user.dmx.lua

local luadmx = require('luadmx')
module('DMX', package.seeall)

local DMX = {}

-- default params
local defaults = {
  -- storage key
  skey = 'dmx_line_1',
  -- RS-485 port
  port = '/dev/RS485',
  -- number of calls per second
  resolution = 20,
  -- total number of channels to use
  channels = 3,
  -- transition time in seconds, does not include DMX transfer time
  transition = 2,
}

-- value setter
function set(chan, val, key)
  key = key or defaults.skey
  chan = tonumber(chan) or 0
  val = tonumber(val) or -1

  -- validate channel number and value
  if chan >= 1 and chan <= 512 and val >= 0 and val <= 255 then
    storage.exec('lset', key, chan - 1, val)
  end
end

-- value getter
function get(chan, key)
  local res, val
  key = key or defaults.skey
  chan = tonumber(chan) or 0

  -- validate channel number and value
  if chan >= 1 and chan <= 512 then
    res = storage.exec('lrange', key, chan - 1, chan - 1)
    if type(res) == 'table' then
      val = tonumber(res[ 1 ])
    end
  end

  return val
end

-- DMX init, returns new DMX object
function init(params)
  local n, k, v, _

  -- create metatable and set user parameters
  n = setmetatable({}, { __index = DMX })
  n.params = params or {}

  _, n.conn = pcall(require('redis').connect)

  -- merge parameters that are set by user
  for k, v in pairs(defaults) do
    if n.params[ k ] == nil then
      n.params[ k ] = v
    end
  end

  n:reset()

  return n
end

function DMX:reset()
  local err, chan, params

  params = self.params
  self.dm, err = luadmx.open(params.port)

  -- error while opening
  if err then
    os.sleep(1)
    error(err)
  end

  -- set channel count
  self.dm:setcount(params.channels)

  -- number of transaction ticks
  self.ticks = math.max(1, params.transition * params.resolution)

  -- calculate sleep time
  self.sleep = 1 / params.resolution

  -- reset channel map
  self.channels = {}

  -- empty channel value map
  self.conn:ltrim(params.skey, 1, 0)

  -- fill channel map
  for chan = 1, params.channels do
    self.channels[ chan ] = { current = 0, target = 0, ticks = 0 }

    -- turn off by default
    self.conn:lpush(params.skey, 0)
    self.dm:setchannel(chan, 0)
  end
end

-- get new values
function DMX:getvalues()
  local max, channels, ticks, values, val

  max = self.params.channels
  channels = self.channels
  ticks = self.ticks
  values = self.conn:lrange(self.params.skey, 0, max - 1) or {}

  -- check for new values for each channel
  for chan = 1, max do
    val = tonumber(values[ chan ]) or 0

    -- target value differs, set transcation
    if val ~= channels[ chan ].target then
      channels[ chan ].target = val
      channels[ chan ].delta = (channels[ chan ].target - channels[ chan ].current) / ticks
      channels[ chan ].ticks = ticks
    end
  end
end

-- main loop handler
function DMX:run()
  self:getvalues()

  -- transition loop
  for i = 1, self.params.resolution do
    self:step()
    self.dm:send()
    os.sleep(self.sleep)
  end
end

-- single transition step
function DMX:step()
  local chan, channels, t

  channels = self.channels

  -- transition for each channel
  for chan = 1, self.params.channels do
    t = channels[ chan ].ticks

    -- transition is active
    if t > 0 then
      t = t - 1

      channels[ chan ].current = channels[ chan ].target - channels[ chan ].delta * t
      channels[ chan ].ticks = t

      self.dm:setchannel(chan, channels[ chan ].current)
    end
  end
end