// place your rules here or add more .js files in this directory
log('add your rules to /etc/wb-rules/');

// ***************************************
// CONFIGURATION

var CURTAIN_OPENTIME = 38000;             // время полного открытия/закрытия штор
var MOTION_DIGITAL_SENS = 25;             // порог чувствительности цифрового датчика движения
var MOTION_TIMEOUT = 1000;                // таймаут сброса тревоги после обнаружения движения
var BATHROOM_LIGHTING_TIMEOUT = 300000;   // задержка выключения света в санузле с момента последнего движения
var ROOM_FLOORLIGHTING_TIMEOUT = 30000;   // таймер отключения подсветки пола
var ROOM_HALLWAY_CALLDOWN_SEC = 3000;      // время с последнего движения в комнате для включения света в прихожей 
var ROOM_HALLWAY_TIMEOUT = 120000;        // таймер отключения света в прихожей


defineAlias("relay_entrance_nav",         "wb-led_69/Channel 1");           // Реле навигации двери
defineAlias("relay_entrance_dnd",         "wb-led_69/Channel 4");           // Реле индикатора "не беспокоить"

defineAlias("relay_entrance_open",        "wb-mr6c_32/Curtain 1 Open");     // Реле замка входной двери с таймаутом
defineAlias("sensor_entrance_open",       "wb-mr6c_32/Input 1");            // Датчик открытия входной двери

defineAlias("relay_apeironbox_ext_open",  "wb-mr6c_32/Curtain 2 Open");     // Реле замка ApeironBox
defineAlias("button_apeironbox_bell",     "wb-mr6c_32/Input 0 counter")     // Кнопка готовности заказа ApeironBox
defineAlias("relay_apeironbox_bell",      "wb-mr6c_32/Curtain 1 Close");    // Реле индикации готовности заказа ApeironBox с таймаутом
defineAlias("sensor_apeironbox_int_open", "wb-mr6c_32/Input 5");            // Датчик открытия внутренней дверцы ApeironBox
defineAlias("sensor_apeironbox_ext_open", "wb-mr6c_32/Input 6");            // Датчик открытия внешней дверцы ApeironBox

defineAlias("relay_safe_open",            "wb-mr6c_32/Curtain 2 Close");    // Реле замка сейфа
defineAlias("sensor_safe_open",           "wb-mr6c_32/Input 4");            // Датчик открытия сейфа


defineAlias("relay_light_main",           "wb-mdm3_43/K1");                 // Реле главного света
defineAlias("relay_light_main_dimm",      "wb-mdm3_43/Channel 1");          // Диммер главного света
defineAlias("relay_light_hallway",        "wb-mdm3_43/K2");                 // Реле освещения прихожей
defineAlias("relay_light_wall_left",      "wb-mr6c_84/K1");                 // Реле левого бра
defineAlias("relay_light_wall_right",     "wb-mr6c_84/K2");                 // Реле правого бра
defineAlias("relay_light_headboard",      "wb-led_190/Channel 1");          // Реле изголовья
defineAlias("relay_light_floor",          "wb-led_190/Channel 4");          // Реле подсветки пола
defineAlias("relay_light_bathroom",       "wb-mr6c_84/K5");                 // Освещение санузла

defineAlias("sensor_bed_motion_1",        "wb-mr6c_84/Input 4");            // Датчик движения у кровати 1
defineAlias("sensor_bed_motion_2",        "wb-mr6c_84/Input 5");            // Датчик движения у кровати 2
defineAlias("sensor_room_motion",         "wb-msw-v4_60/Current Motion");   // Датчик движения в комнате (цифровой)
defineAlias("sensor_bathroom_motion_1",   "wb-msw-v4_38/Current Motion");   // Датчик движения в санузле 1 (цифровой)
defineAlias("sensor_bathroom_motion_2",   "wb-mr6c_32/Input 2");            // Датчик движения в санузле 2

defineAlias("sensor_room_illuminance",    "wb-msw-v4_60/Illuminance");      // Датчик освещенности в комнате

//Curtains
defineAlias("curtains_open",              "wb-mr6c_84/Curtain 2 Open");     // Открытие штор
defineAlias("curtains_close",             "wb-mr6c_84/Curtain 2 Close");    // Открытие штор

//Climate
defineAlias("climate_power",  "ONOKOM-AIR-ME-1-MB-B_1/Active");             // Включение кондиционера
defineAlias("climate_mode",   "ONOKOM-AIR-ME-1-MB-B_1/Mode");               // Режим работы
defineAlias("climate_temp",   "ONOKOM-AIR-ME-1-MB-B_1/Target temperature"); // Температура
defineAlias("climate_fan",    "ONOKOM-AIR-ME-1-MB-B_1/Fan speed");          // Скорость вентилятора
defineAlias("climate_vanes",  "ONOKOM-AIR-ME-1-MB-B_1/Horizontal vanes");   // Направление обдува


// IR Remote
defineAlias("remote_sound_power",         "wb-msw-v4_60/Play from ROM15")   // Кнопка вкл/выкл колонки ApeironSound
defineAlias("remote_sound_light",         "wb-msw-v4_60/Play from ROM16")   // Кнопка вкл/выкл подсветки ApeironSound
defineAlias("remote_sound_volup",         "wb-msw-v4_60/Play from ROM17")   // Кнопка громкость + колонки ApeironSound
defineAlias("remote_sound_voldown",       "wb-msw-v4_60/Play from ROM18")   // Кнопка громкость - колонки ApeironSound

defineAlias("remote_tv_power",            "wb-msw-v4_60/Play from ROM1")    // Кнопка вкл/выкл ТВ
defineAlias("remote_tv_up",               "wb-msw-v4_60/Play from ROM2")    // Кнопка навигации вверх
defineAlias("remote_tv_down",             "wb-msw-v4_60/Play from ROM3")    // Кнопка навигации вниз
defineAlias("remote_tv_left",             "wb-msw-v4_60/Play from ROM4")    // Кнопка навигации влево
defineAlias("remote_tv_right",            "wb-msw-v4_60/Play from ROM5")    // Кнопка навигации вправо
defineAlias("remote_tv_ok",               "wb-msw-v4_60/Play from ROM6")    // Кнопка ОК
defineAlias("remote_tv_home",             "wb-msw-v4_60/Play from ROM7")    // Кнопка Домой
defineAlias("remote_tv_volup",            "wb-msw-v4_60/Play from ROM8")    // Кнопка громкости +
defineAlias("remote_tv_voldown",          "wb-msw-v4_60/Play from ROM9")    // Кнопка громкости -
defineAlias("remote_tv_mute",             "wb-msw-v4_60/Play from ROM10")   // Кнопка без звука
defineAlias("remote_tv_return",           "wb-msw-v4_60/Play from ROM11")   // Кнопка назад
defineAlias("remote_tv_screencast",       "wb-msw-v4_60/Play from ROM12")   // Кнопка трансляции экрана
defineAlias("remote_tv_long_tap",         "wb-msw-v4_60/Play from ROM13")   // Кнопка лонг тапа

// ***************************************
// Functions

function beepBuzzer() {
  dev["buzzer/frequency"] = 500;
  dev["buzzer/volume"] = 30;
  dev["buzzer/enabled"] = true;
  
  setTimeout(function () {
    dev["buzzer/enabled"] = false;
  },100);
}


// ***************************************
// DEVICE: Entrance

defineVirtualDevice('entrance', {
  title: 'Room front door',
  cells: {
    open: { type: 'pushbutton', value: false },
    opensensor: { type: 'alarm', value: false },
    dnd: { type: 'switch', value: false }
}
});

defineRule("Open door command", {
  whenChanged: "entrance/open",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [entrance]: Open door command");
    
    relay_entrance_open = true; // открываем дверь, таймаут замка в настройках реле
  } 
});

defineRule("Entrance open door event", {
  whenChanged: "sensor_entrance_open",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [entrance]: Open door sensor state changed. Door closed? = " + newValue);
    
    dev["entrance/opensensor"] = !newValue;

    // Отключаем замок, если дверь открыли
    if (relay_entrance_open) {
      relay_entrance_open = false;  
    }

    // Включаем свет в прихожей
    // 
    var last_motion = new Date(dev['motion/room_time']).getTime();
    var now = Date.now();
    var diff = (now - last_motion);
    diff = Math.abs(Math.round(diff / 60))

    log.debug("VD [entrance]: Last motion in room (sec) = " + diff);
    if (diff > ROOM_HALLWAY_CALLDOWN_SEC) {
      dev['light/hallway'] = true;
      log.debug("VD [entrance]: Hallway lighting on");
    }

    //Выключаем навигацию
    if (relay_entrance_nav){
      relay_entrance_nav = false;
    }
    
  } 
});

defineRule("Turn on/off DND light", {
  whenChanged: "entrance/dnd",
  then: function (newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [entrance]: DND state checnged. Is dnd active? = " + newValue);
    
    relay_entrance_dnd = newValue;
  }
});


// ***************************************
// DEVICE: Navigation

//TODO
defineVirtualDevice('nav', {
  title: 'Front door navigation',
  cells: {
    enabled: { type: 'switch', value: false },
    color: { type: 'range', value: 0, min: 1, max: 4 }
  }
});


// ***************************************
// DEVICE: ApeiornBox

defineVirtualDevice('apeironbox', {
  title: 'ApeironBox',
  cells: {
    open_ext: { type: 'pushbutton', value: false },
    opensensor_ext: { type: 'alarm', value: false },
    opensensor_int: { type: 'alarm', value: false },
    bell: { type: 'alarm', value: false }
  }
});

defineRule("ApeironBox open command", {
  whenChanged: "apeironbox/open_ext",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [apeironbox]: Open Apeironbox command");
              
    relay_apeironbox_ext_open = true;
  } 
});

defineRule("ApeironBox internal door open", {
  whenChanged: "sensor_apeironbox_int_open",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [apeironbox]: Internal door sensor state changed. Door closed? = " + newValue);
    
    dev["apeironbox/opensensor_int"] = !newValue;
    
    if (newValue && relay_apeironbox_bell) {
      relay_apeironbox_bell = false;  
    }
    
  } 
});

defineRule("ApeironBox external door open", {
  whenChanged: "sensor_apeironbox_ext_open",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [apeironbox]: External door sensor state changed. Door closed? = " + newValue);
    
    dev["apeironbox/opensensor_ext"] = !newValue;
  } 
});

defineRule("ApeironBox bell", {
  whenChanged: "button_apeironbox_bell",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [apeironbox]: Pushed order delivery button");
    
    relay_apeironbox_bell = true;

    dev['apeironbox/bell'] = true;
    setTimeout(function () {
      dev['apeironbox/bell'] = false;
    },1000);
    
  }
});


// ***************************************
// DEVICE: Safe

defineVirtualDevice('safe', {
  title: 'Room safe',
  cells: {
    open: { type: 'pushbutton', value: false },
    opensensor: { type: 'alarm', value: false }
}
});

defineRule("Safe open command", {
  whenChanged: "safe/open",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [safe]: Open safe command");
    
    relay_safe_open = true;
  } 
});

defineRule("Safe door state", {
  whenChanged: "sensor_safe_open",
  then: function(newValue, devName, cellName) {    
    // beepBuzzer();
    log.debug("VD [safe]: Safe door sensor state changed. Door closed? = " + newValue);

    dev["safe/opensensor"] = !newValue;
  } 
});

// ***************************************
// DEVICE: Lighting

defineVirtualDevice('light', {
  title: 'Room light',
  cells: {
    main: { type: 'switch', value: false },
    main_dim: { type: 'range', value: 0, min:0, max:100 },
    hallway: { type: 'switch', value: false },    
    wall_left: { type: 'switch', value: false },
    wall_right: { type: 'switch', value: false },
    headboard: { type: 'switch', value: false },
    standing: { type: 'switch', value: false }    
}
});

defineRule("Main light switch", {
  whenChanged: "light/main",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [light]: Main light changed. On? = " + newValue);
              
    relay_light_main = newValue;
  }
});

defineRule("Main light dimmer", {
  whenChanged: "light/main_dim",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [light]: Main light Dimmer changed. = " + newValue);
              
    relay_light_main_dimm = newValue;
  }
});

defineRule("Hallway light switch", {
  whenChanged: "light/hallway",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [light]: Hallway light changed. On? = " + newValue);
    
    relay_light_hallway = newValue;
  }
});

defineRule("Left wall light switch", {
  whenChanged: "light/wall_left",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [light]: Left wall light changed. On? = " + newValue);
    
    relay_light_wall_left = newValue;
  }
});

defineRule("Right wall light switch", {
  whenChanged: "light/wall_right",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [light]: Right wall light changed. On? = " + newValue);
    
    relay_light_wall_right = newValue;
  }
});

//TODO: переписать
defineRule("Left wall light real switch", {
  whenChanged: "relay_light_wall_left",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();

    dev["light/wall_left"] = newValue    
  }
});
//TODO: переписать
defineRule("Right wall light real switch", {
  whenChanged: "relay_light_wall_right",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();

    dev["light/wall_right"] = newValue    
  }
});


defineRule("Headboard wall light switch", {
  whenChanged: "light/headboard",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [light]: Headboard light changed. On? = " + newValue);
    
    relay_light_headboard = newValue;
  }
});


// ***************************************
// DEVICE: Curtains

defineVirtualDevice('curtains', {
  title: 'Curtains',
  cells: {
    position_1: { type: 'range', value: 0, min:0, max:100 },
    position_1_curr: { type: 'value', value: 100, readonly: true },
    position_1_work: { type: 'switch', value: false, readonly: true }
}
});

var tmp_curtains_timer_update = null;
var tmp_curtains_timer_work = null;


defineRule("Curtains position changed", {
  whenChanged: "curtains/position_1",
  then: function(newValue, devName, cellName) {
    var limit = 500; 
    var step = CURTAIN_OPENTIME / 100;
    var current = dev['curtains/position_1_curr'];
    var time = (current - newValue) * step;

    log.debug("VD [curtains]: open/close command. Real pos = " + current + ", new pos = " + newValue);
    
    //Если прошлая команда не завершена останавливаем и запускаем заново
    if (dev['curtains/position_1_work']) {
      log.debug("Curtains in process. Clean older timers");
      curtains_close = false;
      curtains_open = false;
      clearInterval(tmp_curtains_timer_update);
      clearTimeout(tmp_curtains_timer_work);
    }

    // Начинаем работу
    dev['curtains/position_1_work'] = true;

    if (time > 0){
      curtains_close = true;
    } else {
      curtains_open = true;
    }
    
    // Обновляем текущее положение шторы
    tmp_curtains_timer_update = setInterval(function () {
      if (time > 0){
      dev['curtains/position_1_curr'] -= 1;
      } else {
        dev['curtains/position_1_curr'] += 1;
      }
    }, step);  
      

    // Останавливаем выполнение 
    tmp_curtains_timer_work = setTimeout(function () {
      //beepBuzzer();
      curtains_close = false;
      curtains_open = false;
      dev['curtains/position_1_work'] = false;
      clearInterval(tmp_curtains_timer_update);
    }, Math.abs(time));
    
  } 
})


// ***************************************
// DEVICE: TV

defineVirtualDevice('tv', {
  title: 'ApeironTV',
  cells: {
    power: {type: "pushbutton", value: false },
    nav_up: {type: "pushbutton", value: false },
    nav_down: {type: "pushbutton", value: false },
    nav_left: {type: "pushbutton", value: false },
    nav_right: {type: "pushbutton", value: false },
    ok: {type: "pushbutton", value: false },
    home: {type: "pushbutton", value: false },
    return: {type: "pushbutton", value: false },
    vol_up: {type: "pushbutton", value: false },
    vol_down: {type: "pushbutton", value: false },
    mute: {type: "pushbutton", value: false },
    screencast: {type: "pushbutton", value: false },
    long_tap: {type: "pushbutton", value: false },
  }
});

defineRule("TV power", {
  whenChanged: "tv/power",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [tv]: power");
             
    remote_tv_power = true;
  } 
});

defineRule("TV nav up", {
  whenChanged: "tv/nav_up",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [tv]: nav_up");
              
    remote_tv_up = true;
  } 
});
defineRule("TV nav down", {
  whenChanged: "tv/nav_down",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [tv]: nav_down");
              
    remote_tv_down = true;
  } 
});
defineRule("TV nav left", {
  whenChanged: "tv/nav_left",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [tv]: nav_left");
              
    remote_tv_left = true;
  } 
});
defineRule("TV nav right", {
  whenChanged: "tv/nav_right",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [tv]: nav_right");
              
    remote_tv_right = true;
  } 
});
defineRule("TV nav ok", {
  whenChanged: "tv/ok",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [tv]: nav_ok");
              
    remote_tv_ok = true;
  } 
});
defineRule("TV nav home", {
  whenChanged: "tv/home",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [tv]: nav_home");
              
    remote_tv_home = true;
  } 
});
defineRule("TV nav return", {
  whenChanged: "tv/return",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [tv]: nav_return");
              
    remote_tv_return = true;
  } 
});
defineRule("TV vol up", {
  whenChanged: "tv/vol_up",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [tv]: vol_up");
              
    remote_tv_volup = true;
  } 
});
defineRule("TV vol down", {
  whenChanged: "tv/vol_down",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [tv]: vol_down");
              
    remote_tv_voldown = true;
  } 
});
defineRule("TV mute", {
  whenChanged: "tv/mute",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [tv]: vol_mute");
              
    remote_tv_mute = true;
  } 
});
defineRule("TV screencast", {
  whenChanged: "tv/screencast",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [tv]: nav_cast");
              
    remote_tv_screencast = true;
  } 
});

defineRule("TV long tap", {
  whenChanged: "tv/long_tap",
  then: function(newValue, devName, cellName) {
    // beepBuzzer();
    log.debug("VD [tv]: long_tap");
              
    remote_tv_long_tap = true;
  } 
});


// ***************************************
// DEVICE: ApeironSound

defineVirtualDevice('sound', {
  title: 'ApeironSound',
  cells: {
    power: {type: "pushbutton", value: false },
    light: {type: "pushbutton", value: false },
  }
});

defineRule("On power button pushed", {
  whenChanged: "sound/power",
  then: function(newValue, devName, cellName) {    
    // beepBuzzer();
    log.debug("VD [sound]: power");
              
    remote_sound_power = true;
  } 
});

// ***************************************
// DEVICE: Climate

defineVirtualDevice('climate', {
  title: 'Climate control',
  cells: {
    power: {type: "switch", value: false },
    auto: {type: "switch", value: false },
    temp: { type: 'range', value: 21, min:16, max:30 },
    fan: { type: 'range', value: 1, min:0, max:5 },
    dir: { type: 'range', value: 1, min:0, max:6 },
  }
});

defineRule("", {
  whenChanged: "climate/power",
  then: function(newValue, devName, cellName) {
    log.debug("VD [climate]: power is " + newValue);
    climate_power = newValue;
  }
});
defineRule("", {
  whenChanged: "climate/auto",
  then: function(newValue, devName, cellName) {
    log.debug("VD [climate]: auto mode is " + newValue);
    if (newValue) {
      climate_mode = 3 // авто
    } else {
      climate_mode = 1 // нагрев
    }
  }
});

defineRule("", {
  whenChanged: "climate/temp",
  then: function(newValue, devName, cellName) {
    log.debug("VD [climate]: temp is "  + newValue);
    climate_temp = newValue;
  }
});
defineRule("", {
  whenChanged: "climate/fan",
  then: function(newValue, devName, cellName) {
    log.debug("VD [climate]: fun is "  + newValue);
    climate_fan = newValue;
  }
});
defineRule("", {
  whenChanged: "climate/dir",
  then: function(newValue, devName, cellName) {
    log.debug("VD [climate]: vanes is " + newValue);
    climate_vanes = newValue;
  }
});

// ***************************************
// DEVICE: Motion detector

defineVirtualDevice('motion', {
  title: 'Motion detectors',
  cells: {
    bathroom: {type: "alarm", value: false, readonly: true},
    bathroom_time: {type: "value", value: '', readonly: true},
    bedroom: {type: "alarm", value: false, readonly: true},
    bedroom_time: {type: "value", value: '', readonly: true},
    room: {type: "alarm", value: false, readonly: true},
    room_time: {type: "value", value: '', readonly: true},
  }
});

// Включение света в санузле при движении
//

var tmp_bathroom_lighting_timer = null;

defineRule("On bathroom motion", {
  whenChanged: "motion/bathroom",
  then: function(newValue, devName, cellName) {
    //log.debug("VD [bathroom]: motion changed: " + newValue);

    // только если тревога
    if (newValue) {  
      
      //включаем свет
      relay_light_bathroom = true;  

      //сбрасываем таймер при повторной тревоге
      if (tmp_bathroom_lighting_timer) {
        //log.debug('VD [bathroom]: Restart lighting timeout')
        clearTimeout(tmp_bathroom_lighting_timer);
      }

      //выключаем свет по таймеру
      tmp_bathroom_lighting_timer = setTimeout(function () {
        //log.debug('VD [bathroom]: Lighting timeout has been reached')
        relay_light_bathroom = false; 
      }, BATHROOM_LIGHTING_TIMEOUT);
    }
  }
});

// Включение подсветки пола при движении у кровати
// 

//sensor_room_illuminance
var tmp_badroom_lighting_timer = null;

defineRule("On bedroom motion", {
  whenChanged: "motion/bedroom",
  then: function(newValue, devName, cellName) {
    log.debug("VD [bedroom]: motion changed: " + newValue);

    // только если тревога и освещение больше 5 lux
    if (newValue && sensor_room_illuminance < 5) {  
      
      //включаем свет
      relay_light_floor = true;  

      //сбрасываем таймер при повторной тревоге
      if (tmp_badroom_lighting_timer) {
        log.debug('VD [bedroom]: Restart lighting timeout')
        clearTimeout(tmp_badroom_lighting_timer);
      }

      //выключаем свет по таймеру
      tmp_badroom_lighting_timer = setTimeout(function () {
        //log.debug('VD [bedroom]: Lighting timeout has been reached')
        relay_light_floor = false;
      }, ROOM_FLOORLIGHTING_TIMEOUT);
    }
  }
});

// Датчики движения в санузле
//

// Функция сброса тревоги (движения) в санузле по колдаун таймеру.
var tmp_sensor_bathroom_motion_timer = null;
var tmp_sensor_bathroom_motion = function() {
  dev['motion/bathroom'] = true;
  dev['motion/bathroom_time'] = Date.now(); //дата и время последнего движения
  
  //Если был таймер, обнуляем его
  if (tmp_sensor_bathroom_motion_timer){
    clearTimeout(tmp_sensor_bathroom_motion_timer);
    //log.debug("VD [bathroom]: Motion detected >> clear motion timeout");
  }

  //По достижению таймера, сбрасываем тревогу
  tmp_sensor_bathroom_motion_timer = setTimeout(function () {
    dev['motion/bathroom'] = false;
    //log.debug("VD [bathroom]: The timeout has been reached");
  }, MOTION_TIMEOUT); 
}

defineRule("On bathroom motion detected 1", {
  whenChanged: "sensor_bathroom_motion_1",
  then: function(newValue, devName, cellName) {    
    // Так как датчик цифровой, устанавливаем пороговое значение срабатывания
    if (newValue > MOTION_DIGITAL_SENS) {       
      tmp_sensor_bathroom_motion();
    }
  }
});

defineRule("On bathroom motion detected 2", {
  whenChanged: "sensor_bathroom_motion_2",
  then: function(newValue, devName, cellName) {         
    tmp_sensor_bathroom_motion();
  }
});

// Датчики движения в комнате
//

// Функция сброса тревоги (движения) вокруг кровати и в комнате
var tmp_sensor_bedroom_motion_timer = null;
var tmp_sensor_bedroom_motion = function() {
  dev['motion/bedroom'] = true;
  dev['motion/room'] = true;
  //дата и время последнего движения
  dev['motion/bedroom_time'] = Date.now();
  dev['motion/room_time'] = Date.now();
  
  //Если был таймер, обнуляем его
  if (tmp_sensor_bedroom_motion_timer){
    clearTimeout(tmp_sensor_bedroom_motion_timer);
    //log.debug("VD [bedroom]: Motion detected >> clear motion timeout");
  }

  //По достижению таймера, сбрасываем тревогу
  tmp_sensor_bedroom_motion_timer = setTimeout(function () {
    dev['motion/bedroom'] = false;
    dev['motion/room'] = false;
    //log.debug("VD [bedroom]: The timeout has been reached");
  }, MOTION_TIMEOUT); 
}

defineRule("On bedroom motion detected 1", {
  whenChanged: "sensor_bed_motion_1",
  then: function(newValue, devName, cellName) {         
    tmp_sensor_bedroom_motion();
  }
});
defineRule("On bedroom motion detected 2", {
  whenChanged: "sensor_bed_motion_2",
  then: function(newValue, devName, cellName) {         
    tmp_sensor_bedroom_motion();
  }
});


// Функция сброса тревоги (движения) в комнате
var tmp_sensor_room_motion_timer = null;
var tmp_sensor_room_motion = function() {
  dev['motion/room'] = true;
  dev['motion/room_time'] = Date.now();
  
  //Если был таймер, обнуляем его
  if (tmp_sensor_room_motion_timer){
    clearTimeout(tmp_sensor_room_motion_timer);
    //log.debug("VD [room]: Motion detected >> clear motion timeout");
  }

  //По достижению таймера, сбрасываем тревогу
  tmp_sensor_room_motion_timer = setTimeout(function () {
    dev['motion/room'] = false;
    //log.debug("VD [bedroom]: The timeout has been reached");
  }, MOTION_TIMEOUT); 
}

defineRule("On room motion detected", {
  whenChanged: "sensor_room_motion",
  then: function(newValue, devName, cellName) { 
    // Так как датчик цифровой, устанавливаем пороговое значение срабатывания
    if (newValue > MOTION_DIGITAL_SENS) {       
      tmp_sensor_room_motion();
    }
  }
});


// ***************************************
// DEVICE: Special

defineVirtualDevice('special', {
  title: 'Extra scripts',
  cells: {
    checkin: {type: "pushbutton", value: false},
    checkout: {type: "pushbutton", value: false},
    clean: {type: "switch", value: false},
  }
});

defineRule("On checkin", {
  whenChanged: "special/checkin",
  then: function(newValue, devName, cellName) { 
    log.debug("VD [checkin]: Checkin script");
    relay_entrance_nav = true;
  }
});

defineRule("On checkout", {
  whenChanged: "special/checkout",
  then: function(newValue, devName, cellName) { 
    log.debug("VD [special]: Checkout script");
    dev['curtains/position_1'] = 100;
    relay_safe_open = true;
    dev['climate/power'] = false;
   
    dev['light/main'] = false;
    dev['light/hallway'] = false;
    dev['light/wall_left'] = false;
    dev['light/wall_right'] = false;
    dev['light/headboard'] = false;
  }
});


defineRule("On cleaning", {
  whenChanged: "special/clean",
  then: function(newValue, devName, cellName) { 
    log.debug("VD [special]: Cleaning mode is " + newValue);
    dev['curtains/position_1'] = 100;
    
    dev['light/main'] = newValue;
    dev['light/hallway'] = newValue;
    dev['light/wall_left'] = newValue;
    dev['light/wall_right'] = newValue;
    dev['light/headboard'] = newValue;
  }
});