tankmon - Railcraft Tank Monitoring

--tankmon
--   Railcraft tank monitoring by Forgotten_Boy
--      requires OpenPeripherals (OP) at least version 0.1.9, supports new liquid names in OP 0.2.1
--      with thanks to AmigaLink and Kalmor for the updated liquid names.
--      Supports iron and steel Railcraft tanks and 15 common liquids.
--[[
 Setup:
 - Place an Advanced Computer with wireless modem and with tankmon on it adjacent to a tank valve.  Run "tankmon".
 - Setup another Advanced Computer with wireless modem and with tankmon on it adjacent to an advanced monitor.  Run "tankmon".
 - Your monitor should now show the contents of the tank.  Add as many tanks as you like and the server will simply add them to the display.
 - The size of the monitor or locations of the modems don't matter, place them anywhere on the computer.  The monitor can be resized while tankmon is running.

 Advanced usage:
 - On the client, you can use tankmon to trigger a redstone signal when the tank reaches a certain threshold (specified as 0 to 100, a percentage).  For example:
 tankmon 100 left
 tankmon 0 top
 The first example will send redstone output on the left when the tank is full.  The second example will send redstone output on the top when the tank is empty.
--]]

-- Variable definitions
local valve, monitor, screenw, screenh
local serverID = nil
local clients = {}
local args = {...}
local redlimit, redside, on
local sides = {"left", "right", "top", "bottom", "front", "back"};

----------------------------------------------------
-- Function definitions
----------------------------------------------------
local liquidColors = {{"Water", colors.blue },
                    {"tile.oilStill", colors.gray, "Oil"},
                    {"Creosote Oil", colors.brown},
                    {"Essence", colors.lime},
                    {"Steam", colors.lightGray},
                    {"Honey", colors.yellow},
                    {"Ethanol", colors.orange},
                    {"Lava", colors.orange},
                    {"item.fuel", colors.yellow, "Fuel"},
                    {"Biomass", colors.green},
                    {"Fortron", colors.lightBlue},
                    {"Sludge", colors.black},
                    {"Liquid DNA", colors.magenta},
                    {"Fruit Juice", colors.green},
                    {"Seed Oil", colors.yellow},
                    {"Liquid Force", colors.yellow},
                    {"Oil", colors.gray, "Oil"},
                    {"Fuel", colors.yellow, "Fuel"},
                    {"uumatter", colors.purple, "UUMatter"},
                    {"vegetable", colors.magenta, "Veg"},
                    {"deuterium", colors.lightBlue, "Deuterium"},
--liquid names for OpenPeripherals 0.2.1 by AmigaLink
                                        {"creosote", colors.brown, "Creosote Oil"},
                                        {"essence", colors.lime, "Essence"},
                                        {"steam", colors.lightGray, "Steam"},
                                        {"honey", colors.yellow, "Honey"},
                                        {"bioethanol", colors.orange, "Ethanol"},
                                        {"lava", colors.orange, "Lava"},
                                        {"biomass", colors.green, "Biomass"},
                                        {"fortron", colors.lightBlue, "Fortron"},
                                        {"sludge", colors.black, "Sludge"},
                                        {"liquiddna", colors.magenta, "Liquid DNA"},
                                        {"fruitjuice", colors.green, "Fruit Juice"},
                                        {"seedoil", colors.yellow, "Seed Oil"},
                                        {"xpjuice", colors.lime, "XP Juice"},
                                        {"liquidforce", colors.yellow, "Liquid Force"},
                                        {"oil", colors.gray, "Oil"},
                                        {"fuel", colors.yellow, "Fuel"},
                                        {"milk", colors.white, "Milk"},
-- Life Essence suggested by Fyrhtu
                    {"life essence", colors.red, "Life Essence"}
                }

local function getLiquidColor(liquid)
  for c, color in pairs (liquidColors) do
    if (liquid == color[1]) then
        return color[2],color[3] or liquid
    end
  end
  return colors.white, liquid;
end

local function getDeviceSide(deviceType)
    for i,side in pairs(sides) do
        if (peripheral.isPresent(side)) then
            if (peripheral.getType(side)) == string.lower(deviceType) then
                return side;
            end
        end
    end
end

local function showLevel(count,max,filled,color,label, amt, threshold, signal)
    local screenw, screenh = monitor.getSize()
    max = max + 1
    if (not screenw) then
        return nil;
        -- monitor has been broken
    end

    local starty = screenh -  math.floor((screenh * filled))
    local width  = math.ceil(screenw / max + .5)
    local offset = math.ceil(width * (count - 1))
    local amtw = string.len(amt)
    local thresholdy = (threshold and ( screenh - ((threshold / 100) * screenh)))

    if (count == max) then
    --  the final column should use up the remaining space.  A hack!
        width = screenw - offset
    end
    --truncate the label to the width of the bar.
    label = string.sub(label, 1, math.max((width - 1), 0))

    if (thresholdy and thresholdy < 1) then
        thresholdy = 1
    else
        if (thresholdy and thresholdy > screenh) then
            thresholdy = screenh
        end
    end

    term.redirect(monitor)
    for c=starty, screenh + 1, 1 do
        for line=0, width, 1 do
            paintutils.drawPixel(line + offset, c, color)
        end
    end
    if (thresholdy) then
        local thresholdColor = color
        for line=0, width, 1 do
            thresholdColor = color
            if (signal) then
                thresholdColor = colors.red
            else
                -- makes a dotted line when there is no redstone signal
                if (line % 2 == 0) then
                    thresholdColor = colors.red
                end
            end
            paintutils.drawPixel(line + offset, thresholdy, thresholdColor)
        end
    end

    monitor.setBackgroundColor(color)
    if (color == colors.white) then
        monitor.setTextColor(colors.black)
    end

    labely = math.min((starty + 1), screenh - 1)
    monitor.setCursorPos(offset + 1, labely)
    write(label)

    if (amtw <= width) then
        amty = math.min(labely + 1, screenh)
        monitor.setCursorPos(offset + 1, amty)
        write(amt)
    end
    monitor.setTextColor(colors.white)
--    term.restore()
end

local function tankStats(tank)
    if(tank) then
        local amt = tank["contents"]["amount"]
        local size = tank["capacity"]
        local filled = (amt and 1 / (size / amt)) or 0
        return amt, size, filled
    else
        return nil;
    end
end

local function tableCount(t)
    local total=0
    for k,v in pairs (t) do
        total = total + 1
    end
    return total
end

local function updateDisplay()
    local total = tableCount(clients)
    local count = 1

    monitor.setBackgroundColor(colors.black)
    monitor.setTextScale(.5)
    monitor.clear()

    for ix,client in pairs (clients) do
        local tank = client[1]
        local threshold = client[2]
        local signalOn = client[3]
        local amt,size,filled = tankStats(tank)
        local kind = tank["contents"]["name"]
        local color,name = getLiquidColor(kind)
        local unit = ""
        local amount = math.max(amt or 0, 0)

        if (amount > 1000000) then
            unit="M"
            amount=string.format("%.2f", math.floor(amt / 1000) / 1000)
        else
            if(amount > 0) then
              unit="K"
              amount=string.format("%.2f", amt / 1000)
            else
              amount = ""
            end
        end
        amount = amount..unit
        showLevel(count, total, filled, color, name or "Empty", amount, threshold, signalOn)
        count = count + 1
    end
    return nil;
end

local function broadcast ()
    term.clear()
    term.setCursorPos(1,1)
    print("_____________ tankmon Server started __________")
    print("Broadcasting that tank display is available...")
    print("Hold Ctrl+T to Terminate.")
    while true do
        rednet.broadcast(os.getComputerID())
        term.setCursorPos(1, 5)
        term.clearLine()
        write("Connected tankmon clients: " .. tostring(tableCount(clients)))
        sleep(7)
    end
end

local function receive()
  while true do
    local senderID, message, distance = rednet.receive()
    if (message) then
        local data = textutils.unserialize(message)
        clients[senderID] = data
    end
  end
end

local function display()
    while true do
        updateDisplay()
        sleep(1.5)
    end
end

local function connect()
    print("Looking for a tankmon server in wireless Rednet range...")
    while true do
        local senderID, message, distance = rednet.receive()
        serverID = senderID
        print("Connected to server " .. tostring(serverID))
        sleep(3)
  end
end

local function publishTank()
    while true do
        if serverID then
            term.clear()
            term.setCursorPos(1,1)
            print("** Sending out tank information **")
            local tank = valve.getTankInfo()[1]
            -- establish whether redstone signal should be sent
            local amt,size,pctFilled = tankStats(tank)
            on = false
            local filled = pctFilled * 100
            if (filled and redlimit and redlimit==0 and filled==0) then
                on = true
            else
                if(filled and redlimit and filled <= redlimit) then
                    on=true
                end
            end
            if(redside) then
                rs.setOutput(redside, on)
            end
            -- use rednet to update the server with this tank's info.
            local info = {tank, redlimit, on}
            if (redlimit and redside) then
                print("Redstone threshold: " .. tostring(redlimit))
                print("Redstone output side: " .. redside)
                print("Redstone signal on: " .. tostring(on))
                print("")
            end
            term.clearLine()
            write("** Tank contains: " .. tostring(amt))
            rednet.send(serverID, textutils.serialize(info), false)
        end
        sleep(math.random(1,5))
    end
end

---------------------------------------
--the Main
---------------------------------------
local modemSide = getDeviceSide("modem");

if (modemSide) then
    local modem = peripheral.wrap(modemSide)
else
    error("A wireless modem must be attached to this computer.")
end

local tankSide = getDeviceSide("iron_tank_valve");
local tankSide2 = getDeviceSide("steel_tank_valve");
local tankSide3 = getDeviceSide("rcsteeltankvalvetile");
local tankSide4 = getDeviceSide("rcirontankvalvetile");
local finalside = tankSide or tankSide2 or tankSide3 or tankSide4
local screenSide = getDeviceSide("monitor");

if (finalside and screenSide) then
    error("Either a screen or a tank valve can be connected, not both.")
end

if finalside  then
    valve = peripheral.wrap(finalside )
end

if (screenSide) then
    monitor = peripheral.wrap(screenSide)
    if(not monitor.isColor()) then
        error("The attached monitor must be Advanced.  Get some gold!")
    end
    screenw, screenh = monitor.getSize()
    monitor.clear()
end

rednet.open(modemSide)
if (valve) then
    -- client mode
    redlimit = args[1]
    redside = args[2]
    if (redlimit and not redside) then
        print("A threshold and redstone side must both be present.")
        print("e.g. tankmon 100 top")
        error()
    end
    if (redlimit) then
        redlimit = tonumber(redlimit)
        print("")
        print("Tank will send redstone signal at or below " .. tostring(redlimit) .. "% on side " .. redside)
    end
    -- clear outstanding redstone signals.
    for i,side in pairs(sides) do
        rs.setOutput(side, false)
    end
    parallel.waitForAll(connect, publishTank)
else
    -- server mode
    parallel.waitForAll(broadcast, receive, display)
end
rednet.close(modemSide)