cycle {class = FZZCTicker, mod = 4} { // used to trigger sensor reporting

}

trend { // compute a new trend value based on some random variation of the previous reading plus the trend

    (:v,:s,:w) :- add(:v,:s,:v2), rnd.rsnd(1,:w,:v2,:s);

}

trend.step { // define the trend step for each sensors

    (0,1.0);
    (1,0.4);
    (2,0.8);
    (3,0.6);
    (4,0.3);
    (5,0.1);


}

range { // specifies the temperature range for each sensors

    (0,<40|140>);
    (1,<15|200>);
    (2,<50|140>);
    (3,<50|140>);
    (4,<50|140>);
    (5,<100|140>);

}

line { // specifies the line for each sensors

    //(sensor,redline,guardline)

    (0,<60|130>,<70|120>);
    (1,<20|180>,<40|160>);
    (2,<60|130>,<70|120>);
    (3,<60|130>,<70|120>);
    (4,<65|125>,<70|120>);
    (5,<110|130>,<115|125>);

}

line.check { // match a sensor reading to the 'guardline' & 'readline' lines

    (:v,:rl,:gl,okay) :-  rng.inc(:rl,:v), rng.inc(:gl,:v);
    (:v,:rl,:gl,warn) :- !rng.inc(:gl,:v), rng.inc(:rl,:v);
    (:v,:rl,:gl,halt) :- !rng.inc(:rl,:v);

}

sensors { // keeps track of the sensors readings and handle the console inputs

    readings = [100,100,100,100,100,100],   // last temperature reading for all the 5 sensors
    trending = [0,0,0,0,0,0],               // trending for each of the 5 sensors
    selected = 0                            // currently selected sensor

} {

    // select a sensor
    () :-   @console.keypress(:k?[<49|54>]), hush, sub(:k,49,:s), !peek(selected,:s), poke(selected,:s),
            &console.puts("log : sensor ",:s," selected");

    // stable temp
    () :-   @console.keypress(_?[lst.member([48,42])]), hush, peek(selected,:s), peek(trending,:l), lst.swap(:l,:s,0,:l2),
            poke(trending,:l2), console.puts("log : set temp for sensor ",:s," as stable");
    // lower temp
    () :-   @console.keypress(45), hush, peek(selected,:s), peek(trending,:l), #trend.step(:s,:t), mul(:t,-1,:t2),
            lst.swap(:l,:s,:t2,:l2), poke(trending,:l2), console.puts("log : set temp for sensor ",:s," as decreasing");
    // higher temp
    () :-   @console.keypress(_?[lst.member([61,43])]), hush, peek(selected,:s), peek(trending,:l), #trend.step(:s,:t),
            lst.swap(:l,:s,:t,:l2), poke(trending,:l2), console.puts("log : set temp for sensor ",:s," as increasing");

    // debug print the reading for the selected sensor
    () :-   @console.keypress(114), hush, peek(selected,:s), peek(readings,:l), lst.item(:l,:s,:v),
            console.puts("log : sensor ",:s," temp = ",:v);
    // debug print the trend for the selected sensor
    () :-   @console.keypress(116), hush, peek(selected,:s), peek(trending,:l), lst.item(:l,:s,:v),
            console.puts("log : sensor ",:s," trend = ",:v);

    // this prototype get going cyclically and compute a new reading for each of the sensors and fire-up a statement for each
    // we need to peek a second time at the 'reading' property as its value may get modified by a concurrent inference during
    // the call to #trend
    () :-   @cycle(:c,:t), hush, peek(readings,:lr), peek(trending,:lt), lst.item(:lr,:s,:v), lst.item(:lt,:s,:step?[neq(0)]),
            #trend(:v,:step,:w), #range(:s,:rng), rng.clamp(:rng,:w,:w2), peek(readings,:lr2), lst.swap(:lr2,:s,:w2,:lr3),
            poke(readings,:lr3), declare(sensors(:s,:w2));

    // when a device is halted, we just put out an hint for the user
    () :-   @device(:i,halt), hush, console.puts("log : you can stop the trend on the sensor(s)");

    // handle a reading query
    (:s?[<0|5>],:r) :- peek(readings,:l), lst.item(:l,:s,:r);

}

device { // represents a single sensor

    id      = 0,        // id of the device
    sensors = [0,1],    // list of sensors connected to that device
    state   = okay      // current state (okay, warn, halt)

} {

    // when a sensor reading is available, we check if the reading is within the accepted range. If not we adjust the state
    ()      :-  @sensors(:s,:v), hush, peek(sensors,:l), lst.item(:l,_,:s), #line(:s,:rl,:gl), #line.check(:v,:rl,:gl,:o),
                peek(state,:state), neq(:o,:state), poke(state,:o), peek(id,:i), declare(device(:i,:o));

    // handle state query
    (:i,:s) :- peek(id,:id?[eq(:i)]), peek(state,:s);

}

device { // represents a single sensor

    id      = 1,    // id of the device
    sensors = [2],  // list of sensors connected to that device
    state   = okay  // current state (okay, warn, halt)

} {

    // when a sensor reading is available, we check if the reading is within the accepted range. If not we adjust the state
    ()      :-  @sensors(:s,:v), hush, peek(sensors,:l), lst.item(:l,_,:s), #line(:s,:rl,:gl), #line.check(:v,:rl,:gl,:o),
                peek(state,:state), neq(:o,:state), poke(state,:o), peek(id,:i), declare(device(:i,:o));

    // handle state query
    (:i,:s) :- peek(id,:id?[eq(:i)]), peek(state,:s);

}

device { // represents a single sensor

    id      = 2,    // id of the device
    sensors = [3],  // list of sensors connected to that device
    state   = okay  // current state (okay, warn, halt)

} {

    // when a sensor reading is available, we check if the reading is within the accepted range. If not we adjust the state
    ()      :-  @sensors(:s,:v), hush, peek(sensors,:l), lst.item(:l,_,:s), #line(:s,:rl,:gl), #line.check(:v,:rl,:gl,:o),
                peek(state,:state), neq(:o,:state), poke(state,:o), peek(id,:i), declare(device(:i,:o));

    // handle state query
    (:i,:s) :- peek(id,:id?[eq(:i)]), peek(state,:s);

}

device { // represents a single sensor

    id      = 3,        // id of the device
    sensors = [4,5],    // list of sensors connected to that device
    state   = okay      // current state (okay, warn, halt)

} {

    // when a sensor reading is available, we check if the reading is within the accepted range. If not we adjust the state
    ()      :-  @sensors(:s,:v), hush, peek(sensors,:l), lst.item(:l,_,:s), #line(:s,:rl,:gl), #line.check(:v,:rl,:gl,:o),
                peek(state,:state), neq(:o,:state), poke(state,:o), peek(id,:i), declare(device(:i,:o));

    // handle state query
    (:i,:s) :- peek(id,:id?[eq(:i)]), peek(state,:s);

}