Sugar Valley NeoPool Controller~

# File: neopoolcmd.be
#
# Add commands NPAux, NPAntiFreeze, NPTimer, NPVersion, NPBackup, NPRestore, NPList and NPPrune

# Neopool definitions

MBF_POWER_MODULE_REGISTER = 0x000C
MBF_POWER_MODULE_DATA = 0x000D
MBF_RELAY_STATE = 0x010E
MBF_PAR_SMART_ANTI_FREEZE = 0x41A
MBF_PAR_UICFG_MACHINE = 0x0600

# MBF_PAR_TIMER_BLOCK_BASE
MBV_TIMER_OFFMB_TIMER_ENABLE = 0
MBV_TIMER_OFFMB_TIMER_ON = 1
MBV_TIMER_OFFMB_TIMER_OFF = 3
MBV_TIMER_OFFMB_TIMER_PERIOD = 5
MBV_TIMER_OFFMB_TIMER_INTERVAL = 7
MBV_TIMER_OFFMB_TIMER_COUNTDOWN = 9
MBV_TIMER_OFFMB_TIMER_FUNCTION = 11
MBV_TIMER_OFFMB_TIMER_WORK_TIME = 13

MBV_TIMER_OFFMB_TIMER_ON_IDX = 0
MBV_TIMER_OFFMB_TIMER_OFF_IDX = 1
MBV_TIMER_OFFMB_TIMER_PERIOD_IDX = 2
MBV_TIMER_OFFMB_TIMER_INTERVAL_IDX = 3
MBV_TIMER_OFFMB_TIMER_COUNTDOWN_IDX = 4
MBV_TIMER_OFFMB_TIMER_FUNCTION_IDX  = 5
MBV_TIMER_OFFMB_TIMER_WORK_TIME_IDX = 6

# MBV_TIMER_OFFMB_TIMER_ENABLE working modes:
MBV_PAR_CTIMER_DISABLE = 0
MBV_PAR_CTIMER_ENABLED  = 1
MBV_PAR_CTIMER_ENABLED_LINKED = 2
MBV_PAR_CTIMER_ALWAYS_ON  = 3
MBV_PAR_CTIMER_ALWAYS_OFF = 4
MBV_PAR_CTIMER_COUNTDOWN_KEY = 5
MBV_PAR_CTIMER_COUNTDOWN_KEY_PLUS = 0x01
MBV_PAR_CTIMER_COUNTDOWN_KEY_MINUS = 0x02
MBV_PAR_CTIMER_COUNTDOWN_KEY_ARROWDOWN = 0x04
MBV_PAR_CTIMER_COUNTDOWN_KEY_ARROWUP = 0x08
MBV_PAR_CTIMER_COUNTDOWN_KEYS = {
  MBV_PAR_CTIMER_COUNTDOWN_KEY_PLUS:"+",
  MBV_PAR_CTIMER_COUNTDOWN_KEY_MINUS:"-",
  MBV_PAR_CTIMER_COUNTDOWN_KEY_ARROWDOWN:"▼",
  MBV_PAR_CTIMER_COUNTDOWN_KEY_ARROWUP:"▲"
}

# MBV_TIMER_OFFMB_TIMER_FUNCTION codes:
MBV_PAR_CTIMER_FCT_FILTRATION = 0x0001
MBV_PAR_CTIMER_FCT_LIGHTING = 0x0002
MBV_PAR_CTIMER_FCT_HEATING = 0x0004
MBV_PAR_CTIMER_FCT_RELAY1 = 0x0100
MBV_PAR_CTIMER_FCT_RELAY2 = 0x0200
MBV_PAR_CTIMER_FCT_RELAY3 = 0x0400
MBV_PAR_CTIMER_FCT_RELAY4 = 0x0800
MBV_PAR_CTIMER_FCT_RELAY5 = 0x1000
MBV_PAR_CTIMER_FCT_RELAY6 = 0x2000
MBV_PAR_CTIMER_FCT_RELAY7 = 0x4000
# Function codes text
MBV_PAR_CTIMER_FCT = {
  MBV_PAR_CTIMER_FCT_FILTRATION:"Filtration",
  MBV_PAR_CTIMER_FCT_LIGHTING:"Light",
  MBV_PAR_CTIMER_FCT_HEATING:"Heating",
  MBV_PAR_CTIMER_FCT_RELAY1:"Relay1",
  MBV_PAR_CTIMER_FCT_RELAY2:"Relay2",
  MBV_PAR_CTIMER_FCT_RELAY3:"Relay3",
  MBV_PAR_CTIMER_FCT_RELAY4:"Aux1",
  MBV_PAR_CTIMER_FCT_RELAY5:"Aux2",
  MBV_PAR_CTIMER_FCT_RELAY6:"Aux3",
  MBV_PAR_CTIMER_FCT_RELAY7:"Aux4"
}

# configuration of the system timers
MBF_PAR_TIMER_BLOCK_FILT_INT1 = 0x0434
MBF_PAR_TIMER_BLOCK_FILT_INT2 = 0x0443
MBF_PAR_TIMER_BLOCK_FILT_INT3 = 0x0452
MBF_PAR_TIMER_BLOCK_LIGHT_INT = 0x0470
MBF_PAR_TIMER_BLOCK_AUX1_INT1 = 0x04AC
MBF_PAR_TIMER_BLOCK_AUX1_INT2 = 0x0461
MBF_PAR_TIMER_BLOCK_AUX2_INT1 = 0x04BB
MBF_PAR_TIMER_BLOCK_AUX2_INT2 = 0x047F
MBF_PAR_TIMER_BLOCK_AUX3_INT1 = 0x04CA
MBF_PAR_TIMER_BLOCK_AUX3_INT2 = 0x048E
MBF_PAR_TIMER_BLOCK_AUX4_INT1 = 0x04D9
MBF_PAR_TIMER_BLOCK_AUX4_INT2 = 0x049D

# Timer base addr index
PAR_TIMER_BLOCK = [
  # addr, function
  [MBF_PAR_TIMER_BLOCK_FILT_INT1, MBV_PAR_CTIMER_FCT_FILTRATION],
  [MBF_PAR_TIMER_BLOCK_FILT_INT2, MBV_PAR_CTIMER_FCT_FILTRATION],
  [MBF_PAR_TIMER_BLOCK_FILT_INT3, MBV_PAR_CTIMER_FCT_FILTRATION],
  [MBF_PAR_TIMER_BLOCK_LIGHT_INT, MBV_PAR_CTIMER_FCT_LIGHTING],
  [MBF_PAR_TIMER_BLOCK_AUX1_INT1, MBV_PAR_CTIMER_FCT_RELAY4],
  [MBF_PAR_TIMER_BLOCK_AUX1_INT2, MBV_PAR_CTIMER_FCT_RELAY4],
  [MBF_PAR_TIMER_BLOCK_AUX2_INT1, MBV_PAR_CTIMER_FCT_RELAY5],
  [MBF_PAR_TIMER_BLOCK_AUX2_INT2, MBV_PAR_CTIMER_FCT_RELAY5],
  [MBF_PAR_TIMER_BLOCK_AUX3_INT1, MBV_PAR_CTIMER_FCT_RELAY6],
  [MBF_PAR_TIMER_BLOCK_AUX3_INT2, MBV_PAR_CTIMER_FCT_RELAY6],
  [MBF_PAR_TIMER_BLOCK_AUX4_INT1, MBV_PAR_CTIMER_FCT_RELAY7],
  [MBF_PAR_TIMER_BLOCK_AUX4_INT2, MBV_PAR_CTIMER_FCT_RELAY7]
]
PAR_TIMER_BLOCK_AUX = [
  MBF_PAR_TIMER_BLOCK_AUX1_INT1,
  MBF_PAR_TIMER_BLOCK_AUX2_INT1,
  MBF_PAR_TIMER_BLOCK_AUX3_INT1,
  MBF_PAR_TIMER_BLOCK_AUX4_INT1
]

# Register to exclude from restore
MBF_PAR_TIME_LOW = 0x0408
MBF_PAR_TIME_HIGH = 0x0409
MBF_ACTION_COPY_TO_RTC = 0x04F0

RESTORE_EXCL = [
  MBF_PAR_TIME_LOW,
  MBF_PAR_TIME_HIGH,
  MBF_ACTION_COPY_TO_RTC
]

MACHINE_NAMES = [
  "NeoPool",
  "Hidrolife",
  "Aquascenic",
  "Oxilife",
  "Bionet",
  "Hidroniser",
  "UVScenic",
  "Station",
  "Brilix",
  "Generic",
  "Bayrol",
  "Hay"
]

import string
import json
import path

# NeoPool command class
class NeoPoolCommands
  var TEXT_OFF
  var TEXT_ON
  var TEXT_TOGGLE
  var BACKUP_DIR
  var BACKUP_NAME
  var BACKUP_START_ADDR
  var BACKUP_END_ADDR

  # helper
  def ltrim(s)
    var i = 0 while(i < size(s) && s[i] == ' ') i += 1 end
    return string.split(s, i)[1]
  end
  def rtrim(s)
    var i = size(s) while(i && s[i-1] == ' ') i -= 1 end
    return string.split(s, i)[0]
  end
  def trim(s)
    return self.rtrim(self.ltrim(s));
  end
  def list_sort(_list)
    for i:1..size(_list)-1
      var _value = _list[i]
      var j = i
      while (j > 0) && (_list[j-1] > _value)
        _list[j] = _list[j-1]
        j -= 1
      end
      _list[j] = _value
    end
    return _list
  end
  def get_args(payload)
    if nil == payload
      return []
    end
    var p = string.replace(payload, ' ', ',')
    var d = nil
    var s = ""
    for i:0..size(p)-1
      if nil == d && ('"' == p[i] || "'" == p[i])
        d = p[i]
      elif nil != d && d == p[i]
        d = nil
      elif nil != d && "," == p[i]
        s += ' '
      else
        s += p[i]
      end
    end
    p = string.split(s, ',')
    while p.find('') != nil p.remove(p.find('')) end
    return p
  end
  def get_args_switch(payload, p2)
    var parm, res
    try
      parm = string.tolower(self.trim(payload))
    except ..
      parm = ""
    end
    if parm != ""

      if (size(parm) == size('off') && string.find(parm, 'off') == 0) ||
        (size(parm) == size('0') && string.find(parm, '0') == 0) ||
        (size(parm) == size(self.TEXT_OFF) && string.find(parm, self.TEXT_OFF) == 0)
        res = 0
      elif (size(parm) == size('on') && string.find(parm, 'on') == 0) ||
          (size(parm) == size('1') && string.find(parm, '1') == 0) ||
          (size(parm) == size(self.TEXT_ON) && string.find(parm, self.TEXT_ON) == 0)
        res = 1
      elif p2 != nil &&
          ((size(parm) == size(p2) && string.find(parm, p2) == 0) ||
            (size(parm) == size('2') && string.find(parm, '2') == 0)
          )
        res = 2
      else
        res = -1
      end
    else
      res = nil
    end
    parm = nil
    tasmota.gc()
    return res
  end
  def get_period_from_int(period_num)
    if (period_num == 0)
      return "0"
    elif ((period_num % (86400 * 365)) == 0)
      return string.format("%dy", period_num / (86400 * 365))
    elif ((period_num % (86400 * 7)) == 0)
      return string.format("%dw", period_num / (86400 * 7))
    elif ((period_num % 86400) == 0)
      return string.format("%dd", period_num / 86400)
    elif ((period_num % 3600) == 0)
      return string.format("%dh", period_num / 3600)
    elif ((period_num % 60) == 0)
      return string.format("%dm", period_num / 60)
    else
      return string.format("%ds", period_num)
    end
  end
  def get_period_from_str(period_str)
    period_str = string.tolower(self.trim(period_str))
    var period_num = int(period_str)
    if period_str[size(period_str) - 1] == 'y'
      period_num *= 365 * 24 * 60 * 60
    elif period_str[size(period_str) - 1] == 'w'
      period_num *= 7 * 24 * 60 * 60
    elif period_str[size(period_str) - 1] == 'd'
      period_num *= 24 * 60 * 60
    elif period_str[size(period_str) - 1] == 'h'
      period_num *= 60 * 60
    elif period_str[size(period_str) - 1] == 'm'
      period_num *= 60
    end
    return period_num
  end
  def get_timer(cmd, idx)
    var timer_enable = self.read_register(cmd, "NPRead", PAR_TIMER_BLOCK[idx - 1][0] + MBV_TIMER_OFFMB_TIMER_ENABLE);
    if nil == timer_enable return nil end
    var data = self.read_register(cmd, "NPReadL", PAR_TIMER_BLOCK[idx - 1][0] + MBV_TIMER_OFFMB_TIMER_ON, 7)
    if nil == data return nil end

    var mode, state = "Unknown"
    var values = ""
    if (timer_enable == MBV_PAR_CTIMER_DISABLE || timer_enable == MBV_PAR_CTIMER_ENABLED)
      mode = "Timer"
      state = self.TEXT_OFF
      if (timer_enable == MBV_PAR_CTIMER_ENABLED &&
        (int(data[MBV_TIMER_OFFMB_TIMER_ON_IDX]) !=
          (int(data[MBV_TIMER_OFFMB_TIMER_ON_IDX]) + int(data[MBV_TIMER_OFFMB_TIMER_INTERVAL_IDX]))
        )
      )
        state = self.TEXT_ON
      end

      values = string.format(',"Start":"%s","End":"%s","Period":"%s"',
        tasmota.strftime("%H:%M", int(data[MBV_TIMER_OFFMB_TIMER_ON_IDX])),
        tasmota.strftime("%H:%M", int(data[MBV_TIMER_OFFMB_TIMER_ON_IDX]) + int(data[MBV_TIMER_OFFMB_TIMER_INTERVAL_IDX])),
        self.get_period_from_int(int(data[MBV_TIMER_OFFMB_TIMER_PERIOD_IDX]))
      )
    end

    if (timer_enable == MBV_PAR_CTIMER_ALWAYS_OFF || timer_enable == MBV_PAR_CTIMER_ALWAYS_ON)
      mode = "Manual"
      state = (timer_enable == MBV_PAR_CTIMER_ALWAYS_OFF) ? self.TEXT_OFF : self.TEXT_ON
      values = ""
    end

    if ((timer_enable & 0x00FF) == MBV_PAR_CTIMER_COUNTDOWN_KEY)
      mode = "Temporary"
      state = self.TEXT_ON
      values = string.format(',"Key":"%s","Duration":"%s"',
        MBV_PAR_CTIMER_COUNTDOWN_KEYS.find(((timer_enable >> 8) & 0x0F), "unknown"),
        self.get_period_from_int(int(data[MBV_TIMER_OFFMB_TIMER_INTERVAL_IDX]))
      )
    end

    var alloc = MBV_PAR_CTIMER_FCT.find(int(data[MBV_TIMER_OFFMB_TIMER_FUNCTION_IDX]), "undefined")
    return string.format('{"%s%d":{"Mode":"%s","State":"%s","Allocation":"%s"%s}}', cmd, idx, mode, state, alloc, values)
  end
  def read_register(cmd, read_cmnd, addr, cnt)
    var res = tasmota.cmd(string.format("%s 0x%04X,%d", read_cmnd, addr, cnt), true).find(read_cmnd, "Unknown")
    # result must be a json
    if "Unknown" == res
      tasmota.resp_cmnd(string.format('{"%s":"NeoPool module not available or not activated"}', cmd))
      return nil
    end
    var _json = json.load(json.dump(res))
    if nil == _json || "Error" == res
      tasmota.resp_cmnd(string.format('{"%s":"NeoPool device does not respond"}', cmd))
      return nil
    end
    return compile("return ".._json.find('Data'))()
  end

  # NPAux<x> OFF|0|ON|1|TOGGLE|2 (<x> = 1..4)
  def NPAux(cmd, idx, payload)
    var ctrl, parm

    if idx < 1 || idx > 4
      tasmota.resp_cmnd_error()
      return
    end
    parm = self.get_args_switch(payload, self.TEXT_TOGGLE)
    if parm != nil
      if 0 == parm
        ctrl = MBV_PAR_CTIMER_ALWAYS_OFF
      elif 1 == parm
        ctrl = MBV_PAR_CTIMER_ALWAYS_ON
      elif 2 == parm
        try
          ctrl = self.read_register(cmd, "NPRead", MBF_RELAY_STATE)
          if nil == ctrl return end
          ctrl = (ctrl >> (idx+2)) & 1 ? MBV_PAR_CTIMER_ALWAYS_OFF : MBV_PAR_CTIMER_ALWAYS_ON
        except ..
          return
        end
      else
        tasmota.resp_cmnd_error()
        return
      end
      tasmota.cmd(string.format("NPWrite 0x%04X,%d", PAR_TIMER_BLOCK_AUX[idx-1], ctrl), true)
      tasmota.cmd("NPExec", true)
    else
      try
        ctrl = self.read_register(cmd, "NPRead", MBF_RELAY_STATE)
        if nil == ctrl return end
        ctrl = (ctrl >> (idx+2)) & 1
    except ..
        return
      end
    end
    tasmota.resp_cmnd(string.format('{"%s%d":"%s"}', cmd, idx, ctrl == (parm != nil ? 4 : 0) ? self.TEXT_OFF : self.TEXT_ON))
  end

  # NPAntiFreeze OFF|0|ON|1|TOGGLE|2
  def NPAntiFreeze(cmd, idx, payload)
    var ctrl, parm
    parm = self.get_args_switch(payload, self.TEXT_TOGGLE)
    if parm != nil
      if 0 == parm
        ctrl = 0
      elif 1 == parm
        ctrl = 1
      elif 2 == parm
        try
          ctrl = self.read_register(cmd, "NPRead", MBF_PAR_SMART_ANTI_FREEZE)
          if nil == ctrl return end
          if 1 == ctrl
            ctrl = 0
          else
            ctrl = 1
          end
        except ..
          return
        end
      else
        tasmota.resp_cmnd_error()
        return
      end
      tasmota.cmd(string.format("NPWrite 0x%04X,%d", MBF_PAR_SMART_ANTI_FREEZE, ctrl), true)
      tasmota.cmd("NPExec", true)
    else
      try
        ctrl = self.read_register(cmd, "NPRead", MBF_PAR_SMART_ANTI_FREEZE)
        if nil == ctrl return end
    except ..
        tasmota.resp_cmnd_error()
        return
      end
    end
    tasmota.resp_cmnd(string.format('{"%s":"%s"}', cmd, ctrl ? self.TEXT_ON : self.TEXT_OFF))
  end

  # NPTimer<x> 0|OFF|<hh:mm hh:mm>( <period>)|<json> (<x> = 1..12)
  def NPTimer(cmd, idx, payload)
    var parm

    if idx < 1 || idx > size(PAR_TIMER_BLOCK)
      tasmota.resp_cmnd_error()
      return
    end

    try
      parm = string.tolower(self.trim(payload))
    except ..
      parm = nil
    end

    if parm != nil && size(parm)

      # Set timer
      if self.get_args_switch(payload) == 0
        parm = ''
      end

      try
        if (nil == json.load(parm))
          # convert none json parm to json parm
          var params = self.get_args(parm)
          var keys = ["start", "end", "period"]
          if size(params) > size(keys)
            tasmota.resp_cmnd_error()
            return
          end
          var _json = {}
          while params.size() > 0
            _json[keys[0]] = params[0]
            keys.remove(0)
            params.remove(0)
          end
          parm = json.dump(_json)
        end
      except ..
        tasmota.resp_cmnd_error()
        return
      end

      parm = json.load(parm)
      if (nil != parm)
        var timer_start, timer_end, strp
        try
            # set start and end
          strp = tasmota.strptime(parm.find("start", "00:00"), "%H:%M")
          timer_start = (strp.find("hour", 0) * 3600) + (strp.find("min", 0) * 60)
          strp = tasmota.strptime(parm.find("end", "00:00"), "%H:%M")
          timer_end = strp.find("hour", 0) * 3600 + strp.find("min", 0) * 60
          if (timer_start > timer_end)
            var tmp = timer_end
            timer_end = timer_start
            timer_start = tmp
          end
        except ..
          tasmota.resp_cmnd_error()
          return
        end
        tasmota.cmd(string.format("NPWrite 0x%04X,%d", PAR_TIMER_BLOCK[idx - 1][0] + MBV_TIMER_OFFMB_TIMER_ENABLE, MBV_PAR_CTIMER_ENABLED), true)
        tasmota.cmd(string.format("NPWriteL 0x%04X,%d", PAR_TIMER_BLOCK[idx - 1][0] + MBV_TIMER_OFFMB_TIMER_FUNCTION, PAR_TIMER_BLOCK[idx - 1][1]), true)
        tasmota.cmd(string.format("NPWriteL 0x%04X,%d", PAR_TIMER_BLOCK[idx - 1][0] + MBV_TIMER_OFFMB_TIMER_ON, timer_start), true)
        tasmota.cmd(string.format("NPWriteL 0x%04X,%d", PAR_TIMER_BLOCK[idx - 1][0] + MBV_TIMER_OFFMB_TIMER_INTERVAL, timer_end - timer_start), true)

        if (self.get_period_from_str(parm.find("Period", "0")) != 0)
          tasmota.cmd(string.format("NPWriteL 0x%04X,%d", PAR_TIMER_BLOCK[idx - 1] + MBV_TIMER_OFFMB_TIMER_PERIOD, self.get_period_from_str(parm.find("Period", "0"))), true)
        end
        tasmota.cmd("NPExec", true)

        var res = self.get_timer(cmd, idx)
        if nil != res
          tasmota.resp_cmnd(res)
        end
      else
        tasmota.resp_cmnd_error()
      end

    else
      # Get timer
      var res = self.get_timer(cmd, idx)
      if nil != res
        tasmota.resp_cmnd(res)
      end

    end

  end

  # NPVersion
  def NPVersion(cmd)
    var verstr = ""
    for i: 0 .. 12
      tasmota.cmd(string.format("NPWrite 0x%04X,%d", MBF_POWER_MODULE_REGISTER, i*2), true)
      var data = self.read_register(cmd, "NPRead", MBF_POWER_MODULE_DATA)
      if nil == data return end
      verstr += string.char(data>>8 & 0xFF)
      verstr += string.char(data    & 0xFF)
    end
    var arr = []
    for i: string.split(verstr,'\n') arr.push(i) end
    tasmota.resp_cmnd(string.format('{"%s":%s}', cmd, json.dump(arr)))
  end

  # NPBackup (<name>( overwrite)
  #   <name> may contain strftime specifier
  def NPBackup(cmd, idx, payload)
    var name, overwrite = nil

    var machine = self.read_register(cmd, "NPRead", MBF_PAR_UICFG_MACHINE)
    if nil == machine return end
    machine = machine > size(MACHINE_NAMES) ? 0 : machine

    var parm = self.get_args(payload)
    if parm != nil && size(parm)
      name = self.trim(parm[0])
      if size(parm) > 1
        overwrite = string.tolower(self.trim(parm[1]))
      end
    else
      name = tasmota.strftime(MACHINE_NAMES[machine]+"_"+self.BACKUP_NAME, tasmota.rtc()['local'])
      name += string.format("%+03d:%02d", (tasmota.rtc()['local'] - tasmota.rtc()['utc']) / 3600, 0)
    end

    path.mkdir(self.BACKUP_DIR)
    name = tasmota.strftime(name, tasmota.rtc()['local'])
    if nil != overwrite
      if size(overwrite) > 0 && 'o' == overwrite[0]
        if path.exists(self.BACKUP_DIR+"/"+name)
          # overwrite, first delete existing
          path.remove(self.BACKUP_DIR+"/"+name)
        end
      else
        tasmota.resp_cmnd(string.format('{"%s":"Error","File":"%s","Msg":"Unknown command %s"}', cmd, name, overwrite))
        return
      end
    end
    if path.exists(self.BACKUP_DIR+"/"+name)
      # do not overwrite existing backups
      tasmota.resp_cmnd(string.format('{"%s":"Error","File":"%s","Msg":"Already exists"}', cmd, name))
      return
    end

    # read register
    var reg_data = []
    try
      for addr:range(self.BACKUP_START_ADDR, self.BACKUP_END_ADDR, 16)
        var r = self.read_register(cmd, "NPRead", addr, 16)
        if nil == r return end
        for i:r
          reg_data.push(int(i))
        end
      end
    except ..
      reg_data = []
    end

    if 0 == size(reg_data)
      tasmota.resp_cmnd(string.format('{"%s":"Error","Msg":"Reading Modbus register error"}', cmd))
      return
    end

    # write backup file
    try
      var f = open(self.BACKUP_DIR+"/"+name, "w")
      f.write(json.dump({string.format("0x%04X", self.BACKUP_START_ADDR):reg_data}))
      f.close()
    except ..
      tasmota.resp_cmnd(string.format('{"%s":"Error","File":"%s","Msg":"Writing file error"}', cmd, name))
      return
    end
    tasmota.resp_cmnd(string.format('{"%s":"Done","File":"%s"}', cmd, name))
    return
  end

  # NPRestore <name>
  def NPRestore(cmd, idx, payload)
    var name = nil

    var machine = self.read_register(cmd, "NPRead", MBF_PAR_UICFG_MACHINE)
    if nil == machine return end

    var parm = self.get_args(payload)

    if parm != nil && size(parm)
      name = self.trim(parm[0])
    else
      tasmota.resp_cmnd_error()
      return
    end
    if !path.exists(self.BACKUP_DIR+"/"+name)
      tasmota.resp_cmnd(string.format('{"%s":"Error","File":"%s","Msg":"Does not exists"}', cmd, name))
      return
    end

    # Restore
    # read backup file
    var backup = {}
    var f = open(self.BACKUP_DIR+"/"+name, "r")
    try
      backup = json.load(f.read())
      f.close()
    except ..
      tasmota.resp_cmnd(string.format('{"%s":"Error","File":"%s","Msg":"JSON format error"}', cmd, name))
      return
    end

    # if any multiple addr sort it
    var addr_list = []
    for i:backup.keys()
      addr_list.push(i)
    end
    addr_list = self.list_sort(addr_list)
    # do restore commands
    for addr:addr_list
      var reg_list = backup[addr]
      var write_cmnd = ""
      var cnt = 0
      var write_addr = int(addr)
      for reg_value:reg_list
        if nil == RESTORE_EXCL.find(write_addr)
          if "" == write_cmnd
            write_cmnd = string.format("NPWrite 0x%04X", write_addr)
          end
          write_cmnd +="," + str(int(reg_value))
          cnt += 1
          if cnt >= 8
            tasmota.cmd(write_cmnd, true)
            write_cmnd = ""
            cnt = 0
          end
        elif size(write_cmnd)
          tasmota.cmd(write_cmnd, true)
          write_cmnd = ""
          cnt = 0
        end
        write_addr += 1
      end
      if size(write_cmnd)
        tasmota.cmd(write_cmnd, true)
      end
    end
    tasmota.cmd("NPExec", true)
    tasmota.cmd("NPSave", true)
    tasmota.resp_cmnd(string.format('{"%s":"Done","File":"%s"}', cmd, name))
    return
  end

  # NPList
  def NPList(cmd)
    tasmota.resp_cmnd(string.format('{"%s":%s}', cmd, json.dump(path.listdir(self.BACKUP_DIR)) ))
  end

  # NPPrune <age>( dry-run)
  def NPPrune(cmd, idx, payload)
    var age = nil
    var dry_run = false

    var parm = self.get_args(payload)
    if parm != nil && size(parm)
      age = self.get_period_from_str(string.tolower(self.trim(parm[0])))
      if size(parm) > 1
        if size(string.tolower(self.trim(parm[1]))) > 0 && 'd' == string.tolower(self.trim(parm[1]))[0]
          dry_run = true
        else
          tasmota.resp_cmnd_error()
          return
        end
      end
    else
      tasmota.resp_cmnd_error()
      return
    end

    var dfiles = []
    for _filename:path.listdir(self.BACKUP_DIR)
      if (tasmota.rtc()['local'] - path.last_modified(self.BACKUP_DIR+"/"+_filename)) > age
        dfiles.push(_filename)
        if !dry_run
          path.remove(self.BACKUP_DIR+"/"+_filename)
        end
      end
    end
    if dry_run
      tasmota.resp_cmnd(string.format('{"%s":"dry-run","File":%s}', cmd, json.dump(dfiles)))
      return
    end
    tasmota.resp_cmnd(string.format('{"%s":"Done","File":%s}', cmd, json.dump(dfiles)))
  end


  def init()
    # get tasmota settings
    self.TEXT_OFF = tasmota.cmd('StateText1', true).find('StateText1', 'OFF')
    self.TEXT_ON = tasmota.cmd('StateText2', true).find('StateText2', 'ON')
    self.TEXT_TOGGLE = tasmota.cmd('StateText3', true).find('StateText3', 'TOGGLE')
    self.BACKUP_DIR = "/.npbackup"
    self.BACKUP_NAME = '%Y-%m-%dT%H:%M:%S'
    self.BACKUP_START_ADDR = 0x0400
    self.BACKUP_END_ADDR = 0x06FF
    # add commands
    tasmota.add_cmd('NPAux', / cmd, idx, payload -> self.NPAux(cmd, idx, payload))
    tasmota.add_cmd('NPAntiFreeze', / cmd, idx, payload -> self.NPAntiFreeze(cmd, idx, payload))
    tasmota.add_cmd('NPTimer', / cmd, idx, payload -> self.NPTimer(cmd, idx, payload))
    tasmota.add_cmd('NPVersion', / cmd -> self.NPVersion(cmd))
    tasmota.add_cmd('NPBackup', / cmd, idx, payload -> self.NPBackup(cmd, idx, payload))
    tasmota.add_cmd('NPRestore', / cmd, idx, payload -> self.NPRestore(cmd, idx, payload))
    tasmota.add_cmd('NPList', / cmd -> self.NPList(cmd))
    tasmota.add_cmd('NPPrune', / cmd, idx, payload -> self.NPPrune(cmd, idx, payload))
  end

  def deinit()
    # remove commands
    tasmota.remove_cmd('NPAux')
    tasmota.remove_cmd('NPAntiFreeze')
    tasmota.remove_cmd('NPTimer')
    tasmota.remove_cmd('NPVersion')
    tasmota.remove_cmd('NPBackup')
    tasmota.remove_cmd('NPRestore')
    tasmota.remove_cmd('NPList')
    tasmota.remove_cmd('NPPrune')
  end
end
neopoolcommands = NeoPoolCommands()