Author SHA1 Message Date
MasseR 05263fed2b Easier files 2026-11-03 15:05:18 +02:00
MasseR 6e35445090 Much improved hallway handling 2026-11-03 14:47:01 +02:00
MasseR 95fcc61c4f HallwaySpec: readable clock helper, fix expectations for added Tick 2026-11-02 18:41:29 +02:00
MasseR 2039d03a5e Add failing spec for hallway lights automation 2026-11-02 18:13:31 +02:00
MasseR 868a5d7e4f Refactor bedroom presence controller to parallel arrows style 2026-11-01 13:10:54 +02:00
MasseR d710251a4e Document bedroom presence and sleep mode guard behavior with tests 2026-11-01 13:05:53 +02:00
MasseR c78f5a4a6d Kids light on a transition 2026-11-01 12:48:52 +02:00
MasseR 889ad1c091 Turn on sleep mode only if there are any lights already on 2026-11-01 12:46:30 +02:00
MasseR 5f8b3cbe00 Refactor to a more arrows style syntax 2026-10-24 00:18:04 +03:00
MasseR 078f24e4b9 Fix tests and add tests for kitchen lights 2026-10-23 23:57:05 +03:00
MasseR 15e50322c4 Making the controllers more linear
Basically, the idea of `(oneBranch <> secondBranch)` instead of

```
do
x <- foo
case x of
  ...
```
2026-10-23 22:55:06 +03:00
MasseR 617bd255ff Diagrams 2026-10-23 16:00:19 +03:00
MasseR 022342af32 Make the type variable 2026-10-22 12:17:58 +03:00
MasseR 6caa2acafb Merge pull request 'Statistics page' (#7) from statistics-page into main
Reviewed-on: #7
2026-10-12 16:06:16 +03:00
21 changed files with 717 additions and 165 deletions

No files matched your search

+2
View File
@@ -6,6 +6,8 @@ dist-newstyle
docs/superpowers/plans
*.dat
handlers.json
*.hp
*.eventlog
*.eventlog.html
+3
View File
@@ -60,6 +60,7 @@ library
-- Modules exported by the library.
exposed-modules: AFRP
, AFRP.Diagram
, HomeAssistant.Controller
, HomeAssistant.Controller.Bedroom
, HomeAssistant.Controller.Children
@@ -181,6 +182,7 @@ test-suite home-assistant-controller-test
, ConnectionSpec
, FlagsSpec
, GraphingSpec
, HallwaySpec
, HttpServerSpec
, KitchenSpec
, LivingroomSpec
@@ -188,6 +190,7 @@ test-suite home-assistant-controller-test
, RuntimeSpec
, Support
, ControllerSpec
, PresenceSpec
-- LANGUAGE extensions used by modules in this package.
-- other-extensions:
+57 -25
View File
@@ -1,11 +1,13 @@
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE Arrows #-}
{-# LANGUAGE TypeOperators #-}
module AFRP
( Mealy(..)
, Auto(..)
, DecodedAuto(..)
, eff
, withEntities
, named
, Event(..)
, hold
, holdKnown
@@ -18,8 +20,10 @@ module AFRP
, changes
, whenA
, filterA
, filterEvent
, thenA
, (>>|)
, (>>||)
, toEvent
, lMerge
, Pair(..)
@@ -27,6 +31,7 @@ module AFRP
, SerializeUTCTime(..)
, SerializeLocalTime(..)
, edge
, edgeFrom
, waitFor
, duration
, tag
@@ -67,6 +72,8 @@ import qualified Data.Conduit.Cereal as CC
import qualified Conduit as C
import Control.Monad.Catch (MonadCatch, handle)
import Control.Exception.Annotated (throw)
import AFRP.Diagram
import Data.Text (Text)
data Codec s = Codec { getter :: !(Get s), putter :: !(Putter s) }
@@ -257,54 +264,58 @@ load path a = handle defaultOnMissingFile (flip deserialize a <$> liftIO (B.read
| isDoesNotExistError e = pure $ FailDecode "State doesn't exist yet" a
| otherwise = throw e
-- | The set of entity ids an arrow subscribes to. Static: it does not
-- change as the machine steps, so the runtime can read it once to build
-- trigger subscriptions.
data Mealy eff a b = Mealy
{ entities :: S.Set T.Text
, runDiagramC :: forall x. (DiagramF x -> x) -> x
, runMealy :: forall m. Monad m => (forall x. eff x -> m x) -> Auto m a b
}
-- Provide a name
named :: Text -> Mealy eff a b -> Mealy eff a b
named n f = f{runDiagramC = \run -> run (Step n (runDiagramC f run))}
instance Semigroup b => Semigroup (Mealy eff a b) where
Mealy ast af <> Mealy bst bf = Mealy (ast <> bst) $ \nt -> af nt <> bf nt
Mealy ast ad af <> Mealy bst bd bf = Mealy (ast <> bst) (combineDiagram Merge ad bd) $ \nt -> af nt <> bf nt
instance Monoid b => Monoid (Mealy eff a b) where
mempty = Mealy mempty $ \_nt -> mempty
mempty = Mealy mempty emptyDiagram $ \_nt -> mempty
eff :: (Request -> a -> eff b) -> Mealy eff a b
eff f = Mealy mempty $ \nt -> do
eff f = Mealy mempty emptyDiagram $ \nt -> do
Stateful (Codec get put) (State () False) $ \s req a -> do
b <- nt (f req a)
pure (b, s)
-- | Override the static entity set of an arrow. Use when a combinator
-- (e.g. 'switch') hides continuation entities from the runtime's
-- startup subscription scan.
withEntities :: S.Set T.Text -> Mealy eff a b -> Mealy eff a b
withEntities es (Mealy _ f) = Mealy es f
instance Category (Mealy eff) where
{- HLINT ignore "Use const" -}
id = Mealy mempty $ \_nt -> id
(Mealy ast f) . (Mealy bst g) = Mealy (ast <> bst) $ \nt -> do
id = Mealy mempty emptyDiagram $ \_nt -> id
(Mealy ast ad f) . (Mealy bst bd g) = Mealy (ast <> bst) (combineDiagram Then bd ad) $ \nt -> do
f nt . g nt
instance Arrow (Mealy eff) where
arr f = Mealy mempty $ \_nt -> arr f
first (Mealy st f) = Mealy st $ \nt -> first (f nt)
arr f = Mealy mempty emptyDiagram $ \_nt -> arr f
first (Mealy st d f) = Mealy st d $ \nt -> first (f nt)
(Mealy ast ad f) &&& (Mealy bst bd g) = Mealy (ast <> bst) (combineDiagram Both ad bd) $ \nt -> do
f nt &&& g nt
instance ArrowChoice (Mealy eff) where
left (Mealy st f) = Mealy st $ \nt -> left (f nt)
left (Mealy st d f) = Mealy st d $ \nt -> left (f nt)
(Mealy ast ad f) +++ (Mealy bst bd g) = Mealy (ast <> bst) (combineDiagram Branch ad bd) $ \nt -> do
f nt +++ g nt
instance Functor (Mealy eff a) where
fmap f (Mealy st g) = Mealy st $ \nt -> fmap f (g nt)
fmap f (Mealy st d g) = Mealy st d $ \nt -> fmap f (g nt)
instance Applicative (Mealy eff a) where
pure b = Mealy mempty $ \_ -> pure b
Mealy ast f <*> Mealy bst x = Mealy (ast <> bst) $ \nt ->
pure b = Mealy mempty emptyDiagram $ \_ -> pure b
Mealy ast ad f <*> Mealy bst bd x = Mealy (ast <> bst) (combineDiagram Compose ad bd) $ \nt ->
f nt <*> x nt
data Event a
@@ -332,7 +343,7 @@ hold def = mapAccum step def id
holdKnown :: (Serialize a, Eq a) => Mealy m (Event a) (Maybe a)
holdKnown = arr (fmap Just) >>> hold Nothing
snapshot :: (Serialize a, Eq a) => a -> Mealy m (Event (), a) a
snapshot :: (Serialize a, Eq a) => a -> Mealy m (Event x, a) a
snapshot def = mapAccum step def id
where
step prev (Tick, _) = prev
@@ -369,10 +380,10 @@ preMapAccum' f x extract = Stateful (Codec get put) (pure x) (\s _req a -> pure
mapAccum :: (Eq x, Serialize x) => (x -> a -> x) -> x -> (x -> b) -> Mealy eff a b
mapAccum step x extract = Mealy mempty $ \_nt -> mapAccum' step x extract
mapAccum step x extract = Mealy mempty emptyDiagram $ \_nt -> mapAccum' step x extract
preMapAccum :: (Eq x, Serialize x) => (x -> a -> x) -> x -> (x -> b) -> Mealy eff a b
preMapAccum step x extract = Mealy mempty $ \_nt -> preMapAccum' step x extract
preMapAccum step x extract = Mealy mempty emptyDiagram $ \_nt -> preMapAccum' step x extract
mapAccum' :: forall m x a b. (Monad m, Eq x, Serialize x) => (x -> a -> x) -> x -> (x -> b) -> Auto m a b
mapAccum' f x extract = Stateful (Codec get put) (pure x) (\s _req a -> pure $ step s a)
@@ -381,7 +392,7 @@ mapAccum' f x extract = Stateful (Codec get put) (pure x) (\s _req a -> pure $ s
step s a = let s' = f (state s) a in (extract s', State s' (dirty s || state s /= s'))
preMapAccumRequest :: (Serialize x, Eq x) => (Request -> x -> a -> x) -> x -> (x -> b) -> Mealy eff a b
preMapAccumRequest step x extract = Mealy mempty $ \_ -> preMapAccumRequest' step x extract
preMapAccumRequest step x extract = Mealy mempty emptyDiagram $ \_ -> preMapAccumRequest' step x extract
preMapAccumRequest' :: forall m x a b. (Serialize x, Eq x, Monad m) => (Request -> x -> a -> x) -> x -> (x -> b) -> Auto m a b
preMapAccumRequest' f x extract = Stateful (Codec get put) (State x False) (\s req a -> pure $ step s req a)
@@ -390,7 +401,7 @@ preMapAccumRequest' f x extract = Stateful (Codec get put) (State x False) (\s r
step s req a = let s' = f req (state s) a in (extract (state s), State s' (dirty s || state s /= s'))
mapAccumRequest :: (Serialize x, Eq x) => (Request -> x -> a -> x) -> x -> (x -> b) -> Mealy eff a b
mapAccumRequest step x extract = Mealy mempty $ \_ -> mapAccumRequest' step x extract
mapAccumRequest step x extract = Mealy mempty emptyDiagram $ \_ -> mapAccumRequest' step x extract
mapAccumRequest' :: forall m x a b. (Monad m, Serialize x, Eq x) => (Request -> x -> a -> x) -> x -> (x -> b) -> Auto m a b
mapAccumRequest' f x extract = Stateful (Codec get put) (State x False) (\s req a -> pure $ step s req a)
@@ -484,6 +495,13 @@ whenA predicate auto = arr (\a -> if predicate a then Left a else Right ()) >>>
filterA :: (a -> Bool) -> Mealy eff a (Either () a)
filterA f = arr $ \a -> bool (Left ()) (Right a) (f a)
-- filters events through if they match the predicate
filterEvent :: (ArrowChoice cat, Arrow cat) => (a -> Bool) -> Event a `cat` Event a
filterEvent predicate = proc ev -> do
case ev of
Event a | predicate a -> id -< ev
_ -> arr (const Tick) -< ()
thenA :: (ArrowChoice cat, Arrow cat) => cat a (Either b1 c) -> cat c (Either b1 b2) -> cat a (Either b1 b2)
thenA f g = f >>> arr Left ||| g
@@ -492,6 +510,15 @@ thenA f g = f >>> arr Left ||| g
infixl 2 >>|
(>>||) :: (ArrowChoice cat, Arrow cat) => cat a (Event b) -> cat b c -> cat a (Event c)
f >>|| g = proc x -> do
e <- f -< x
case e of
Event e' -> g >>> arr Event -< e'
Tick -> arr (const Tick) -< ()
infixr 1 >>||
toEvent :: Mealy eff (Either () a) (Event a)
toEvent = arr (either (const Tick) Event)
@@ -502,10 +529,15 @@ lMerge (Event a) _ = Event a
lMerge Tick (Event a) = Event a
edge :: Mealy eff Bool (Event ())
edge =
edge = edgeFrom False
-- | Edge that behaves as if the input has been `start` forever, so the first
-- True input does not fire when `start` is already True (no transition).
edgeFrom :: Bool -> Mealy eff Bool (Event ())
edgeFrom start =
mapAccum
(\(_, current) new -> (current, new))
(False, False)
(start, start)
(\(old, current) ->
if not old && current
then Event ()
@@ -606,7 +638,7 @@ requestLocalTime :: Request -> LocalTime
requestLocalTime Request{requestTime, requestTimeZone} = utcToLocalTime requestTimeZone requestTime
currentTime :: Mealy eff a LocalTime
currentTime = Mealy mempty $ \_nt -> Fun $ \req _ ->
currentTime = Mealy mempty emptyDiagram $ \_nt -> Fun $ \req _ ->
requestLocalTime req
+49
View File
@@ -0,0 +1,49 @@
{-# LANGUAGE OverloadedStrings #-}
module AFRP.Diagram where
import Data.Text (Text)
import qualified Text.Printf as Text
import qualified Data.Text as T
-- For rendering the arrows
data DiagramF f
= Empty
| Step Text f -- Named step
| Then f f -- >>>
| Both f f -- &&&
| Branch f f -- |||
| Merge f f -- <>
| Compose f f -- <*>
type DiagramAlgebra a = DiagramF a -> a
type DiagramC= forall a. DiagramAlgebra a -> a
combineDiagram :: (forall a. a -> a -> DiagramF a) -> DiagramC -> DiagramC -> DiagramC
combineDiagram constructor a b r = r (constructor (a r) (b r))
emptyDiagram :: DiagramC
emptyDiagram r = r Empty
renderF :: DiagramF (Maybe T.Text) -> Maybe T.Text
renderF = \case
Empty -> Nothing
Step n x -> Just $ n <> T.pack (maybe "" (Text.printf "( %s )") x)
Then (Just a) (Just b) -> Just $ a <> " -> " <> b
Then (Just a) _ -> Just a
Then _ b -> b
Both (Just a) (Just b) -> Just $ T.pack $ Text.printf "(%s, %s)" a b
Both (Just a) _ -> Just a
Both _ b -> b
Branch (Just a) (Just b) -> Just $ T.pack $ Text.printf "(%s || %s)" a b
-- I'm leaving this here. This would be technically more correct (showing
-- the empty branch, ie. the full if-then-else, but often we care about a
-- more simplistic `when` style structure
-- Branch (Just a) Nothing -> Just $ T.pack $ Text.printf "(%s || <skip>)" a
Branch (Just a) Nothing -> Just $ T.pack $ Text.printf "%s" a
Branch _ b -> b
Merge (Just a) (Just b) -> Just $ T.pack $ Text.printf "(%s, %s)" a b
Merge (Just a) _ -> Just a
Merge _ b -> b
Compose (Just a) (Just b) -> Just $ T.pack $ Text.printf "(%s, %s)" a b
Compose (Just a) _ -> Just a
Compose _ b -> b
+62 -56
View File
@@ -1,21 +1,18 @@
{-# LANGUAGE Arrows #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DerivingVia #-}
module HomeAssistant.Controller.Bedroom where
import HomeAssistant.Controller
import qualified Data.Text as T
import AFRP (Event (..), lMerge, duration, edge)
import AFRP (Event (..), edge, filterEvent, hold, named, snapshot, tag, waitFor, (>>||))
import Data.Aeson (Value, object, (.=))
import Control.Arrow ((>>>), returnA, arr, Arrow (..))
import Data.Bool (bool)
import Data.Time (NominalDiffTime)
import qualified AFRP
import Data.Map (Map)
import qualified Data.Map.Strict as M
import Data.Serialize.Text ()
import Data.Default (def)
import Data.Serialize (Serialize)
@@ -37,46 +34,58 @@ createBedroomScene = Service
bedroomPresence :: HASS (Event Value) (Event Presence)
bedroomPresence = presence "binary_sensor.presence_sensor_bedroom_occupancy"
presenceLightEvents :: HASS (Event Value) (Event LightingMode)
presenceLightEvents =
bedroomPresence >>> AFRP.hold Unoccupied
>>> arr lightWanted
>>> (sleepEvent &&& offEvent &&& onEvent)
>>> arr (\(s,(o,n)) -> s `AFRP.lMerge` o `AFRP.lMerge` n)
where
lightWanted o = o == Occupied
sleepEvent = arr not >>> AFRP.edge >>> arr (AFRP.tag LightingSleep)
onEvent = AFRP.edge >>> arr (AFRP.tag LightingOn)
offEvent = arr not >>> AFRP.waitFor 300 >>> arr (AFRP.tag LightingOff)
bedroomPresenceOccupied :: HASS (Event Value) Bool
bedroomPresenceOccupied = bedroomPresence >>> hold Unoccupied >>> arr (== Occupied)
bedroomLightStatus :: HASS (Event Value) (Map T.Text LightObservation)
bedroomLightStatus = M.fromList <$> traverse (\e -> (e,) <$> observedLight e) [e | EntityId e <- bedroomLightTargets]
newtype Snapshot = Snapshot { getSnapshot :: Map T.Text LightObservation }
deriving (Show, Eq)
deriving Serialize via (Map T.Text LightObservation)
lightLevel :: HASS (Event Value) Int
lightLevel = entityRead "sensor.presence_sensor_bedroom_light_level" >>> AFRP.hold 1
-- Snapshot the light status when leaving (presence turning unoccupied),
-- restored on the next entry.
snapshotOnLeaving :: HASS (Event Value) (Map T.Text LightObservation)
snapshotOnLeaving =
(bedroomPresenceOccupied &&& bedroomLightStatus)
>>> first (arr not >>> edge)
>>> snapshot M.empty
-- The light reactions run "in parallel"; there is a chance that two
-- services are called in one go
bedroomPresenceController :: HASS (Event Value) ()
bedroomPresenceController = proc x -> do
p <- presenceLightEvents >>> traceEvent -< x
capped <- lightLevel >>> arr (< 4) -< x
snap <- (doSnapshot &&& bedroomLightStatus) >>> AFRP.snapshot M.empty >>> arr Snapshot -< x
-- This line is just for debugging
_ <- AFRP.changes >>> traceEvent -< snap
case p of
Event LightingOff -> do
callService (light bedroomLightTargets Off) -< ()
Event LightingOn -> do
callServicesDyn (\(c,xs) -> concatMap (uncurry (toLight c)) xs) -< (capped, M.toList (getSnapshot snap))
returnA -< ()
Event LightingSleep -> do
callService (activateScene "scene.makuuhuone_lepotila") -< ()
_ -> returnA -< ()
bedroomPresenceController =
((,,,) <$> bedroomPresenceOccupied <*> cappedLightLevel <*> bedroomLightStatus <*> snapshotOnLeaving)
>>> mconcat
[ AFRP.named "Lights on" lightsOn
, AFRP.named "Lights sleep" lightsSleep
, AFRP.named "Lights off" lightsOff
]
>>> arr (const ()) -- I don't like this extra arr here
where
cappedLightLevel :: HASS (Event Value) Bool
cappedLightLevel = lightLevel >>> arr (< 4)
lightsOn =
arr (\(o, capped, _, snap) -> (o, (capped, M.toList snap)))
>>> first edge
>>> arr (\(ev, p) -> tag p ev)
>>|| callServicesDyn "Turn on lights (capped)" (\(c,xs) -> concatMap (uncurry (toLight c)) xs)
lightsSleep =
arr (\(o, _, st, _) -> (not o, st))
>>> first edge
>>> arr (\(ev, st) -> tag st ev)
>>> filterEvent anyLightsAreOn
>>|| callService "Turn on sleep" (activateScene "scene.makuuhuone_lepotila")
lightsOff =
arr (\(o, _, _, _) -> not o)
>>> waitFor 300
>>|| callService "Turn off lights" (light bedroomLightTargets Off)
anyLightsAreOn :: Foldable f => f LightObservation -> Bool
anyLightsAreOn = any observedOn
toLight :: Bool -> T.Text -> LightObservation -> [Service]
toLight _ entityId LightObservation{observedOn=False} = [light [EntityId entityId] Off]
toLight capped entityId LightObservation{observedOn=True, observedTemperature=t, observedBrightness=b} =
@@ -85,8 +94,6 @@ bedroomPresenceController = proc x -> do
, lightColorTemperature = t
})
]
doSnapshot = presenceLightEvents
>>> arr (\ev -> if ev == Event LightingSleep then Event () else Tick)
data BedroomControls
@@ -110,21 +117,21 @@ bedroomButtonController = proc x -> do
-- Any event will cause the sleep mode to be turned off
case ev of
Event (Masse (OnButton ShortRelease)) -> do
callService (activateScene "scene.makuuhuone_masse") -< ()
callService "scene.makuuhuone_masse" (activateScene "scene.makuuhuone_masse") -< ()
Event (Masse (OnButton DoubleClick)) -> do
callService (activateScene "scene.makuuhuone_keski") -< ()
callService "scene.makuuhuone_keski" (activateScene "scene.makuuhuone_keski") -< ()
Event (Masse (OnButton LongClick)) -> do
callService (activateScene "scene.makuuhuone_kirkas") -< ()
callService "scene.makuuhuone_kirkas" (activateScene "scene.makuuhuone_kirkas") -< ()
Event (Masse (OffButton _)) -> do
callService (light [AreaId "makuuhuone"] Off) -< ()
callService "Lights off" (light [AreaId "makuuhuone"] Off) -< ()
Event (Enishen (OnButton ShortRelease)) -> do
callService (activateScene "scene.makuuhuone_jemina") -< ()
callService "scene.makuuhuone_jemina" (activateScene "scene.makuuhuone_jemina") -< ()
Event (Enishen (OnButton DoubleClick)) -> do
callService (activateScene "scene.makuuhuone_keski") -< ()
callService "scene.makuuhuone_keski" (activateScene "scene.makuuhuone_keski") -< ()
Event (Enishen (OnButton LongClick)) -> do
callService (activateScene "scene.makuuhuone_kirkas") -< ()
callService "scene.makuuhuone_kirkas" (activateScene "scene.makuuhuone_kirkas") -< ()
Event (Enishen (OffButton _)) -> do
callService (light [AreaId "makuuhuone"] Off) -< ()
callService "Lights off" (light [AreaId "makuuhuone"] Off) -< ()
_ -> returnA -< ()
@@ -134,22 +141,21 @@ drawer = entityBool "binary_sensor.bedroom_nightstand_drawer_sensor_masse_contac
>>> arr (fmap (bool Closed Open))
bedroomDrawerController :: HASS (Event Value) ()
bedroomDrawerController = proc x -> do
st <- drawer >>> traceEvent -< x
case st of
Event Open -> callService (switchService [entity] True) -< ()
Event Closed -> callService (switchService [entity] False) -< ()
_ -> returnA -< ()
bedroomDrawerController =
drawer >>>
(named "Drawer opened" lightOn <> named "Drawer closed" lightOff)
>>> arr (const ())
where
entity = EntityId "switch.bedroom_drawer_light_masse"
lightOff = filterEvent (== Closed)
>>|| callService "drawer light off" (switchService [entity] False)
lightOn = filterEvent (== Open)
>>|| callService "drawer light on" (switchService [entity] True)
door :: HASS (Event Value) (Event DoorState)
door = entityBool "binary_sensor.makuuhuone_ovi_contact"
>>> arr (fmap (bool Closed Open))
waitFor :: NominalDiffTime -> HASS a (Event ())
waitFor n = duration >>> arr (> n) >>> edge
delayedDoor :: HASS (Event Value) (Event DoorState)
delayedDoor = door
@@ -163,8 +169,8 @@ humidifierController = proc x -> do
case st of
-- Turn the humidifier on when the door is closed
-- the humidifier is low-powered, no point in losing all the humidity
Event Open -> callService (humidifier False) -< ()
Event Closed -> callService (humidifier True) -< ()
Event Open -> callService "Humidifier off" (humidifier False) -< ()
Event Closed -> callService "Humidifier on" (humidifier True) -< ()
_ -> returnA -< ()
where
humidifier state = Service
+10 -8
View File
@@ -85,11 +85,13 @@ schoolLightController = lightsOn <> lightsOff
lightsOn :: HASS a ()
lightsOn = foldMap atTime timersOn
>>> AFRP.onEvent (callService (light [AreaId "lasten_makuuhuone"] (On def{lightBrightness=Just $ BrightnessPercent 100} )))
>>> AFRP.onEvent (callService "Lights on" lights)
where
lights = light [AreaId "lasten_makuuhuone"] (On def{lightBrightness=Just (BrightnessPercent 100), lightTransition = Just 5} )
lightsOff :: HASS a ()
lightsOff = foldMap atTime timersOff
>>> AFRP.onEvent (callService (light [AreaId "lasten_makuuhuone"] Off))
>>> AFRP.onEvent (callService "Lights off" (light [AreaId "lasten_makuuhuone"] Off))
childrenBedroomButton :: HASS (Event Value) (Event (IkeaButton IkeaGesture))
@@ -99,10 +101,10 @@ childrenBedroomButtonController :: HASS (Event Value) ()
childrenBedroomButtonController = proc x -> do
ev <- childrenBedroomButton >>> traceEvent -< x
case ev of
Event (OnButton ShortRelease) -> callService (activateScene "scene.lasten_nukkuvalmistelu") -< ()
Event (OnButton DoubleClick) -> callService (activateScene "scene.lasten_luku") -< ()
Event (OnButton LongClick) -> callService (activateScene "scene.lasten_kirkas") -< ()
Event (OffButton _) -> callService (light [AreaId "lasten_makuuhuone"] Off) -< ()
Event (OnButton ShortRelease) -> callService "scene.lasten_nukkuvalmistelu" (activateScene "scene.lasten_nukkuvalmistelu") -< ()
Event (OnButton DoubleClick) -> callService "scene.lasten_luku" (activateScene "scene.lasten_luku") -< ()
Event (OnButton LongClick) -> callService "scene.lasten_kirkas" (activateScene "scene.lasten_kirkas") -< ()
Event (OffButton _) -> callService "Lights off" (light [AreaId "lasten_makuuhuone"] Off) -< ()
_ -> returnA -< ()
newtype PM25 = PM25 Float
@@ -153,8 +155,8 @@ childrenAirFilterController = proc ev -> do
humidifier <- humidifierOperatingState >>> AFRP.holdKnown >>> arr join -< ev
case level of
Event PM25High ->
AFRP.whenA (== Just Idle) (callService (fanOnTo (Percentage 80))) -< humidifier
Event PM25Low -> callService (fanOnTo (Percentage 20)) -< ()
AFRP.whenA (== Just Idle) (callService "Fan strong" (fanOnTo (Percentage 80))) -< humidifier
Event PM25Low -> callService "Fan low" (fanOnTo (Percentage 20)) -< ()
_ -> returnA -< ()
where
fanOnTo percentage = Service
+10 -1
View File
@@ -1,9 +1,18 @@
module HomeAssistant.Controller.Door (DoorState(..)) where
module HomeAssistant.Controller.Door (DoorState(..), doorState) where
import GHC.Generics (Generic)
import Data.Serialize (Serialize)
import AFRP (Mealy, Event)
import Data.Aeson (Value)
import Data.Text (Text)
import HomeAssistant.Controller.Entity (entityBool)
import Control.Arrow ((>>>), arr)
import Data.Bool (bool)
data DoorState = Open | Closed
deriving (Show, Eq, Generic)
instance Serialize DoorState
doorState :: Text -> Mealy eff (Event Value) (Event DoorState)
doorState entity = entityBool entity >>> arr (fmap (bool Closed Open))
+15 -10
View File
@@ -1,5 +1,6 @@
{-# LANGUAGE Arrows #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE OverloadedStrings #-}
module HomeAssistant.Controller.Effect
( HASSEff(..)
@@ -13,9 +14,10 @@ module HomeAssistant.Controller.Effect
, traceValue
) where
import AFRP (Mealy, eff, Event (..), Request)
import AFRP (Mealy, eff, Event (..), Request, named)
import Control.Arrow (returnA)
import HomeAssistant.Controller.Service (Service)
import HomeAssistant.Controller.Service (Service (..))
import qualified Data.Text as T
data HASSEff a where
CallService :: Request -> Service -> HASSEff ()
@@ -25,17 +27,20 @@ data HASSEff a where
type HASS a b = Mealy HASSEff a b
callService :: Service -> HASS a ()
callService service = eff (\req _ -> CallService req service)
serviceLabel :: T.Text -> HASS a b -> HASS a b
serviceLabel lbl = named ("Service: " <> lbl)
callServices :: [Service] -> HASS a ()
callServices service = eff (\req _ -> CallServices req service)
callService :: T.Text -> Service -> HASS a ()
callService lbl service = serviceLabel lbl $ eff (\req _ -> CallService req service)
callServiceDyn :: (a -> Service) -> HASS a ()
callServiceDyn mkService = eff (\req a -> CallService req (mkService a))
callServices :: T.Text -> [Service] -> HASS a ()
callServices lbl service = serviceLabel lbl $ eff (\req _ -> CallServices req service)
callServicesDyn :: (a -> [Service]) -> HASS a ()
callServicesDyn mkService = eff (\req a -> CallServices req (mkService a))
callServiceDyn :: T.Text -> (a -> Service) -> HASS a ()
callServiceDyn lbl mkService = serviceLabel lbl $ eff (\req a -> CallService req (mkService a))
callServicesDyn :: T.Text -> (a -> [Service]) -> HASS a ()
callServicesDyn lbl mkService = serviceLabel lbl $ eff (\req a -> CallServices req (mkService a))
debug :: Show a => HASS a a
debug = proc x -> do
+3 -2
View File
@@ -10,7 +10,7 @@ module HomeAssistant.Controller.Entity
, entityBool'
) where
import AFRP (Mealy (..), Event, events, filterA, (>>|), toEvent)
import AFRP (Mealy (..), Event, events, filterA, (>>|), toEvent, named)
import Control.Arrow (arr)
import Control.Category ((>>>))
import Data.Aeson (Value)
@@ -19,12 +19,13 @@ import qualified Data.Text as T
import qualified Data.Set as S
import Control.Lens (has, only, (^?), to)
import qualified Data.Text.Lens as TL
import AFRP.Diagram (emptyDiagram)
entityChangeEvent :: T.Text -> Mealy eff (Event Value) (Event Value)
entityChangeEvent entityId = entityChangeEvent' entityId >>> toEvent
entityChangeEvent' :: T.Text -> Mealy eff (Event Value) (Either () Value)
entityChangeEvent' entityId = Mealy (S.singleton entityId) $ runMealy (events >>| filterA isEntity)
entityChangeEvent' entityId = named entityId $ Mealy (S.singleton entityId) emptyDiagram $ runMealy (events >>| filterA isEntity)
where
isEntity :: Value -> Bool
isEntity = has (key "event" . key "variables" . key "trigger" . key "entity_id" . _String . only entityId)
+74 -15
View File
@@ -1,31 +1,90 @@
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE Arrows #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE RecordWildCards #-}
module HomeAssistant.Controller.Hallway where
import HomeAssistant.Controller (Presence, HASS, motion, motionToPresence, traceEvent, callServiceDyn, light, Target (..), LightCommand (..))
import HomeAssistant.Controller.Light.Mode (LightingMode (..), lightingModeEvents)
import HomeAssistant.Controller (Presence (..), HASS, motion, motionToPresence, callServiceDyn, light, Target (..), LightCommand (..), doorState, DoorState (Closed), callService)
import AFRP (Event (..))
import qualified AFRP
import Data.Aeson (Value)
import Control.Arrow ((>>>), returnA)
import Control.Arrow ((>>>), arr, returnA)
import Data.Time (LocalTime(..), TimeOfDay (..))
import Data.Default (def)
import Data.Serialize (Serialize)
import GHC.Generics (Generic)
data Mode
= Quiet -- ^ Possibly sleep time, doors are open, minimize light leakage
| Regular -- ^ Doors are closed, light leakage is not a concern
deriving (Generic, Eq, Show)
instance Serialize Mode
data ModeInput = ModeInput
{ roomTimeOfDay :: TimeOfDay
, bedroomDoor :: Maybe DoorState
, childrenBedroomDoor :: Maybe DoorState
}
mode :: HASS (Event Value) Mode
mode = roomState >>> arr sleepMode
where
sleepMode :: ModeInput -> Mode
sleepMode ModeInput{bedroomDoor = Just Closed, childrenBedroomDoor = Just Closed} = Regular
sleepMode ModeInput{..}
| roomTimeOfDay > TimeOfDay 20 30 0 || roomTimeOfDay < TimeOfDay 7 30 0 = Quiet
| otherwise = Regular
roomState = ModeInput <$> timeOfDay <*> masterBedroom <*> childrenBedroom
timeOfDay = fmap localTimeOfDay AFRP.currentTime
masterBedroom = doorState "binary_sensor.makuuhuone_ovi_contact" >>> AFRP.holdKnown
childrenBedroom = doorState "binary_sensor.lasten_makuuhuone_ovi_contact" >>> AFRP.holdKnown
hallwayPresence :: HASS (Event Value) Presence
hallwayPresence = motion "binary_sensor.hallway_movement_occupancy" >>> motionToPresence 500
hallwayLightsController :: HASS (Event Value) ()
hallwayLightsController = proc x -> do
now <- AFRP.currentTime -< ()
p <- hallwayPresence -< x
ev <- lightingModeEvents -< p
traceEvent -< ev
case ev of
-- The lights entity is a "group of lights" in hass
Event LightingOn | lightsAllowed now -> callServiceDyn (light [EntityId "light.hallway_lights"]) -< On def
Event LightingOff -> callServiceDyn (light [EntityId "light.hallway_lights"]) -< Off
_ -> returnA -< ()
lightsOnTrigger :: HASS (Event Value) (Event ())
lightsOnTrigger = hallwayPresence >>> arr (== Occupied) >>> AFRP.edge
modeTrigger :: HASS (Event Value) (Event Mode)
modeTrigger = ((,) <$> hallwayPresence <*> (mode >>> AFRP.changes)) >>> arr go
where
lightsAllowed (LocalTime _ tod) = not (tod > TimeOfDay 1 45 0 && tod < TimeOfDay 5 0 0)
go (Unoccupied, _) = Tick
go (Occupied, e) = e
modeC :: HASS (Event Value) ()
modeC = modeTrigger >>> mconcat
[ AFRP.filterEvent (== Quiet) AFRP.>>|| lightOff
, AFRP.filterEvent (== Regular) AFRP.>>|| lightOn
] >>>
arr (const ())
where
lightOff = callService "Lower light off" (light [EntityId "light.hallway_ceiling"] Off)
lightOn = callService "Lower light back on" (light [EntityId "light.hallway_ceiling"] (On def))
onC :: HASS (Event Value) ()
onC = proc ev -> do
trigger <- lightsOnTrigger -< ev
m <- mode -< ev
let entities = case m of
Quiet -> [EntityId "light.hallway_ceiling_2"]
Regular -> [EntityId "light.hallway_lights"]
case trigger of
Event _ -> lightsOn -< entities
Tick -> returnA -< ()
where
lightsOn = callServiceDyn "Lights on" (\es -> light es (On def))
lightsOffTrigger :: HASS (Event Value) (Event ())
lightsOffTrigger = hallwayPresence >>> arr (== Unoccupied) >>>
AFRP.edgeFrom True -- we start from 'edgeFrom True' because the initial state is to be unoccupied
offC :: HASS (Event Value) ()
offC = (lightsOffTrigger AFRP.>>|| lightsOff) >>>
arr (const ())
where
lightsOff = callService "Lights off" (light [EntityId "light.hallway_lights"] Off)
hallwayLightsController :: HASS (Event Value) ()
hallwayLightsController = onC <> offC <> modeC
+23 -28
View File
@@ -2,7 +2,7 @@
{-# LANGUAGE Arrows #-}
module HomeAssistant.Controller.Kitchen where
import HomeAssistant.Controller
import AFRP (Event (..))
import AFRP (Event (..), (>>||))
import qualified AFRP
import Data.Aeson (Value)
import Control.Arrow ((>>>), Arrow (..), returnA)
@@ -23,8 +23,8 @@ kitchenCeilingController = proc x -> do
ev <- lightingModeEvents -< p
traceEvent -< ev
case ev of
Event LightingOn | lightsAllowed now -> callServiceDyn (light [EntityId "light.kitchen_ceiling"]) -< On def
Event LightingOff -> callServiceDyn (light [EntityId "light.kitchen_ceiling"]) -< Off
Event LightingOn | lightsAllowed now -> callServiceDyn "light.kitchen_ceiling on" (light [EntityId "light.kitchen_ceiling"]) -< On def
Event LightingOff -> callServiceDyn "light.kitchen_ceiling off" (light [EntityId "light.kitchen_ceiling"]) -< Off
_ -> returnA -< ()
where
lightsAllowed (LocalTime _ tod) = not (tod > TimeOfDay 1 45 0 && tod < TimeOfDay 5 0 0)
@@ -36,44 +36,39 @@ dinnerLightLevel = entityRead "sensor.sijainti_keittio_light_level" >>> AFRP.hol
dinnerPresence :: HASS (Event Value) Presence
dinnerPresence = presence "binary_sensor.sijainti_keittio_occupancy" >>> AFRP.hold Unoccupied
dinnerLightEvents :: HASS (Event Value) (Event LightingMode)
dinnerLightEvents =
dinnerTableController :: HASS (Event Value) ()
dinnerTableController =
((,) <$> dinnerLightLevel <*> dinnerPresence)
>>> arr lightWanted
>>> (sleepEvent &&& offEvent &&& onEvent)
>>> arr (\(s, (o, n)) -> s `AFRP.lMerge` o `AFRP.lMerge` n)
-- These are done "in parallel", there is a chance that two services are called in one go
>>> mconcat
[ AFRP.named "Lights on" lightsOn
, AFRP.named "Lights sleep" lightsSleep
, AFRP.named "Lights off" lightsOff ]
>>> arr (const ()) -- I don't like this extra arr here
where
lightWanted (lightLevel, occ) = occ == Occupied && lightLevel < 13
onEvent =
lightsOn =
AFRP.edge
>>> arr (fmap (const LightingOn))
>>|| sleep "sleep off" False
>>> callService "Dining light on" (light [EntityId "light.kitchen_dining_large"] $ On def)
sleepEvent =
lightsSleep =
arr not
>>> AFRP.edge
>>> arr (fmap (const LightingSleep))
>>|| sleep "sleep on" True
offEvent =
lightsOff =
arr not
>>> AFRP.waitFor 300
>>> arr (fmap (const LightingOff))
>>|| sleep "sleep off" False
>>> callService "Dining light on" (light [EntityId "light.kitchen_dining_large"] Off)
sleep lbl b = callService lbl (switchService [EntityId "switch.adaptive_lighting_ruokapoydan_valot_sleep_mode"] b)
dinnerTableController :: HASS (Event Value) ()
dinnerTableController = proc x -> do
ev <- dinnerLightEvents -< x
case ev of
Event LightingOn -> do
sleep -< False
callServiceDyn (light [EntityId "light.kitchen_dining_large"]) -< On def
Event LightingOff -> do
sleep -< False
callServiceDyn (light [EntityId "light.kitchen_dining_large"]) -< Off
Event LightingSleep -> do
sleep -< True
_ -> returnA -< ()
where
sleep = callServiceDyn (switchService [EntityId "switch.adaptive_lighting_ruokapoydan_valot_sleep_mode"])
kitchenMotionController :: HASS (Event Value) ()
kitchenMotionController = kitchenCeilingController <> dinnerTableController
+4 -4
View File
@@ -39,8 +39,8 @@ livingroomPresenceController = proc x -> do
ev <- lightingModeEvents . livingroomPresence -< x
traceEvent -< ev
case ev of
AFRP.Event LightingOn -> callServiceDyn (light livingroomLightTargets) -< On def
AFRP.Event LightingOff -> callServiceDyn (light livingroomLightTargets) -< Off
AFRP.Event LightingOn -> callServiceDyn "Lights on" (light livingroomLightTargets) -< On def
AFRP.Event LightingOff -> callServiceDyn "Lights off" (light livingroomLightTargets) -< Off
_ -> returnA -< ()
returnA -< ()
@@ -88,6 +88,6 @@ livingroomPlantLights = (season &&& tod)
where
setLights = proc mode -> do
case mode of
AFRP.Event Growth -> callService (activateScene "scene.olohuoneen_kasvivalo") -< ()
AFRP.Event Ambience -> callService (activateScene "scene.kasvivalo_iltatila") -< ()
AFRP.Event Growth -> callService "scene.olohuoneen_kasvivalo" (activateScene "scene.olohuoneen_kasvivalo") -< ()
AFRP.Event Ambience -> callService "scene.kasvivalo_iltatila" (activateScene "scene.kasvivalo_iltatila") -< ()
_ -> returnA -< ()
+14 -9
View File
@@ -3,10 +3,11 @@ module HomeAssistant.Controller.Presence
, presence
, Motion(..)
, motion
, motionEvent
, motionToPresence
) where
import AFRP (Event, hold, lMerge, waitFor, tag, edge)
import AFRP (Event, hold, lMerge, waitFor, tag, edge, holdKnown)
import Control.Arrow (arr, (&&&))
import Control.Category ((>>>))
import Data.Aeson (Value)
@@ -28,28 +29,32 @@ presence entityId = entityBool entityId
>>> arr (fmap (bool Unoccupied Occupied))
data Motion = MotionDetected | MotionNotDetected | MotionUnknown
data Motion = MotionDetected | MotionNotDetected
deriving (Show, Eq, Generic)
motion :: T.Text -> HASS (Event Value) Motion
motionEvent :: T.Text -> HASS (Event Value) (Event Motion)
motionEvent entityId = entityBool entityId
>>> arr (fmap (bool MotionNotDetected MotionDetected))
motion :: T.Text -> HASS (Event Value) (Maybe Motion)
motion entityId = entityBool entityId
>>> arr (fmap (bool MotionNotDetected MotionDetected))
>>> hold MotionUnknown
>>> holdKnown
-- Convert a motion status into a simulated presence
--
-- A motion tracker detects _motion_, but if you are still, it can't detect you.
-- A simple and cheap heuristic is to assume the person is a bit longer there
motionToPresence :: NominalDiffTime -> HASS Motion Presence
motionToPresence :: NominalDiffTime -> HASS (Maybe Motion) Presence
motionToPresence delay = (eventOccupied &&& eventUnoccupied)
>>> arr (uncurry lMerge)
>>> AFRP.hold Unoccupied
where
eventOccupied :: HASS Motion (Event Presence)
eventOccupied = arr (== MotionDetected) >>> edge >>> arr (fmap (const Occupied))
eventUnoccupied :: HASS Motion (Event Presence)
eventUnoccupied = arr (== MotionNotDetected) >>> waitFor delay >>> arr (tag Unoccupied)
eventOccupied :: HASS (Maybe Motion) (Event Presence)
eventOccupied = arr (== Just MotionDetected) >>> edge >>> arr (fmap (const Occupied))
eventUnoccupied :: HASS (Maybe Motion) (Event Presence)
eventUnoccupied = arr (== Just MotionNotDetected) >>> waitFor delay >>> arr (tag Unoccupied)
instance Serialize Motion
+5 -2
View File
@@ -42,12 +42,13 @@ import HttpServer qualified
import Katip (KatipContext, Namespace (Namespace), Severity (..), logF, logLocM, ls, runKatipContextT, runKatipT, sl, katipAddNamespace)
import Network.Socket (withSocketsDo)
import System.Environment (getEnv, lookupEnv)
import System.FilePath ((</>))
import System.FilePath ((</>), (<.>))
import System.Metrics qualified
import Text.Read (readMaybe)
import UnliftIO.Async
import Control.Monad.Catch (MonadCatch)
import Control.Exception.Annotated (checkpoint, Annotation (..))
import AFRP.Diagram (renderF)
step :: (MonadIO m) => FilePath -> T.Text -> UUID -> Auto m a b -> a -> m (b, Auto m a b)
step path name trace st a = do
@@ -80,7 +81,7 @@ runController :: forall m. (HasCallStack, MonadCatch m, KatipContext m, MonadIO
runController rootDir bus (Controller name machine) = checkpoint (Annotation name) $ katipAddNamespace ns $ do
inbound <- liftIO $ atomically (dupTChan (busInbound bus))
let workerDefinition = runMealy machine (channelHassEval @m bus)
let path = rootDir </> T.unpack name
let path = rootDir </> T.unpack name <.> "dat"
worker <-
load path workerDefinition >>= \case
Decoded a -> pure a
@@ -122,6 +123,8 @@ defaultMain =
rrdtool <- fromMaybe "rrdtool" <$> liftIO (lookupEnv "HA_RRDTOOL")
metricsPort <- lookupPort
writerLimiter <- slidingWindowLimiter rateLimitMetrics 10 20
forM_ controllers $ \(Controller n m) ->
logLocM InfoS $ ls $ n <> ": " <> fromMaybe "" (runDiagramC m renderF)
let ents = foldMap (\(Controller _ m) -> entities m) controllers
workers =
[ ("reader", readerAction host 8123 token ents bus),
+3 -2
View File
@@ -20,6 +20,7 @@ import qualified Hedgehog.Range as Range
import Test.Hspec
import Test.Hspec.Hedgehog
import Data.Maybe (listToMaybe)
import AFRP.Diagram (emptyDiagram)
fakeRequest :: Request
fakeRequest = Request (sec 0) utc nil "test"
@@ -536,11 +537,11 @@ sampleSpec = describe "sample" $ do
-- | A stateless arrow carrying a fixed entity set, for testing propagation.
subscribed :: S.Set T.Text -> Mealy Identity Int Int
subscribed ents = Mealy ents $ \_ -> Fun $ \_ a -> a
subscribed ents = Mealy ents emptyDiagram $ \_ -> Fun $ \_ a -> a
-- | Same as 'subscribed' but yields a function, for testing '<*>'.
subscribedF :: S.Set T.Text -> Mealy Identity Int (Int -> Int)
subscribedF ents = Mealy ents $ \_ -> Fun $ \_ a -> (a +)
subscribedF ents = Mealy ents emptyDiagram $ \_ -> Fun $ \_ a -> (a +)
entitiesSpec :: Spec
entitiesSpec = describe "entities" $ do
+91 -1
View File
@@ -5,7 +5,10 @@ module BedroomSpec (spec) where
import AFRP (Event (..), entities)
import qualified Data.Set as S
import qualified Data.Text as T
import Data.Aeson (Value)
import Data.Aeson (Value, object, (.=))
import qualified Data.Aeson.Key as Key
import Data.Default (def)
import Data.Time (getCurrentTime, addUTCTime)
import HomeAssistant.Controller
import HomeAssistant.Controller.Bedroom
import Support
@@ -20,11 +23,31 @@ enishenButton = Event . buttonEvent "event.bedroom_quick_jemina_action"
drawerState :: T.Text -> Event Value
drawerState = Event . stateEvent "binary_sensor.bedroom_nightstand_drawer_sensor_masse_contact"
presenceSensor :: T.Text -> Event Value
presenceSensor = Event . stateEvent "binary_sensor.presence_sensor_bedroom_occupancy"
-- Light state event with observed attributes
masseLight :: T.Text -> [(T.Text, Int)] -> Event Value
masseLight state attrs = Event $ object
[ "event" .= object
[ "variables" .= object
[ "trigger" .= object
[ "entity_id" .= ("light.bedroom_masse" :: T.Text)
, "to_state" .= object
[ "state" .= state
, "attributes" .= object [ Key.fromString (T.unpack k) .= v | (k, v) <- attrs ]
]
]
]
]
]
spec :: Spec
spec = describe "Bedroom" $ do
entitySpec
drawerSpec
buttonSpec
presenceSpec
entitySpec :: Spec
entitySpec = describe "entities" $ do
@@ -85,6 +108,73 @@ drawerSpec = describe "bedroomDrawerController" $ do
services (runHASS bedroomDrawerController [Tick])
`shouldBe` [[]]
presenceSpec :: Spec
presenceSpec = describe "bedroomPresenceController" $ do
let sleepScene = activateScene "scene.makuuhuone_lepotila"
it "subscribes to presence, light level and the bedroom lights" $
entities bedroomPresenceController
`shouldBe` S.fromList
[ "binary_sensor.presence_sensor_bedroom_occupancy"
, "sensor.presence_sensor_bedroom_light_level"
, "light.bedroom_ceiling"
, "light.bedroom_jemina"
, "light.bedroom_led_switch"
, "light.bedroom_masse"
]
it "does nothing on Tick" $
services (runHASS bedroomPresenceController [Tick])
`shouldBe` [[]]
it "does nothing when entering for the first time (no snapshot yet)" $
services (runHASS bedroomPresenceController [presenceSensor "on"])
`shouldBe` [[]]
it "activates the sleep scene when leaving with the lights on" $
services (runHASS bedroomPresenceController
[ presenceSensor "on", masseLight "on" [], presenceSensor "off" ])
`shouldBe` [ [], [], [sleepScene] ]
it "does not activate the sleep scene when the lights are off" $
services (runHASS bedroomPresenceController
[ presenceSensor "on", masseLight "on" [], masseLight "off" [], presenceSensor "off" ])
`shouldBe` [ [], [], [], [] ]
it "turns the lights off 300s after leaving" $ do
now <- getCurrentTime
let later = 305 `addUTCTime` now
services (runHASSTimed bedroomPresenceController
[ (now, presenceSensor "on"), (now, presenceSensor "off"), (later, Tick) ])
`shouldBe` [ [], [], [light bedroomLightTargets Off] ]
it "restores the last snapshot when re-entering after sleep" $ do
now <- getCurrentTime
let later = 350 `addUTCTime` now
let masseRestored = light [EntityId "light.bedroom_masse"] (On def
{ lightBrightness = Just (BrightnessAbsolute 140)
, lightColorTemperature = Just 2700
})
services (runHASSTimed bedroomPresenceController
[ (now, presenceSensor "on")
, (now, masseLight "on" [("brightness", 255), ("color_temp_kelvin", 2700)])
, (now, presenceSensor "off")
, (now, Tick)
, (later, presenceSensor "on")
, (later, Tick)
])
`shouldBe` [ []
, []
, [sleepScene]
, []
, [ light [EntityId "light.bedroom_ceiling"] Off
, light [EntityId "light.bedroom_jemina"] Off
, light [EntityId "light.bedroom_led_switch"] Off
, masseRestored
]
, []
]
buttonSpec :: Spec
buttonSpec = describe "bedroomButtonController" $ do
let area = AreaId "makuuhuone"
+211
View File
@@ -0,0 +1,211 @@
{-# LANGUAGE OverloadedStrings #-}
module HallwaySpec (spec) where
import AFRP (Event (..))
import qualified Data.Text as T
import Data.Aeson (Value)
import Data.Bool (bool)
import Data.Default (def)
import Data.List (scanl')
import Data.Time (UTCTime, addUTCTime)
import HomeAssistant.Controller
import HomeAssistant.Controller.Hallway
import Support
import Test.Hspec
import Test.Hspec.Hedgehog
import qualified Hedgehog.Gen as Gen
import qualified Hedgehog.Range as Range
day, night :: UTCTime
day = clock 10 0 -- 10:00, outside sleep hours
night = clock 21 0 -- 21:00, inside sleep hours (20:30 - 07:30)
motionSensor :: T.Text -> Event Value
motionSensor = Event . stateEvent "binary_sensor.hallway_movement_occupancy"
masterDoor :: T.Text -> Event Value
masterDoor = Event . stateEvent "binary_sensor.makuuhuone_ovi_contact"
childrenDoor :: T.Text -> Event Value
childrenDoor = Event . stateEvent "binary_sensor.lasten_makuuhuone_ovi_contact"
-- Same shape as the generator in PresenceSpec: mostly short gaps (< 500s
-- timeout), occasionally a 600s gap so presence can expire and the room can
-- become unoccupied again.
data TestEvent = TestEvent Int (Event Bool)
deriving Show
genTestEvent :: Gen TestEvent
genTestEvent = TestEvent
<$> Gen.frequency [(8, Gen.integral (Range.linear 0 20)), (2, pure 600)]
<*> Gen.frequency [(3, pure Tick), (1, Event <$> Gen.bool)]
-- | Presence and both of its presence-derived triggers, observed in lock-step
-- over the same motion stream, so the triggers can be judged against the
-- intermediate presence value at each step.
presenceProbe :: HASS (Event Value) (Presence, Event (), Event ())
presenceProbe = (,,) <$> hallwayPresence <*> lightsOnTrigger <*> lightsOffTrigger
-- | Expected firing steps: every step that *enters* `target`. The implicit
-- state before the first step is Unoccupied — the room starts unoccupied —
-- so an Unoccupied-trigger never fires at the first step.
edgeSteps :: Presence -> [Presence] -> [Int]
edgeSteps target ps =
[ i
| (i, (prev, p)) <- zip [0 ..] (zip (Unoccupied : ps) ps)
, prev /= target
, p == target
]
spec :: Spec
spec = describe "Hallway" $ do
lightsSpec
presenceTransitionSpec
modeTriggerSpec
presenceTransitionSpec :: Spec
presenceTransitionSpec = describe "presenceTriggers" $
it "fires exactly on the corresponding presence transitions" $ hedgehog $ do
events <- forAll $ Gen.list (Range.linear 0 100) genTestEvent
let steps = drop 1 $ scanl' (flip addUTCTime) day [fromIntegral t | TestEvent t _ <- events]
timed = values (runHASSTimed presenceProbe
(zipWith (\t (TestEvent _ e) ->
(t, stateEvent "binary_sensor.hallway_movement_occupancy" . bool "off" "on" <$> e))
steps events))
presences = [p | (p, _, _) <- timed]
onSteps = [i | (i, (_, Event (), _)) <- zip [0 ..] timed]
offSteps = [i | (i, (_, _, Event ())) <- zip [0 ..] timed]
onSteps === edgeSteps Occupied presences
offSteps === edgeSteps Unoccupied presences
cover 30 "at least one unoccupied -> occupied transition" (not (null onSteps))
cover 30 "at least one occupied -> unoccupied transition" (not (null offSteps))
-- | Presence, the chosen mode and the mode-adjustment trigger observed in
-- lock-step over the same event stream.
modeProbe :: HASS (Event Value) (Presence, Mode, Event Mode)
modeProbe = (,,) <$> hallwayPresence <*> mode <*> modeTrigger
data ModeAction
= Motion Bool -- ^ @True@ is motion detected
| MasterDoor Bool -- ^ @True@ is closed
| ChildrenDoor Bool -- ^ @True@ is closed
| Idle
deriving Show
data ModeEvent = ModeEvent Int ModeAction
deriving Show
genModeEvent :: Gen ModeEvent
genModeEvent = ModeEvent
<$> Gen.frequency [(6, Gen.integral (Range.linear 0 15)), (1, pure 900)]
<*> Gen.frequency [(4, Motion <$> Gen.bool)
,(2, MasterDoor <$> Gen.bool)
,(2, ChildrenDoor <$> Gen.bool)
,(2, pure Idle)
]
modeEventValue :: ModeAction -> Event Value
modeEventValue (Motion b) = Event $ stateEvent "binary_sensor.hallway_movement_occupancy" (bool "off" "on" b)
modeEventValue (MasterDoor b) = Event $ stateEvent "binary_sensor.makuuhuone_ovi_contact" (bool "off" "on" b)
modeEventValue (ChildrenDoor b) = Event $ stateEvent "binary_sensor.lasten_makuuhuone_ovi_contact" (bool "off" "on" b)
modeEventValue Idle = Tick
-- | The mode-adjustment trigger: the presence-based lights are already on
-- (room occupied), the world changed which lights should be on, so adjust.
-- The first observed mode is the baseline the lights-on trigger already
-- acted on, so it is not an adjustment.
modeTriggerSpec :: Spec
modeTriggerSpec = describe "modeTrigger" $
it "fires exactly on occupied steps that change the mode, tagged with the new mode" $ hedgehog $ do
events <- forAll $ Gen.list (Range.linear 0 100) genModeEvent
let steps = drop 1 $ scanl' (flip addUTCTime) (clock 20 0) [fromIntegral t | ModeEvent t _ <- events]
timed = values (runHASSTimed modeProbe
(zipWith (\t (ModeEvent _ a) -> (t, modeEventValue a)) steps events))
modes = [m | (_, m, _) <- timed]
-- The previous mode; at the first step it is the mode itself, since
-- the first observed mode is the baseline the lights-on trigger
-- already acted on, not an adjustment.
prior = case modes of [] -> []; m0 : _ -> m0 : init modes
expected =
[ i
| (i, (prevM, (p, m, _))) <- zip [0 ..] (zip prior timed)
, prevM /= m
, p == Occupied
]
suppressed =
[ () | (prevM, (p, m, _)) <- zip prior timed
, p == Unoccupied
, prevM /= m
]
fired = [i | (i, (_, _, Event _)) <- zip [0 ..] timed]
tags = [(i, tag) | (i, (_, _, Event tag)) <- zip [0 ..] timed]
fired === expected
tags === [(i, m) | i <- expected, let m = modes !! i]
cover 25 "fires at least once" (not (null fired))
cover 25 "suppressed a mode change while unoccupied" (not (null suppressed))
cover 25 "reaches quiet mode" (Quiet `elem` modes)
lightsSpec :: Spec
lightsSpec = do
describe "hallwayLightsController" $ do
it "turns the full lights on when someone enters during daytime" $
services (runHASSTimed hallwayLightsController [(day, motionSensor "on")])
`shouldBe` [[light [EntityId "light.hallway_lights"] (On def)]]
it "turns the full lights on when someone enters during daytime preceding tick" $
services (runHASSTimed hallwayLightsController [(day, Tick), (day, motionSensor "on")])
`shouldBe` [[], [light [EntityId "light.hallway_lights"] (On def)]]
it "turns the lights off when everyone leaves, without sleep mode" $
let later = 505 `addUTCTime` day
in services (runHASSTimed hallwayLightsController
[ (day, Tick)
, (day, motionSensor "on")
, (day, motionSensor "off")
, (later, Tick)
])
`shouldBe` [ []
, [light [EntityId "light.hallway_lights"] (On def)]
, []
, [light [EntityId "light.hallway_lights"] Off]
]
it "turns on only the ceiling light when entering during sleep hours with a door open" $
services (runHASSTimed hallwayLightsController
[ (night, Tick)
, (night, masterDoor "on")
, (night, motionSensor "on")
])
`shouldBe` [ []
, []
, [light [EntityId "light.hallway_ceiling_2"] (On def)]
]
it "sets the lower hallway light off when a door is opened during sleep hours" $
services (runHASSTimed hallwayLightsController
[ (night, masterDoor "off")
, (night, childrenDoor "off")
, (night, motionSensor "on")
, (night, masterDoor "on")
])
`shouldBe` [ []
, []
, [light [EntityId "light.hallway_lights"] (On def)]
, [light [EntityId "light.hallway_ceiling"] Off]
]
it "turns the lower hallway light on when the doors close while presence is active" $
services (runHASSTimed hallwayLightsController
[ (night, masterDoor "on")
, (night, motionSensor "on")
, (night, masterDoor "off")
, (night, childrenDoor "off")
])
`shouldBe` [ []
, [light [EntityId "light.hallway_ceiling_2"] (On def)]
, []
, [light [EntityId "light.hallway_ceiling"] (On def)]
]
+9 -2
View File
@@ -11,6 +11,7 @@ import HomeAssistant.Controller.Kitchen
import Support
import Test.Hspec
import Data.Default (def)
import Data.Time (getCurrentTime, addUTCTime)
-- Helper functions for creating test events
testDinnerLightLevel :: Int -> Event Value
@@ -37,9 +38,15 @@ dinnerTableSpec = describe "dinnerTableController" $ do
services (runHASS dinnerTableController [testDinnerLightLevel 10, testDinnerPresence "on"])
`shouldBe` [[switchService [EntityId "switch.adaptive_lighting_ruokapoydan_valot_sleep_mode"] True], [switchService [EntityId "switch.adaptive_lighting_ruokapoydan_valot_sleep_mode"] False, light [EntityId "light.kitchen_dining_large"] (On def)]]
it "turns lights off when presence is unoccupied" $ do
services (runHASS dinnerTableController [testDinnerLightLevel 10, testDinnerPresence "off"])
it "turns lights to sleep when presence is unoccupied" $ do
now <- getCurrentTime
services (runHASSTimed dinnerTableController [(now, testDinnerLightLevel 10), (now, testDinnerPresence "off")])
`shouldBe` [[switchService [EntityId "switch.adaptive_lighting_ruokapoydan_valot_sleep_mode"] True], []]
it "turns lights off when no presence for 300 seconds" $ do
now <- getCurrentTime
let later = 305 `addUTCTime` now
services (runHASSTimed dinnerTableController [(now, testDinnerLightLevel 10), (now, testDinnerPresence "off"), (later, Tick)])
`shouldBe` [[switchService [EntityId "switch.adaptive_lighting_ruokapoydan_valot_sleep_mode"] True], [], [switchService [EntityId "switch.adaptive_lighting_ruokapoydan_valot_sleep_mode"] False, light [EntityId "light.kitchen_dining_large"] Off]]
it "does nothing on Tick" $ do
services (runHASS dinnerTableController [Tick])
+4
View File
@@ -8,12 +8,14 @@ import qualified BusSpec
import qualified ConnectionSpec
import qualified FlagsSpec
import qualified GraphingSpec
import qualified HallwaySpec
import qualified HttpServerSpec
import qualified KitchenSpec
import qualified LivingroomSpec
import qualified MetricsSpec
import qualified RuntimeSpec
import qualified ControllerSpec
import qualified PresenceSpec
main :: IO ()
main = hspec $ do
@@ -24,9 +26,11 @@ main = hspec $ do
ConnectionSpec.spec
FlagsSpec.spec
GraphingSpec.spec
HallwaySpec.spec
HttpServerSpec.spec
KitchenSpec.spec
LivingroomSpec.spec
MetricsSpec.spec
RuntimeSpec.spec
ControllerSpec.spec
PresenceSpec.spec
+53
View File
@@ -0,0 +1,53 @@
{-# LANGUAGE OverloadedStrings #-}
module PresenceSpec where
import Test.Hspec (Spec, describe, shouldBe, it)
import HomeAssistant.Controller (motion, motionToPresence, HASS, Presence(..))
import Control.Arrow ((>>>))
import Data.Aeson (Value)
import Support
import Data.Time (UTCTime)
import AFRP (Event(..))
import qualified Data.Text as T
import Test.Hspec.Hedgehog
import qualified Hedgehog.Gen as Gen
import qualified Hedgehog.Range as Range
import Data.Time.Clock (addUTCTime, diffUTCTime)
import Data.List (scanl')
import Data.Bool (bool)
motionSensor :: T.Text -> Event Value
motionSensor = Event . stateEvent "sensor.foo"
day :: UTCTime
day = clock 10 0 -- 10:00, outside sleep hours
sut :: HASS (Event Value) Presence
sut = motion "sensor.foo" >>> motionToPresence 500
data TestEvent = TestEvent Int (Event Bool)
deriving Show
genTestEvent :: Gen TestEvent
genTestEvent = TestEvent
<$> Gen.frequency [(8, Gen.integral (Range.linear 0 20)), (2, pure 600)]
<*> Gen.frequency [(3, pure Tick), (1, Event <$> Gen.bool)]
spec :: Spec
spec = describe "Presence" $ do
it "Starts as unoccupied" $
values (runHASSTimed sut [(day, Tick)]) `shouldBe` [Unoccupied]
it "Detection motion means presence" $ do
values (runHASSTimed sut [(day, motionSensor "on")]) `shouldBe` [Occupied]
values (runHASSTimed sut [(day, Tick), (day, motionSensor "on")]) `shouldBe` [Unoccupied, Occupied]
it "Leaving doesn't mean immediately unoccupied room" $ do
values (runHASSTimed sut [(day, motionSensor "on"), (day, motionSensor "off")]) `shouldBe` [Occupied, Occupied]
it "re-detects occupancy only after the timeout since the previous detection" $ hedgehog $ do
events <- forAll $ Gen.list (Range.linear 0 100) genTestEvent
let steps = drop 1 $ scanl' (flip addUTCTime) day [fromIntegral t | TestEvent t _ <- events]
length steps === length events
let timed = zip steps (values (runHASSTimed sut (zipWith (\t (TestEvent _ e) -> (t, stateEvent "sensor.foo" . bool "off" "on" <$> e)) steps events)))
let transitions = [() | ((_, Occupied), (_, Unoccupied)) <- zip timed (drop 1 timed)]
cover 20 "occupied -> unoccupied transition" (not (null transitions))
let starts = [t | (Unoccupied, (t, Occupied)) <- zip (Unoccupied : map snd timed) timed]
let deltas = zipWith (\a b -> b `diffUTCTime` a) starts (drop 1 starts)
(null deltas || minimum deltas > 500) === True
+15
View File
@@ -6,11 +6,13 @@ module Support
, runHASS
, runHASSTimed
, services
, values
, fakeRequest
, sec
, stateEvent
, buttonEvent
, withTestLogEnv
, clock
) where
import Control.Exception (bracket)
@@ -75,9 +77,14 @@ runHASSTimed m = go (runMealy m interp)
case runAcc (stepAuto w (Request t utc nil "test") a) [] of
((b, w'), svcs) -> (b, svcs) : go w' as
-- To observe external effects
services :: [(b, [Service])] -> [[Service]]
services = map snd
-- To observe intermediary steps
values :: [(b, [Service])] -> [b]
values = map fst
-- | Build a state-trigger payload matching `entityChangeEvent'` / `entityBool'`
-- lenses. The subscribe_trigger websocket event wraps the trigger datum under
-- `event.variables.trigger`, with `entity_id` and `to_state.state` fields.
@@ -106,3 +113,11 @@ buttonEvent entityId eventType = object
]
]
]
-- runHASSTimed builds its request with the UTC zone, so a UTCTime given as
-- seconds-of-day reads back as exactly that local time of day
clock :: Int -> Int -> UTCTime
clock h m = sec (fromIntegral (h * 60 + m) * 60)