tankmon2

-- Syntax: Brainfuck
--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.black, "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"},
     {"nitrofuel", colors.green, "Nitrofuel"}
                                }

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["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["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("unknown")[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)