View difference between Paste ID: HJYeTTFZ and ENkHsHjH

---tankmon
+-- tankmon
---   Tank monitoring program edited by RikuSS4
+-- http://www.computercraft.info/forums2/index.php?/topic/15689-dead-simple-railcraft-tank-monitoring/
---    Original program by Forgotten_Boy
+-- Tank monitoring program edited by RikuSS4
---    Hardware detector program by Sharidan
+-- Original program by Forgotten_Boy
---   	Requires OpenPeripherals (OP). Tested with version 3.0.
+-- Hardware detector program by Sharidan
---   	Supports iron & steel Railcraft tanks, Open Block tanks, Ender Tanks, AE ExtraCells tanks,
+-- Requires OpenPeripherals (OP). Tested with version 3.0.
---    TConstruct tanks, and Extra Utilities Drums.
+-- Supports iron & steel Railcraft tanks, Open Block tanks, Ender Tanks, AE ExtraCells tanks,
---   	Also supports multiple tanks, and tanks attached with modems.
+-- TConstruct tanks, and Extra Utilities Drums.
---   	If I missed any tanks, let me know. I will add it to the list.
+-- Also supports multiple tanks, and tanks attached with modems.
---[[
+-- If I missed any tanks, let me know. I will add it to the list.
- Setup:
+-- Setup:
- - Place an Advanced Computer with wireless modem and with tankmon on it adjacent to a tank.  Run "tankmon".
+-- Place an Advanced Computer with wireless modem and with tankmon on it adjacent to a tank.  Run "tankmon".
- - Setup another Advanced Computer with wireless modem and with tankmon on it adjacent to an advanced monitor and/or terminal glass bridge.  Run "tankmon".
+-- Setup another Advanced Computer with wireless modem and with tankmon on it adjacent to an advanced monitor and/or terminal glass bridge.  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.
+-- 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.
+-- 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.
 
- Optional Setup:
+-- Optional Setup:
- - Place an Advanced Computer with wired and wireless modems with lan cables connecting all tanks with lan modems attached to tanks and to computer.  Run "tankmon".
+-- Place an Advanced Computer with wired and wireless modems with lan cables connecting all tanks with lan modems attached to tanks and to computer.
- - Setup another Advanced Computer with wireless modem and with tankmon on it adjacent to an advanced monitor and/or terminal glass bridge.  Run "tankmon".
+-- Run "tankmon".
- - Your monitor should now show the contents of the tanks.  Add as many tanks as you like and the server will simply add them to the display.
+-- Setup another Advanced Computer with wireless modem and with tankmon on it adjacent to an advanced monitor and/or terminal glass bridge.
- - 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.
+-- Run "tankmon".
 -- Your monitor should now show the contents of the tanks.  Add as many tanks as you like and the server will simply add them to the display.
- Advanced usage:
+-- 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.
- - 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
+-- Advanced usage:
- tankmon 0 top
+-- 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).
- 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.
+-- 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 tankTypes = {"iron_tank_valve", "steel_tank_valve", "openblocks_tank", "drum", "ender_tank", "cofh_thermalexpansion_tank", "net_minecraft_src_buildcraft_factory_tiletank", "tileentitycertustank", "tconstruct_lavatank"};
+
-local scale = .5 --Scale for monitor text
+
 local sides = {"left", "right", "top", "bottom", "front", "back"};
 local tankTypes = {"rcirontankvalvetile","rcsteeltankvalvetile","iron_tank_valve", "steel_tank_valve", "openblocks_tank", "drum", "ender_tank", "cofh_thermalexpansion_tank", "net_minecraft_src_buildcraft_factory_tiletank", "tileentitycertustank", "tconstruct_lavatank"};
 local scale = 0.75 --Scale for monitor text
 local skipEmpty = true --Skip showing empty tanks
 local count = 0 --Counter for tanks
 
 ----------------------------------------------------
 -- Terminal Bridge Glasses Variable definitions
 ----------------------------------------------------
 local bridge = {}
 bridge["TankText"] = {}
 bridge["TankBackground"] = {}
 bridge["TankTexture"] = {}
 -------------------------------------------------------
 -- Terminal Bridge Glasses display variable definitions
 -- Feel free to alter these to your liking
 -------------------------------------------------------
 bridge["BackgroundColor"] = 0x000000 --Background Bar color
 bridge["TextColor"] = 0x33B5E5 --Text color
 bridge["TextScale"] = 1 --Text Scale
 bridge["ExtendBackground"] = true --Extend Black background behind text
 bridge["BarWidth"] = 25 --Tank bar width
 bridge["BarHeight"] = 50 --Tank bar height
 bridge["XOffset"] = 5 --X Offset for displaying info
 bridge["YOffset"] = 50 --Y Offset for displaying info
 bridge["XSpacing"] = 5 --Space between columns
 bridge["YSpacing"] = 5 --Space between rows
 bridge["Alpha"] = 1 --Alpha value of bar background
 bridge["LinesAmt"] = 3 --Number of text lines after tank bar
 bridge["MaxCols"] = 3 --Max Number of cols to display per page
 bridge["MaxRows"] = 3 --Max Number of rows to display per page
 -------------------------------------------------------
 -- Which row to start with. This will be changed to
 -- automatically change based on user input in chat
 -- command box.
 -------------------------------------------------------
 bridge["StartRow"] = 0 --Min Row to display
 -------------------------------------------------------
 -- Altering these does nothing
 -------------------------------------------------------
 bridge["CurrentRow"] = 1 --Current Row
 bridge["CurrentCol"] = 1 --Current Col
 
 ----------------------------------------------------
 -- Function definitions
 ----------------------------------------------------
 local liquidNameColors = {
                {"water", colors.blue, "Water" },
                {"lava", colors.orange, "Lava" },
                {"liquidforce", colors.yellow, "Liquid Force" },
-               {"ardite.molten", colors.orange, "Molten Ardite" },
+
-               {"gold.molten", colors.yellow, "Molten Gold" },
+
-               {"blood", colors.orange, "Blood" },
+
                {"ardite.molten", colors.pink, "Molten Ardite" },
                {"gold.molten", colors.orange, "Molten Gold" },
                {"blood", colors.red, "Blood" },
                {"copper.molten", colors.orange, "Molten Copper" },
                {"obsidian.molten", colors.gray, "Molten Obsidian" },
                {"bop.honey", colors.yellow, "Honey" },
                {"sap", colors.brown, "Sap" },
-               {"alumite.molten", colors.orange, "Molten Ardite" },
+
                {"iron.molten", colors.gray, "Molten Iron" },
                {"bop.liquidpoison", colors.purple, "Liquid Poison" },
                {"alumite.molten", colors.pink, "Molten Ardite" },
                {"cobalt.molten", colors.cyan, "Molten Cobalt" },
                {"bop.springwater", colors.blue, "Spring Water" },
                {"glowstone", colors.yellow, "Energized Glowstone" },
                {"resin", colors.brown, "Resin" },
                {"emerald.liquid", colors.lime, "Liquified Emerald" },
                {"pinkslime", colors.pink, "Pink Slime" },
                {"redstone", colors.orange, "Destabilized Redstone" },
                {"xpjuice", colors.lime, "Liquid XP" },
                {"Mob Essence", colors.lime, "Mob Essence" },
                {"oil", colors.gray, "Oil" },
                {"fluid.oil", colors.gray, "Oil" },
                {"aluminum.molten", colors.lightGray, "Molten Aluminum" },
                {"manyullyn.molten", colors.purple, "Molten Manyullyn" },
                {"stone.seared", colors.gray, "Seared Stone" },
                {"creosote", colors.green, "Creosote Oil" },
                {"sludge", colors.brown, "Sludge" },
                {"fluid.seedoil", colors.yellow, "Fuel" },
                {"bioethanol", colors.lime, "Ethanol" },
                {"fluid.bioethanol", colors.lime, "Ethanol" },
                {"acid", colors.lime, "Acid" },
                {"biomass", colors.lime, "Biomass" },
-               {"fuel", colors.lime, "Fuel" },
+
                {"electrum.molten", colors.yellow, "Molten Electrum" },
                {"sewage", colors.brown, "Sewage" },
                {"slime.blue", colors.cyan, "Liquid Blueslime" },
                {"tin.molten", colors.lightGray, "Molten Tin" },
                {"aluminumbrass.molten", colors.orange, "Molten Aluminum Brass" },
                {"milk", colors.white, "Milk" },
                {"fuel", colors.yellow, "Fuel" },
                {"fluid.fuel", colors.yellow, "Fuel" },
                {"biofuel", colors.green, "Biofuel" },
                {"fluid.biofuel", colors.green, "Biofuel" },
                {"chocolatemilk", colors.brown, "Chocolate Milk" },
                {"glass.molten", colors.lightGray, "Molten Glass" },
                {"cryotheum", colors.cyan, "Gelid Cryotheum" },
                {"pyrotheum", colors.orange, "Blazing Pyrotheum" },
                {"pinkslime", colors.pink, "Pink Slime" },
                {"platinum.molten", colors.cyan, "Molten Platinum" },
                {"coal", colors.gray, "Liquifacted Coal" },
-               {"bronze.molten", colors.brown, "Molten Bronze" }
+
                {"mushroomsoup", colors.brown, "Mushroom Soup" },
                {"silver.molten", colors.lightGray, "Molten Silver" },
                {"nickel.molten", colors.cyan, "Molten Nickel" },
                {"ender", colors.green, "Resonant Ender" },
                {"invar.molten", colors.lightGray, "Molten Invar" },
                {"glue", colors.white, "Glue" },
                {"meat", colors.pink, "Meat" },
                {"steel.molten", colors.gray, "Molten Steel" },
                {"bronze.molten", colors.brown, "Molten Bronze" },
                {"uumatter", colors.purple, "UU Matter" }
                }
 
 function cls()
    term.clear()
    term.setCursorPos(1,1)
    term.setCursorBlink(false)
 end
 function clm()
    if monitor then
       monitor.setBackgroundColor(colors.black)
       monitor.setTextScale(scale)
       monitor.clear()
       monitor.setCursorPos(1,1)
       monitor.setCursorBlink(false)
    end
 end
 function clb()
    if bridge["peripheral"] then
       bridge["peripheral"].clear()
    end
 end
 
 function table.merge(tbl1, tbl2)
    for k,v in ipairs(tbl2) do
       table.insert(tbl1, v)
    end
    return tbl1
 end
 
 function split(str, wordNum)
    local splitString = {}
    for tmp in str:gmatch("%w+") do
       table.insert(splitString, tmp)
    end
    return splitString[wordNum] or ""
 end
 
 local function getLiquidColor(liquid)
    for c, color in pairs (liquidNameColors) do
       if (liquid == color[1]) or (liquid == color[3]) then
          return color[2]
       end
    end
    return colors.white;
 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
 
 function hardwareDetector(...)
   local self = {}
   -- Initialize internal hardware list
   self._devList = {}
 
   -- Internal worker function
   -- Checks a boolean value and returns the
   -- corresponding supplied value
   local function iif(bool, resultTrue, resultFalse)
     if (bool) then
       return resultTrue;
     else
       return resultFalse;
     end
   end
   local function split(str, pat)
     local t = {}
     local fpat = "(.-)" .. pat
     local last_end = 1
     local s, e, cap = str:find(fpat, 1)
     while s do
       if s ~= 1 or cap ~= "" then
         table.insert(t,cap)
       end
       last_end = e+1
       s, e, cap = str:find(fpat, last_end)
     end -- while
     if last_end <= #str then
       cap = str:sub(last_end)
       table.insert(t, cap)
     end
     return t
   end
   local function splitType(str)
     local typ, adv = str, nil
     local r = split(str, ":")
     if (#r == 2) then
       typ = r[1]
       adv = r[2]
     end
     return typ, adv;
   end
   local function wrapID(value)
     if (value == nil) then
       return "offline"
     else
       return tostring(value)
     end
   end
   local function addDevice(label, devType, remote)
     local lcdt = string.lower(devType)
     local adv = "n/a";
     local pCall = function() end;
     if (remote) then
       pCall = function(label, method)
         return remote.callRemote(label, method)
       end;
     else
       pCall = function(label, method)
         return peripheral.call(label, method)
       end;
     end
     if (lcdt == "modem") then
       adv = iif(pCall(label, "isWireless"), "wireless", "cable")
     elseif (lcdt == "monitor") then
       adv = iif(pCall(label, "isColor"), "advanced", "normal")
     elseif (lcdt == "computer" or lcdt == "turtle") then
       adv = tostring(wrapID(pCall(label, "getID")))
     elseif (lcdt == "drive") then
       if (disk.isPresent(label)) then
         if (disk.hasData(label)) then
           adv = "floppy";
         elseif (disk.hasAudio(label)) then
           adv = "music";
         else
           adv = "unknown";
         end
       else
         adv = "empty"
       end
     end
     table.insert(self._devList, {label, devType, adv});
     if (lcdt == "modem" and string.lower(adv) == "cable") then
       return true;
     end
   end
 
   -- Detects all connected peripherals
   function self.detect()
     self._devList = {};
     local sides = rs.getSides();
     local remoteSide = {};
     for i, side in pairs(sides) do
       local devType = peripheral.getType(side);
       if (devType) then
         if (addDevice(side, devType)) then
           table.insert(remoteSide, side);
         end
       end -- if
     end -- for-do
 
     if (#remoteSide > 0) then
       -- There was a cable modem attached, so we need to loop through all remote peripherals too
       for r = 1, #remoteSide do
         local rp = peripheral.wrap(remoteSide[r]);
         local lst = rp.getNamesRemote()
         for r = 1, #lst do
           local name = lst[r]
           local devType = rp.getTypeRemote(name);
           if (devType) then
             addDevice(name, devType, rp);
           end
         end
       end -- for r
     end
   end
 
   -- Returns a tuple of the first matching peripheral
   function self.find(...)
     local args={...}
     if (#args > 0) then
       local idx = 0;
       for i, sideType in pairs(self._devList) do
         for a = 1, #args do
           local findType = args[a];
           if (type(findType) == "string") then
             local typ, adv = splitType(findType);
             if (string.lower(typ) == string.lower(self._devList[i][2])) then
               if (adv) then
                 if (string.lower(adv) == string.lower(self._devList[i][3])) then
                   -- We found a device of this type
                   idx = i;
                 end
               else
                 -- We found a device of this type
                 idx = i;
               end
               if (idx > 0) then
                 return tostring(self._devList[idx][1]), tostring(self._devList[idx][2]), tostring(self._devList[idx][3])
               end
             end
           end
         end
       end
       return nil;
     else
       error("No device type specified.", 0)
-      local args={...}
+
   end
 
   -- Returns a complete list of peripherals
   function self.getAll()
     return self._devList;
   end
 
   -- Returns a list of all matching peripherals
   function self.getList(...)
 	  local args={...}
       local results = {}
       if (#args > 0) then
          for i, sideType in pairs(self._devList) do
             for a = 1, #args do
                local findType = args[a];
                if (type(findType) == "string") then
                   if (string.lower(findType) == string.lower(self._devList[i][2])) then
                      -- We found a device of this type
                      table.insert(results, {tostring(self._devList[i][1]), tostring(self._devList[i][2]), tostring(self._devList[i][3])})
                   end
                elseif (type(findType) == "table") then
                   for i2, entry in pairs(findType) do
                      if (type(entry) == "string") then
                         if (string.lower(entry) == string.lower(self._devList[i][2])) then
                            -- We found a device of this type
                            table.insert(results, {tostring(self._devList[i][1]), tostring(self._devList[i][2]), tostring(self._devList[i][3])})
                         end
                      end
                   end
                end
             end
          end
          return results;
       else
          error("No device type specified.", 0);
       end
    end
 
   -- Determines if the device is remote or not
   function self.isRemote(dev)
     if (type(dev) == "string") then
       local sides = rs.getSides();
       for i, s in pairs(sides) do
         if (string.lower(dev) == string.lower(s)) then
           return nil;
         end
       end
       return true;
     else
       error("Device connect string expected.", 0);
     end
   end
 
   -- Internal calls, don't mess with these
   self.detect()
 
   local args = {...};
   if (#args > 0) then
     return self.find(...);
   else
     -- If no parameters were passed,
     -- return the hardware object
     return self;
   end
 end
 
 local function showLevel(count,total,filled,color,label,rawLabel, amt, threshold, signal)
    if (monitor) then
       local screenw, screenh = monitor.getSize()
       --total = total + 1
       if (not screenw) then
          return nil;
          -- monitor has been broken
       end
 
       local starty = screenh -  math.floor((screenh * filled))
       local width  = math.ceil(screenw / total)
       local offset = math.ceil((screenw / total) * (count-1))
       local amtw = string.len(amt)
       local thresholdy = (threshold and ( screenh - ((threshold / 100) * screenh)))
 
       if (count == total) then
       --  the final column should use up the remaining space.  A hack!
          width = screenw - offset
       end
 
       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
                else
                   thresholdColor = color
                end
             end
             paintutils.drawPixel(line + offset, thresholdy, thresholdColor)
          end
       end
 
       --truncate the label to the width of the bar.
       monLabel = string.sub(rawLabel, 1, math.max((width - 1), 0))
 
       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)
       monitor.setTextScale(scale)
       write(monLabel)
 
       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
    if (bridge["peripheral"]) then
       --Maximum length string can be
       local cutoffPoint = math.ceil(bridge["BarWidth"] / (8*bridge["TextScale"]))
 
       bridge["CurrentRow"] = math.floor((count+bridge["MaxCols"]-1)/bridge["MaxCols"])
       bridge["CurrentCol"] = ((count+bridge["MaxCols"]-1) - bridge["CurrentRow"]*bridge["MaxCols"]) + 1
 
       if (bridge["CurrentRow"] > bridge["StartRow"]) and (bridge["CurrentRow"] <= (bridge["StartRow"] + bridge["MaxRows"])) then
          --Heigth including extra lines below tank display
          local fullHeight = bridge["BarHeight"]+((8*bridge["TextScale"])*(bridge["LinesAmt"]))
          --X and Y coords for tank displays
          local x = bridge["XOffset"] + ((bridge["BarWidth"] + bridge["XSpacing"]) * (bridge["CurrentCol"]-1))
          local y = bridge["YOffset"] + ((fullHeight+bridge["YSpacing"])*(bridge["CurrentRow"]-bridge["StartRow"]-1))
          --Draw tank background using liquid texture
          if bridge["ExtendBackground"] then
             bridge["TankBackground"][count] = bridge["peripheral"].addBox(x,y,bridge["BarWidth"],fullHeight,bridge["BackgroundColor"],bridge["Alpha"])
          else
             bridge["TankBackground"][count] = bridge["peripheral"].addBox(x,y,bridge["BarWidth"],bridge["BarHeight"],bridge["BackgroundColor"],bridge["Alpha"])
          end
          bridge["TankTexture"][count] = bridge["peripheral"].addLiquid(x+1,y+1+math.ceil(bridge["BarHeight"]-(bridge["BarHeight"] * filled)),bridge["BarWidth"]-2,(bridge["BarHeight"] * filled)-2,label)
          --Display info to bridge
          bridge["TankText"][count] = bridge["TankText"][count] or {}
          for i=0,(bridge["LinesAmt"]-1) do
             bridge["TankText"][count][i] = bridge["peripheral"].addText((x+2), (bridge["BarHeight"]+y+((8*bridge["TextScale"])*i)),"",bridge["TextColor"])
             bridge["TankText"][count][i].setScale(scale)
          end
          bridge["TankText"][count][0].setText(string.sub(split(rawLabel,1), 1, cutoffPoint))
          bridge["TankText"][count][1].setText(string.sub(split(rawLabel,2), 1, cutoffPoint))
          bridge["TankText"][count][2].setText(string.sub(tostring(math.floor(filled*100)).."%", 1, cutoffPoint))
       end
    end
 end
 
 local function tankStats(tank)
 	if(tank) then
       local name = tank["name"] or nil
       local rawName = tank["rawName"] or nil
 		local amt = tank["amount"]
 		local size = tank["capacity"]
 		local filled = (amt and 1 / (size / amt)) or 0
       local threshold = tank["redLimit"] or -1
       local signalOn = tank["on"] or false
 		return name, rawName, amt, size, filled, threshold, signalOn
 	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
 
 function printTable(tt, indent)
    print(tableToString(tt, indent))
 end
 
 function tableToString (tt, indent, done)
   done = done or {}
   indent = indent or 0
   if type(tt) == "table" then
     local sb = {}
     for key, value in pairs (tt) do
       table.insert(sb, string.rep (" ", indent)) -- indent it
       if type (value) == "table" and not done [value] then
         done [value] = true
         table.insert(sb, "{\n");
         table.insert(sb, tableToString (value, indent + 2, done))
         table.insert(sb, string.rep (" ", indent)) -- indent it
         table.insert(sb, "}\n");
       elseif "number" == type(key) then
         table.insert(sb, string.format("\"%s\"\n", tostring(value)))
       else
         table.insert(sb, string.format("%s = \"%s\"\n", tostring (key), tostring(value)))
        end
     end
     return table.concat(sb)
   else
     return tt .. "\n"
   end
 end
 
 function table.contains(tbl, element)
   for _, value in pairs(tbl) do
     if value == element then
       return true
     end
   end
   return false
 end
 
 local function findTank(tbl)
    if type(tbl) == "table" then
       for index,value in pairs(tbl) do
          if type(value) == "table" then
             if value["capacity"] then
                return tbl
             else
                return findTank(value)
             end
          end
       end
    else
       return nil
    end
 end
 local function findTanks(tbl)
    local tblTemp = {}
    if type(tbl) == "table" then
       for index,value in pairs(tbl) do
          if type(value) == "table" then
             if value["capacity"] then
                table.insert(tblTemp, value)
             else
                table.insert(tblTemp, findTank(value))
             end
          end
       end
    end
    return tblTemp
 end
 local function updateDisplay()
    --printTable(findTanks(clients))
 --end
 --local function tmp()
 	local count = 1
    local lstTanks = {}
    local total = 0
 
    clm()
    clb()
 
    if tableCount(clients) > 0 then
       local i = 1
       for ix,client in pairs (clients) do
          local tanks = findTanks(client)
          table.merge(lstTanks, tanks)
          if (i <= 15) then
             term.setCursorPos(1,6+i)
             term.clearLine()
             print("Client "..i.." # of Tanks: "..tostring(#tanks))
          end
          i = i + 1
       end
       total = #lstTanks
       term.setCursorPos(1,6)
       term.clearLine()
       print("Total # of Tanks: "..tostring(total))
       for _,tankInfo in pairs (lstTanks) do
             local name, rawName, amt, size, filled, threshold, signalOn = tankStats(tankInfo)
             local color = getLiquidColor(rawName)
             local unit = ""
             local amount = math.max(amt or 0, 0)
             --print("Name: "..tostring(name))
             --print("Raw Name: "..tostring(rawName))
             --print("color: "..tostring(color))
             --print("amt: "..tostring(amt))
             --print("size: "..tostring(size))
             --print("filled: "..tostring(filled))
 
             if not (name) and (skipEmpty) then total = total - 1 end
             if name or (not (name) and not (skipEmpty)) then
                if (amount > 1000000) then
                   unit="M"
                   amount=string.format("%.2f", math.floor(amt / 1000) / 1000)
                   --unit="K Buckets"
                   --amount=string.format("%i", math.floor(amt / 1000) / 1000)
                else
                   if(amount > 0) then
                      unit="K"
                      amount=string.format("%.2f", amt / 1000)
                      --unit=" Buckets"
                      --amount=string.format("%i", amt / 1000)
                   else
                      amount = ""
                   end
                end
                amount = amount..unit
                showLevel(count, total, filled, color, name or "Empty", rawName or "Empty", amount, threshold, signalOn)
                count = count + 1
             --end
          end
       end
    end
    return nil;
 end
 
 local function broadcast ()
 	cls()
 	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: " .. tableCount(clients))
 		sleep(7)
 	end
 end
 
 local function receive()
   while true do
     local senderID, message, distance = rednet.receive()
-      sleep(1.5)
+
 		local data = textutils.unserialize(message)
 		clients[senderID] = data
     end
   end
 end
 
 local function display()
 	while true do
       updateDisplay()
       sleep(2.5)
 	end
 end
 
 local function connect()
 	cls()
    print("Looking for a tankmon server in range...")
 	while true do
 		local senderID, message, distance = rednet.receive()
 		serverID = senderID
       print()
       print("Connected to server " ..tostring(serverID)..".")
       sleep(3)
   end
 end
 
-                     lstTanks[i][1] = peripheral.wrap(lstTanks[i][1]).getTankInfo("unknown")[1]
+
    while true do
       if (serverID) then
          local hw = hardwareDetector()
          lstTanks = hw.getList(tankTypes)
          if (type(lstTanks) == "table") then
             if (#lstTanks > 0) then
                local info = {}
                for i, tank in pairs(lstTanks) do
                   if not tank[1]["capacity"] then
                      lstTanks[i][1] = peripheral.wrap(lstTanks[i][1]).getTankInfo("bottom")[1]
                   end
                end
                cls()
                print("** Sending out tank information **")
                print("Number of tanks: "..#lstTanks)
                for i, tank in pairs(lstTanks) do
                   -- establish whether redstone signal should be sent
                   local name, rawName, amt, size, filled, threshold, signalOn = tankStats(tank[1])
                   on = false
                   pctFilled = filled * 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.
                   tank[1]["redLimit"] = redLimit
                   tank[1]["on"] = on
                   table.insert(info, tank[1])
                   if (redLimit and redside) then
                      print("Redstone signal on: " .. tostring(on))
                   end
                   if (i <= 12) then
                      term.setCursorPos(1,3 + i)
                      term.clearLine()
                      if tank[1]["amount"] then
                         write("** Tank "..i.." contains: " .. tostring(tank[1]["amount"]).."mB of "..tostring(tank[1]["name"]))
                      else
                         write("** Tank "..i.." is empty.")
                      end
                   end
                end
                if (redLimit and redside) then
                   print("Redstone threshold: " .. tostring(redLimit))
                   print("Redstone output side: " .. tostring(redside))
                end
                rednet.send(serverID, textutils.serialize(info), false)
             end
          end
 		end
 		sleep(math.random(1,5))
   end
 end
 
 -------------------------------------------------------
 -- Hardware setup and detection
 -------------------------------------------------------
 local hw = hardwareDetector()
 local screenSide, _, _ = hw.find("monitor:advanced");
 local bridgeSide, _, _ = hw.find("openperipheral_glassesbridge");
 local modemSide, _, _ = hardwareDetector("modem:wireless")
 lstTanks = hw.getList(tankTypes)
 
 if (modemSide) then
     local modem = peripheral.wrap(modemSide)
 else
     error("A wireless modem must be attached to this computer.")
 end
 
 if (#lstTanks > 0) and (bridgeSide or screenSide) then
     error("Either a screen or a tank valve can be connected, not both.")
 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()
 	clm()
 end
 if (bridgeSide) then
    bridge["peripheral"] = peripheral.wrap(bridgeSide)
    clb()
 end
 
 ---------------------------------------
 --the Main
 ---------------------------------------
 
 rednet.open(modemSide)
 if (#lstTanks > 0) 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)