View difference between Paste ID: x3FVV8P5 and fguScPBQ

---[[
+
-Program name: Lolmer's EZ-NUKE reactor control system
+local progVer = ""
-Version: v0.3.17
+local progName = "Mt. Weather"
-Programmer: Lolmer
+
-With reat assistance from @echaet and @thetaphi
+
-Last update: 2015-04-08
+
-Pastebin: http://pastebin.com/fguScPBQ
+
-GitHub: https://github.com/sandalle/minecraft_bigreactor_control
+
 -- End multi-reactor cleanup section
-Description:
+
-This program controls a Big Reactors nuclear reactor in Minecraft with a Computercraft computer, using Computercraft's own wired modem connected to the reactors computer control port.
+
 local monitorList = {} -- Empty monitor array
-This program was designed to work with the mods and versions installed on Never Stop Toasting (NST) Diet http://www.technicpack.net/modpack/details/never-stop-toasting-diet.254882 Endeavour: Never Stop Toasting: Diet official Minecraft server http://forums.somethingawful.com/showthread.php?threadid=3603757
+
 local reactorList = {} -- Empty reactor array
-To simplify the code and guesswork, I assume the following monitor layout, where each "monitor" listed below is a collection of three wide by two high Advanced Monitors:
+
-1) One Advanced Monitor for overall status display plus
+
-	one or more Reactors plus
+
-	none or more Turbines.
+local turbineMonitorOffset = 0 -- Turbines are assigned monitors after reactors
-2) One Advanced Monitor for overall status display plus (furthest monitor from computer by cable length)
+
-	one Advanced Monitor for each connected Reactor plus (subsequent found monitors)
+
-	one Advanced Monitor for each connected Turbine (last group of monitors found).
+
-If you enable debug mode, add one additional Advanced Monitor for #1 or #2.
+
 write("Initializing program...\n")
-Notes
+
-----------------------------
+
-- Only one reactor and one, two, and three turbines have been tested with the above, but IN THEORY any number is supported.
+
-- Devices are found in the reverse order they are plugged in, so monitor_10 will be found before monitor_9.
+
 local logFile = fs.open("reactorcontrol.log", "w")
-When using actively cooled reactors with turbines, keep the following in mind:
+
-- 1 mB steam carries up to 10RF of potential energy to extract in a turbine.
+
-- Actively cooled reactors produce steam, not power.
+
-- You will need about 10 mB of water for each 1 mB of steam that you want to create in a 7^3 reactor.
+
-- Two 15x15x14 Turbines can output 260K RF/t by just one 7^3 (four rods) reactor putting out 4k mB steam.
+
 end
-Features
+
-----------------------------
+
-- Configurable min/max energy buffer and min/max temperature via ReactorOptions file.
+
-- Disengages coils and minimizes flow for turbines over max energy buffer.
+
-- ReactorOptions is read on start and then current values are saved every program cycle.
+
-- Rod Control value in ReactorOptions is only useful for initial start, after that the program saves the current Rod Control average over all Fuel Rods for next boot.
+  local ccVersion = nil
-- Auto-adjusts control rods per reactor to maintain temperature.
+  ccVersion = os.version()
-- Will display reactor data to all attached monitors of correct dimensions.
+
-	- For multiple monitors, the first monitor (often last plugged in) is the overall status monitor.
+	if ccVersion == "CraftOS 1.6" then
-- For multiple monitors, the first monitor (often last plugged in) is the overall status monitor.
+		term.native()
-- A new cruise mode from mechaet, ONLINE will be "blue" when active, to keep your actively cooled reactors running smoothly.
+
 		term.restore()
-GUI Usage
+
-----------------------------
+
-- Right-clicking between "< * >" of the last row of a monitor alternates the device selection between Reactor, Turbine, and Status output.
+
-	- Right-clicking "<" and ">" switches between connected devices, starting with the currently selected type, but not limited to them.
+
-- The other "<" and ">" buttons, when right-clicked with the mouse, will decrease and increase, respectively, the values assigned to the monitor:
+
-	- "Rod (%)" will lower/raise the Reactor Control Rods for that Reactor
+
-	- "mB/t" will lower/raise the Turbine Flow Rate maximum for that Turbine
+local function printLog(printStr)
-	- "RPM" will lower/raise the target Turbine RPM for that Turbine
+	if debugMode then
-- Right-clicking between the "<" and ">" (not on them) will disable auto-adjust of that value for attached device.
+		-- If multiple monitors, use the last monitor for debugging if debug is enabled
-	- Right-clicking on the "Enabled" or "Disabled" text for auto-adjust will do the same.
+		if #monitorList > 1 then
-- Right-clicking on "ONLINE" or "OFFLINE" at the top-right will toggle the state of attached device.
+			term.redirect(monitorList[#monitorList]) -- Redirect to last monitor for debugging
 			monitorList[#monitorList].setTextScale(0.5) -- Fit more logs on screen
-Default values
+			write(printStr.."\n")   -- May need to use term.scroll(x) if we output too much, not sure
-----------------------------
+			termRestore()
-- Rod Control: 90% (Let's start off safe and then power up as we can)
+		end -- if #monitorList > 1 then
-- Minimum Energy Buffer: 15% (will power on below this value)
+
-- Maximum Energy Buffer: 85% (will power off above this value)
+
-- Minimum Passive Cooling Temperature: 950^C (will raise control rods below this value)
+
-- Maximum Passive Cooling Temperature: 1,400^C (will lower control rods above this value)
+
-- Minimum Active Cooling Temperature: 300^C (will raise the control rods below this value)
+
-- Maximum Active Cooling Temperature: 420^C (will lower control rods above this value)
+
-- Optimal Turbine RPM:  900, 1,800, or 2,700 (divisible by 900)
+
-	- New user-controlled option for target speed of turbines, defaults to 2726RPM, which is high-optimal.
+
 	end -- if debugMode then
-Requirements
+
-----------------------------
+
-- Advanced Monitor size is X: 29, Y: 12 with a 3x2 size
+
-- Computer or Advanced Computer
+
-- Modems (not wireless) connecting each of the Computer to both the Advanced Monitor and Reactor Computer Port.
+
-- Big Reactors (http://www.big-reactors.com/) 0.3.2A+
+
-- Computercraft (http://computercraft.info/) 1.58, 1.63+, or 1.73+
+
-- Reset the computer any time number of connected devices change.
+
 config = {}
-Resources
+
-----------------------------
+
-- This script is available from:
+
-	- http://pastebin.com/fguScPBQ
+
-	- https://github.com/sandalle/minecraft_bigreactor_control
+
 	printLog("Save function called for config for "..path.." EOL")
-- Start-up script is available from:
+
-	- http://pastebin.com/ZTMzRLez
+
-	- https://github.com/sandalle/minecraft_bigreactor_control
+
-- Other reactor control program which I based my program on:
+
-	- http://pastebin.com/aMAu4X5J (ScatmanJohn)
+
-	- http://pastebin.com/HjUVNDau (version ScatmanJohn based his on)
+
-- A simpler Big Reactor control program is available from:
+
-	- http://pastebin.com/7S5xCvgL (IronClaymore only for passively cooled reactors)
+
-- Reactor Computer Port API: http://wiki.technicpack.net/Reactor_Computer_Port
+
-- Computercraft API: http://computercraft.info/wiki/Category:APIs
+
-- Big Reactors Efficiency, Speculation and Questions! http://www.reddit.com/r/feedthebeast/comments/1vzds0/big_reactors_efficiency_speculation_and_questions/
+
-- Big Reactors API code: https://github.com/erogenousbeef/BigReactors/blob/master/erogenousbeef/bigreactors/common/multiblock/tileentity/TileEntityReactorComputerPort.java
+
-- Big Reactors API: http://big-reactors.com/cc_api.html
+
-- Big Reactor Simulator from http://reddit.com/r/feedthebeast : http://br.sidoh.org/
+
-- A tutorial from FTB's rhn : http://forum.feed-the-beast.com/threads/rhns-continued-adventures-a-build-journal-guide-collection-etc.42664/page-10#post-657819
+
 			value2 = tostring(value2)
-ChangeLog
+
-============================
+
-- 0.3.17
+
-	- Display how much steam (in mB/t) a Turbine is receiving on that Turbine's monitor.
+
-	- Set monitor scale before checking size fixing Issue #50.
+
-	- Having a monitor is now optional, closing Issue #46.
+
-	- Incorporate steam supply and demand in reactor control thanks to @thetaphi (Nicolas Kratz).
+
-	- Added turbine coil auto dis-/engage (Issue #51 and #55) thanks to @thetaphi (Nicolas Kratz).
+
-	- Stop overzealous controlRodAdjustAmount adjustment amount adjustment Issue #56 thanks to @thetaphi (Nicolas Kratz).
+
-	- Monitors can be reconfigured via GUI fixes Issue #34 thanks to @thetaphi (Nicolas Kratz).
+
 end --config.save = function(path, tab)
-Prior ChangeLogs are posted at https://github.com/sandalle/minecraft_bigreactor_control/releases
+
 -- Load a config file
-TODO
+
-============================
+
-See https://github.com/sandalle/minecraft_bigreactor_control/issues?q=is%3Aopen+is%3Aissue+label%3Aenhancement :)
+
 	assert(path ~= nil, "Path can't be nil")
-]]--
+
 	if f ~= nil then
 		local tab = {}
 		local line = ""
-local progVer = "0.3.17"
+
-local progName = "EZ-NUKE"
+
 		local currentTag = nil
 		local found = false
 		local pos = 0
 		while line ~= nil do
 			found = false
 			line = line:gsub("\\;", "#_!36!_#") -- to keep \;
 			line = line:gsub("\\=", "#_!71!_#") -- to keep \=
 			if line ~= "" then
 				-- Delete comments
 				newLine = line
 				line = ""
 				for i=1, string.len(newLine) do
 					if string.sub(newLine, i, i) ~= ";" then
 						line = line..newLine:sub(i, i)
-local monitorAssignments = {} -- Empty array of monitor - "what to display" assignments
+
-local monitorOptionFileName = "monitors.options" -- File for saving the monitor assignments
+
 					end
-local steamRequested = 0 -- Sum of Turbine Flow Rate in mB
+
-local steamDelivered = 0 -- Sum of Active Reactor steam output in mB
+
 				-- Find tag
--- Log levels
+
-local FATAL = 16
+
-local ERROR = 8
+
-local WARN = 4
+
-local INFO = 2
+
-local DEBUG = 1
+
 				if not found and line ~= "" then
 					pos = line:find("=")
 					if pos == nil then
 						error("Bad INI file structure")
 					end
 					line = line:gsub("#_!36!_#", ";")
 					line = line:gsub("#_!71!_#", "=")
 					tab[currentTag][stringTrim(line:sub(1, pos-1))] = stringTrim(line:sub(pos+1, line:len()))
 					found = true
 				end
 			end
 			line = f.readLine()
 		end
 
 		f:close()
 
 		return tab
 	else
 		return nil
 	end
-	local ccVersion = nil
+
-	ccVersion = os.version()
+
 
-	if ccVersion == "CraftOS 1.6" or "CraftOS 1.7" then
+
-		term.redirect(term.native())
+
 local function round(num, places)
 	local mult = 10^places
 	local addon = nil
 	if ((num * mult) < 0) then
 		addon = -.5
 	else
 		addon = .5
 	end
-local function printLog(printStr, logLevel)
+
-	logLevel = logLevel or INFO
+
-	-- No, I'm not going to write full syslog style levels. But this makes it a little easier filtering and finding stuff in the logfile.
+
-	-- Since you're already looking at it, you can adjust your preferred log level right here.
+
-	if debugMode and (logLevel >= WARN) then
+
-		-- If multiple monitors, print to all of them
+
-		for monitorName, deviceData in pairs(monitorAssignments) do
+
-			if deviceData.type == "Debug" then
+
-				debugMonitor = monitorList[deviceData.index]
+
-				if(not debugMonitor) or (not debugMonitor.getSize()) then
+
-					term.write("printLog(): debug monitor "..monitorName.." failed")
+
 	local printString, xPos, yPos, monitorIndex =
-					term.redirect(debugMonitor) -- Redirect to selected monitor
+
-					debugMonitor.setTextScale(0.5) -- Fit more logs on screen
+
-					local color = colors.lightGray
+
-					if (logLevel == WARN) then
+
-						color = colors.white
+
-					elseif (logLevel == ERROR) then
+
-						color = colors.red
+
-					elseif (logLevel == FATAL) then
+
-						color = colors.black
+
-						debugMonitor.setBackgroundColor(colors.red)
+
 		return -- Invalid monitorIndex
-					debugMonitor.setTextColor(color)
+
-					write(printStr.."\n")   -- May need to use term.scroll(x) if we output too much, not sure
+
-					debugMonitor.setBackgroundColor(colors.black)
+
 	monitor.write(printString)
 end -- function print(printParams)
 
-		end -- for
+
 -- Replaces the one from FC_API (http://pastebin.com/A9hcbZWe) and adding multi-monitor support
 local function printCentered(printString, yPos, monitorIndex)
 	local monitor = nil
 	monitor = monitorList[monitorIndex]
 
 	if not monitor then
 		printLog("monitor["..monitorIndex.."] in printCentered() is NOT a valid monitor.")
 		return -- Invalid monitorIndex
 	end
 
 	local width, height = monitor.getSize()
 	local monitorNameLength = 0
 
 	-- Special changes for title bar
 	if yPos == 1 then
 		-- Add monitor name to first line
 		monitorNameLength = monitorNames[monitorIndex]:len()
--- Format number with [k,M,G,T,P,E] postfix or exponent, depending on how large it is
+
-local function formatReadableSIUnit(num)
+
-	printLog("formatReadableSIUnit("..num..")", DEBUG)
+		if (#monitorList ~= 1) and (monitorIndex ~= 1) then
-	num = tonumber(num)
+
-	if(num < 1000) then return tostring(num) end
+
-	local sizes = {"", "k", "M", "G", "T", "P", "E"}
+
-	local exponent = math.floor(math.log10(num))
+
-	local group = math.floor(exponent / 3)
+	monitor.setCursorPos(math.floor(width/2) - math.ceil(printString:len()/2) +  monitorNameLength/2, yPos)
-	if group > #sizes then
+	monitor.clearLine()
-		return string.format("%e", num)
+
 
-		local divisor = math.pow(10, (group - 1) * 3)
+
-		return string.format("%i%s", num / divisor, sizes[group])
+	-- print{monitorNames[monitorIndex], 1, 1, monitorIndex} -- Print monitor name
 
-end -- local function formatReadableSIUnit(num)
+
 end -- function printCentered(printString, yPos, monitorIndex)
--- pretty printLog() a table
+
-local function tprint (tbl, loglevel, indent)
+
-	if not loglevel then loglevel = DEBUG end
+
-	if not indent then indent = 0 end
+
-	for k, v in pairs(tbl) do
+
-		formatting = string.rep("  ", indent) .. k .. ": "
+
-		if type(v) == "table" then
+
-			printLog(formatting, loglevel)
+
-			tprint(v, loglevel, indent+1)
+
-		elseif type(v) == 'boolean' or type(v) == "function" then
+		printLog("monitor["..monitorIndex.."] in printLeft() is NOT a valid monitor.")
-			printLog(formatting .. tostring(v), loglevel)
+
 	end
-			printLog(formatting .. v, loglevel)
+
 	local gap = 1
 	local width = monitor.getSize()
-end -- function tprint()
+
 	-- Clear left-half of the monitor
 
 	for curXPos = 1, (width / 2) do
 		monitor.setCursorPos(curXPos, yPos)
 		monitor.write(" ")
 	end
 
 	-- Write our string left-aligned
 	monitor.setCursorPos(1+gap, yPos)
 	monitor.write(printString)
 end
 
 
 -- Print text padded from the right side
 -- Clear the right side of the screen
 local function printRight(printString, yPos, monitorIndex)
 	local monitor = nil
 	monitor = monitorList[monitorIndex]
 
 	if not monitor then
 		printLog("monitor["..monitorIndex.."] in printRight() is NOT a valid monitor.")
 		return -- Invalid monitorIndex
 	end
 
 	-- Make sure printString is a string
 	printString = tostring(printString)
 
 	local gap = 1
 	local width = monitor.getSize()
 
 	-- Clear right-half of the monitor
 	for curXPos = (width/2), width do
 		monitor.setCursorPos(curXPos, yPos)
 		monitor.write(" ")
 	end
 
 	-- Write our string right-aligned
 	monitor.setCursorPos(math.floor(width) - math.ceil(printString:len()+gap), yPos)
 	monitor.write(printString)
 end
 
 
 -- Replaces the one from FC_API (http://pastebin.com/A9hcbZWe) and adding multi-monitor support
-		printLog("Successfully opened "..path.." for reading EOL")
+
 	local monitor = nil
 	monitor = monitorList[monitorIndex]
 
 	printLog("Called as clearMonitor(printString="..printString..",monitorIndex="..monitorIndex..").")
 
 	if not monitor then
 		printLog("monitor["..monitorIndex.."] in clearMonitor(printString="..printString..",monitorIndex="..monitorIndex..") is NOT a valid monitor.")
 		return -- Invalid monitorIndex
 	end
 
 	local gap = 2
 	monitor.clear()
 	local width, height = monitor.getSize()
 	monitor.setTextScale(1.0) -- Make sure scale is correct
 
 	printCentered(printString, 1, monitorIndex)
 	monitor.setTextColor(colors.blue)
 	print{monitorNames[monitorIndex], 1, 1, monitorIndex}
 	monitor.setTextColor(colors.white)
 
 	for i=1, width do
 		monitor.setCursorPos(i, gap)
 		monitor.write("-")
 	end
 
 	monitor.setCursorPos(1, gap+1)
 end -- function clearMonitor(printString, monitorIndex)
 
 
 -- Return a list of all connected (including via wired modems) devices of "deviceType"
 local function getDevices(deviceType)
 	printLog("Called as getDevices(deviceType="..deviceType..")")
 
 	local deviceName = nil
 	local deviceIndex = 1
 	local deviceList, deviceNames = {}, {} -- Empty array, which grows as we need
 	local peripheralList = peripheral.getNames() -- Get table of connected peripherals
 
 	deviceType = deviceType:lower() -- Make sure we're matching case here
 
 	for peripheralIndex = 1, #peripheralList do
 		-- Log every device found
 		-- printLog("Found "..peripheral.getType(peripheralList[peripheralIndex]).."["..peripheralIndex.."] attached as \""..peripheralList[peripheralIndex].."\".")
 		if (string.lower(peripheral.getType(peripheralList[peripheralIndex])) == deviceType) then
 			-- Log devices found which match deviceType and which device index we give them
 			printLog("Found "..peripheral.getType(peripheralList[peripheralIndex]).."["..peripheralIndex.."] as index \"["..deviceIndex.."]\" attached as \""..peripheralList[peripheralIndex].."\".")
 			write("Found "..peripheral.getType(peripheralList[peripheralIndex]).."["..peripheralIndex.."] as index \"["..deviceIndex.."]\" attached as \""..peripheralList[peripheralIndex].."\".\n")
 			deviceNames[deviceIndex] = peripheralList[peripheralIndex]
-		printLog("Could NOT opened "..path.." for reading! EOL")
+
 			deviceIndex = deviceIndex + 1
 		end
 	end -- for peripheralIndex = 1, #peripheralList do
 
 	return deviceList, deviceNames
 end -- function getDevices(deviceType)
 
 -- Draw a line across the entire x-axis
 local function drawLine(yPos, monitorIndex)
 	local monitor = nil
 	monitor = monitorList[monitorIndex]
 
 	if not monitor then
 		printLog("monitor["..monitorIndex.."] in drawLine() is NOT a valid monitor.")
 		return -- Invalid monitorIndex
 	end
 
 	local width, height = monitor.getSize()
 
 	for i=1, width do
 		monitor.setCursorPos(i, yPos)
 		monitor.write("-")
 	end
 end -- function drawLine(yPos,monitorIndex)
 
 
 -- Display a solid bar of specified color
 local function drawBar(startXPos, startYPos, endXPos, endYPos, color, monitorIndex)
 	local monitor = nil
 	monitor = monitorList[monitorIndex]
 
 	if not monitor then
 		printLog("monitor["..monitorIndex.."] in drawBar() is NOT a valid monitor.")
 		return -- Invalid monitorIndex
 	end
 
 	-- PaintUtils only outputs to term., not monitor.
 	-- See http://www.computercraft.info/forums2/index.php?/topic/15540-paintutils-on-a-monitor/
 	term.redirect(monitor)
 	paintutils.drawLine(startXPos, startYPos, endXPos, endYPos, color)
 	monitor.setBackgroundColor(colors.black) -- PaintUtils doesn't restore the color
 	termRestore()
 end -- function drawBar(startXPos, startYPos,endXPos,endYPos,color,monitorIndex)
 
 
 -- Display single pixel color
 local function drawPixel(xPos, yPos, color, monitorIndex)
 	local monitor = nil
 	monitor = monitorList[monitorIndex]
 
 	if not monitor then
-		printLog("monitor["..monitorIndex.."] in printCentered() is NOT a valid monitor.", ERROR)
+
 		return -- Invalid monitorIndex
 	end
 
 	-- PaintUtils only outputs to term., not monitor.
 	-- See http://www.computercraft.info/forums2/index.php?/topic/15540-paintutils-on-a-monitor/
 	term.redirect(monitor)
 	paintutils.drawPixel(xPos, yPos, color)
 	monitor.setBackgroundColor(colors.black) -- PaintUtils doesn't restore the color
 	termRestore()
 end -- function drawPixel(xPos, yPos, color, monitorIndex)
-		width = width - monitorNameLength -- add a space
+
 
 -- End helper functions
-		if monitorAssignments[monitorNames[monitorIndex]].type ~= "Status" then
+
 
 -- Then initialize the monitors
 local function findMonitors()
 	-- Empty out old list of monitors
-	monitor.setCursorPos(monitorNameLength + math.ceil((1 + width - printString:len())/2), yPos)
+
 
 	printLog("Finding monitors...")
 	monitorList, monitorNames = getDevices("monitor")
 
 	if #monitorList == 0 then
 		printLog("No monitors found!")
 		error("Can't find any monitors!")
 	else
 		for monitorIndex = 1, #monitorList do
 			local monitor, monitorX, monitorY = nil, nil, nil
 			monitor = monitorList[monitorIndex]
-		printLog("monitor["..monitorIndex.."] in printLeft() is NOT a valid monitor.", ERROR)
+
 			if not monitor then
 				printLog("monitorList["..monitorIndex.."] in findMonitors() is NOT a valid monitor.")
 
 				table.remove(monitorList, monitorIndex) -- Remove invalid monitor from list
 				if monitorIndex ~= #monitorList then    -- If we're not at the end, clean up
 					monitorIndex = monitorIndex - 1 -- We just removed an element
 				end -- if monitorIndex == #monitorList then
 				break -- Invalid monitorIndex
 			else -- valid monitor
 				monitorX, monitorY = monitor.getSize()
 				if (monitorX == nil) or (monitorY == nil) then -- somehow a valid monitor, but non-existent sizes? Maybe fixes Issue #3
 					printLog("monitorList["..monitorIndex.."] in findMonitors() is NOT a valid sized monitor.")
 
 					table.remove(monitorList, monitorIndex) -- Remove invalid monitor from list
 					if monitorIndex ~= #monitorList then    -- If we're not at the end, clean up
 						monitorIndex = monitorIndex - 1 -- We just removed an element
 					end -- if monitorIndex == #monitorList then
 					break -- Invalid monitorIndex
 
 				-- Check for minimum size to allow for monitor.setTextScale(0.5) to work for 3x2 debugging monitor, changes getSize()
 				elseif monitorX < 29 or monitorY < 12 then
 					term.redirect(monitor)
 					monitor.clear()
 					printLog("Removing monitor "..monitorIndex.." for being too small.")
 					monitor.setCursorPos(1,2)
 					write("Monitor is the wrong size!\n")
-		printLog("monitor["..monitorIndex.."] in printRight() is NOT a valid monitor.", ERROR)
+
 					termRestore()
 
 					table.remove(monitorList, monitorIndex) -- Remove invalid monitor from list
 					if monitorIndex == #monitorList then    -- If we're at the end already, break from loop
 						break
 					else
 						monitorIndex = monitorIndex - 1 -- We just removed an element
 					end -- if monitorIndex == #monitorList then
 
 				end -- if monitorX < 29 or monitorY < 12 then
 			end -- if not monitor then
 
 			printLog("Monitor["..monitorIndex.."] named \""..monitorNames[monitorIndex].."\" is a valid monitor of size x:"..monitorX.." by y:"..monitorY..".")
 		end -- for monitorIndex = 1, #monitorList do
 	end -- if #monitorList == 0 then
 
 	printLog("Found "..#monitorList.." monitor(s) in findMonitors().")
 end -- local function findMonitors()
 
 
 -- Initialize all Big Reactors - Reactors
 local function findReactors()
 	-- Empty out old list of reactors
 	newReactorList = {}
 	printLog("Finding reactors...")
 	newReactorList, reactorNames = getDevices("BigReactors-Reactor")
 
 	if #newReactorList == 0 then
 		printLog("No reactors found!")
-		printLog("monitor["..monitorIndex.."] in clearMonitor(printString="..printString..",monitorIndex="..monitorIndex..") is NOT a valid monitor.", ERROR)
+
 	else  -- Placeholder
 		for reactorIndex = 1, #newReactorList do
 			local reactor = nil
 			reactor = newReactorList[reactorIndex]
 
 			if not reactor then
 				printLog("reactorList["..reactorIndex.."] in findReactors() is NOT a valid Big Reactor.")
 
 				table.remove(newReactorList, reactorIndex) -- Remove invalid reactor from list
 				if reactorIndex ~= #newReactorList then    -- If we're not at the end, clean up
 					reactorIndex = reactorIndex - 1 -- We just removed an element
 				end -- reactorIndex ~= #newReactorList then
 				return -- Invalid reactorIndex
 			else
 				printLog("reactor["..reactorIndex.."] in findReactors() is a valid Big Reactor.")
 				--initialize the default table
 				_G[reactorNames[reactorIndex]] = {}
 				_G[reactorNames[reactorIndex]]["ReactorOptions"] = {}
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["baseControlRodLevel"] = 80
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["lastTempPoll"] = 0
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["autoStart"] = true
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["activeCooled"] = true
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMaxTemp"] = 1400 --set for passive-cooled, the active-cooled subroutine will correct it
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMinTemp"] = 1000
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"] = false
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorName"] = reactorNames[reactorIndex]
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorCruising"] = false
 				if reactor.getConnected() then
 					printLog("reactor["..reactorIndex.."] in findReactors() is connected.")
 				else
 					printLog("reactor["..reactorIndex.."] in findReactors() is NOT connected.")
 					return -- Disconnected reactor
 				end
 			end
 
 			--failsafe
 			local tempTable = _G[reactorNames[reactorIndex]]
 
 			--check to make sure we get a valid config
 			if (config.load(reactorNames[reactorIndex]..".options")) ~= nil then
 				tempTable = config.load(reactorNames[reactorIndex]..".options")
 			else
 				--if we don't have a valid config from disk, make a valid config
 				config.save(reactorNames[reactorIndex]..".options", _G[reactorNames[reactorIndex]])
 			end
 
 			--load values from tempTable, checking for nil values along the way
 			if tempTable["ReactorOptions"]["baseControlRodLevel"] ~= nil then
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["baseControlRodLevel"] = tempTable["ReactorOptions"]["baseControlRodLevel"]
 			end
 
 			if tempTable["ReactorOptions"]["lastTempPoll"] ~= nil then
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["lastTempPoll"] = tempTable["ReactorOptions"]["lastTempPoll"]
 			end
 
 			if tempTable["ReactorOptions"]["autoStart"] ~= nil then
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["autoStart"] = tempTable["ReactorOptions"]["autoStart"]
 			end
 
 			if tempTable["ReactorOptions"]["activeCooled"] ~= nil then
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["activeCooled"] = tempTable["ReactorOptions"]["activeCooled"]
 			end
 
 			if tempTable["ReactorOptions"]["reactorMaxTemp"] ~= nil then
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMaxTemp"] = tempTable["ReactorOptions"]["reactorMaxTemp"]
 			end
 
 			if tempTable["ReactorOptions"]["reactorMinTemp"] ~= nil then
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMinTemp"] = tempTable["ReactorOptions"]["reactorMinTemp"]
 			end
 
 			if tempTable["ReactorOptions"]["rodOverride"] ~= nil then
 				printLog("Got value from config file for Rod Override, the value is: "..tostring(tempTable["ReactorOptions"]["rodOverride"]).." EOL")
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"] = tempTable["ReactorOptions"]["rodOverride"]
 			end
 
 			if tempTable["ReactorOptions"]["reactorName"] ~= nil then
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorName"] = tempTable["ReactorOptions"]["reactorName"]
 			end
 
 			if tempTable["ReactorOptions"]["reactorCruising"] ~= nil then
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorCruising"] = tempTable["ReactorOptions"]["reactorCruising"]
 			end
 
 			--stricter typing, let's set these puppies up with the right type of value.
 			_G[reactorNames[reactorIndex]]["ReactorOptions"]["baseControlRodLevel"] = tonumber(_G[reactorNames[reactorIndex]]["ReactorOptions"]["baseControlRodLevel"])
 
 			_G[reactorNames[reactorIndex]]["ReactorOptions"]["lastTempPoll"] = tonumber(_G[reactorNames[reactorIndex]]["ReactorOptions"]["lastTempPoll"])
 
 			if (tostring(_G[reactorNames[reactorIndex]]["ReactorOptions"]["autoStart"]) == "true") then
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["autoStart"] = true
 			else
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["autoStart"] = false
 			end
 
 			if (tostring(_G[reactorNames[reactorIndex]]["ReactorOptions"]["activeCooled"]) == "true") then
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["activeCooled"] = true
 			else
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["activeCooled"] = false
 			end
 
 			_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMaxTemp"] = tonumber(_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMaxTemp"])
 
 			_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMinTemp"] = tonumber(_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMinTemp"])
-local function saveMonitorAssignments()
+
-	local assignments = {}
+
-	for monitor, data in pairs(monitorAssignments) do
+
-		local name = nil
+
-		if (data.type == "Reactor") then
+
-			name = data.reactorName
+
-		elseif (data.type == "Turbine") then
+
-			name = data.turbineName
+
 
-			name = data.type
+
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorCruising"] = true
-		assignments[monitor] = name
+
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorCruising"] = false
-	config.save(monitorOptionFileName, {Monitors = assignments})
+
 
 			--save one more time, in case we didn't have a complete config file before
-UI = {
+
-	monitorIndex = 1,
+
-	reactorIndex = 1,
+
-	turbineIndex = 1
+
-}
+
 	reactorList = newReactorList
-UI.handlePossibleClick = function(self)
+
-	local monitorData = monitorAssignments[sideClick]
+	-- Start turbine monitor offset after reactors get monitors
-	if monitorData == nil then
+	-- This assumes that there is a monitor for each turbine and reactor, plus the overall monitor display
-		printLog("UI.handlePossibleClick(): "..sideClick.." is unassigned, can't handle click", WARN)
+	turbineMonitorOffset = #reactorList + 1 -- #turbineList will start at "1" if turbines found and move us just beyond #reactorList and status monitor range
-		return
+
 	printLog("Found "..#reactorList.." reactor(s) in findReactors().")
 	printLog("Set turbineMonitorOffset to "..turbineMonitorOffset.." in findReactors().")
-	self.monitorIndex = monitorData.index
+
-	local width, height = monitorList[self.monitorIndex].getSize()
+
-	-- All the last line are belong to us
+
-	if (yClick == height) then
+
-		if (monitorData.type == "Reactor") then
+
-			if (xClick == 1) then
+
-				self:selectPrevReactor()
+
-			elseif (xClick == width) then
+
-				self:selectNextReactor()
+
-			elseif (3 <= xClick and xClick <= width - 2) then
+
-				self:selectTurbine()
+
 	if #newTurbineList == 0 then
-		elseif (monitorData.type == "Turbine") then
+
-			if (xClick == 1) then
+
-				self:selectPrevTurbine()
+
-			elseif (xClick == width) then
+
-				self:selectNextTurbine()
+
-			elseif (3 <= xClick and xClick <= width - 2) then
+
-				self:selectStatus()
+
 				printLog("turbineList["..turbineIndex.."] in findTurbines() is NOT a valid Big Reactors Turbine.")
-		elseif (monitorData.type == "Status") then
+
-			if (xClick == 1) then
+
-				self.turbineIndex = #turbineList
+
-				self:selectTurbine()
+
-			elseif (xClick == width) then
+
-				self.reactorIndex = 1
+
-				self:selectReactor()
+
-			elseif (3 <= xClick and xClick <= width - 2) then
+
-				self:selectReactor()
+
 				_G[turbineNames[turbineIndex]] = {}
 				_G[turbineNames[turbineIndex]]["TurbineOptions"] = {}
-			self:selectStatus()
+
 				_G[turbineNames[turbineIndex]]["TurbineOptions"]["BaseSpeed"] = 2726
-		-- Yes, that means we're skipping Debug. I figure everyone who wants that is
+
-		-- bound to use the console key commands anyway, and that way we don't have
+
-		-- it interfere with regular use.
+
 				_G[turbineNames[turbineIndex]]["TurbineOptions"]["turbineName"] = turbineNames[turbineIndex]
 				printLog("turbineList["..turbineIndex.."] in findTurbines() is a valid Big Reactors Turbine.")
 				if turbine.getConnected() then
-		if (monitorData.type == "Turbine") then
+
-			self:handleTurbineMonitorClick(monitorData.turbineIndex, monitorData.index)
+
-		elseif (monitorData.type == "Reactor") then
+
-			self:handleReactorMonitorClick(monitorData.reactorIndex, monitorData.index)
+
 				end
 			end
-end -- UI.handlePossibleClick()
+
 			--failsafe
-UI.logChange = function(self, messageText)
+
-	printLog("UI: "..messageText)
+
 			--check to make sure we get a valid config
-	write(messageText.."\n")
+
 				tempTable = config.load(turbineNames[turbineIndex]..".options")
 			else
-UI.selectNextMonitor = function(self)
+
-	self.monitorIndex = self.monitorIndex + 1
+
-	if self.monitorIndex > #monitorList then
+
-		self.monitorIndex = 1
+
 			--load values from tempTable, checking for nil values along the way
-	local messageText = "Selected monitor "..monitorNames[self.monitorIndex]
+
-	self:logChange(messageText)
+
-end -- UI.selectNextMonitor()
+
 
 			if tempTable["TurbineOptions"]["BaseSpeed"] ~= nil then
-UI.selectReactor = function(self)
+
-	monitorAssignments[monitorNames[self.monitorIndex]] = {type="Reactor", index=self.monitorIndex, reactorName=reactorNames[self.reactorIndex], reactorIndex=self.reactorIndex}
+
-	saveMonitorAssignments()
+
-	local messageText = "Selected reactor "..reactorNames[self.reactorIndex].." for display on "..monitorNames[self.monitorIndex]
+
-	self:logChange(messageText)
+
-end -- UI.selectReactor()
+
 
-UI.selectPrevReactor = function(self)
+
-	if self.reactorIndex <= 1 then
+
-		self.reactorIndex = #reactorList
+
-		self:selectStatus()
+
 			if tempTable["TurbineOptions"]["flowOverride"] ~= nil then
-		self.reactorIndex = self.reactorIndex - 1
+
-		self:selectReactor()
+
 
-end -- UI.selectPrevReactor()
+
 				_G[turbineNames[turbineIndex]]["TurbineOptions"]["turbineName"] = tempTable["TurbineOptions"]["turbineName"]
-UI.selectNextReactor = function(self)
+
-	if self.reactorIndex >= #reactorList then
+
-		self.reactorIndex = 1
+
-		self.turbineIndex = 1
+
-		self:selectTurbine()
+
 
-		self.reactorIndex = self.reactorIndex + 1
+
-		self:selectReactor()
+
 	end -- if #newTurbineList == 0 then
-end -- UI.selectNextReactor()
+
 	printLog("Found "..#turbineList.." turbine(s) in findTurbines().")
 end -- function findTurbines()
-UI.selectTurbine = function(self)
+
-	monitorAssignments[monitorNames[self.monitorIndex]] = {type="Turbine", index=self.monitorIndex, turbineName=turbineNames[self.turbineIndex], turbineIndex=self.turbineIndex}
+
-	saveMonitorAssignments()
+
-	local messageText = "Selected turbine "..turbineNames[self.turbineIndex].." for display on "..monitorNames[self.monitorIndex]
+
-	self:logChange(messageText)
+
-end -- UI.selectTurbine()
+
 	if not reactor then
-UI.selectPrevTurbine = function(self)
+
-	if self.turbineIndex <= 1 then
+
-		self.turbineIndex = #turbineList
+
-		self.reactorIndex = #reactorList
+
-		self:selectReactor()
+
 
-		self.turbineIndex = self.turbineIndex - 1
+
-		self:selectTurbine()
+
 end -- function getReactorStoredEnergyBufferPercent(reactor)
-end -- UI.selectPrevTurbine()
+
 
-UI.selectNextTurbine = function(self)
+
-	if self.turbineIndex >= #turbineList then
+
-		self.turbineIndex = 1
+
-		self:selectStatus()
+
 	if not turbine then
-		self.turbineIndex = self.turbineIndex + 1
+
-		self:selectTurbine()
+
 	else
-end -- UI.selectNextTurbine()
+
 	end
 
-UI.selectStatus = function(self)
+
-	monitorAssignments[monitorNames[self.monitorIndex]] = {type="Status", index=self.monitorIndex}
+
-	saveMonitorAssignments()
+
-	local messageText = "Selected status summary for display on "..monitorNames[self.monitorIndex]
+
-	self:logChange(messageText)
+
-end -- UI.selectStatus()
+
 
-UI.selectDebug = function(self)
+
-	monitorAssignments[monitorNames[self.monitorIndex]] = {type="Debug", index=self.monitorIndex}
+
-	saveMonitorAssignments()
+
-	monitorList[self.monitorIndex].clear()
+
-	local messageText = "Selected debug output for display on "..monitorNames[self.monitorIndex]
+
-	self:logChange(messageText)
+
-end -- UI.selectDebug()
+
 		reactor = reactorList[reactorIndex]
--- Allow controlling Reactor Control Rod Level from GUI
+
-UI.handleReactorMonitorClick = function(self, reactorIndex, monitorIndex)
+
 			return -- Invalid reactorIndex
 		else
 			printLog("reactor["..reactorIndex.."] in reactorCruise(cruiseMaxTemp="..cruiseMaxTemp..",cruiseMinTemp="..cruiseMinTemp..",lastPolledTemp="..lastPolledTemp..",reactorIndex="..reactorIndex..") is a valid Big Reactor.")
 			if reactor.getConnected() then
 				printLog("reactor["..reactorIndex.."] in reactorCruise(cruiseMaxTemp="..cruiseMaxTemp..",cruiseMinTemp="..cruiseMinTemp..",lastPolledTemp="..lastPolledTemp..",reactorIndex="..reactorIndex..") is connected.")
 			else
 				printLog("reactor["..reactorIndex.."] in reactorCruise(cruiseMaxTemp="..cruiseMaxTemp..",cruiseMinTemp="..cruiseMinTemp..",lastPolledTemp="..lastPolledTemp..",reactorIndex="..reactorIndex..") is NOT connected.")
 				return -- Disconnected reactor
 			end -- if reactor.getConnected() then
 		end -- if not reactor then
 
 		local rodPercentage = math.ceil(reactor.getControlRodLevel(0))
 		local reactorTemp = math.ceil(reactor.getFuelTemperature())
 		_G[reactorNames[reactorIndex]]["ReactorOptions"]["baseControlRodLevel"] = rodPercentage
 
 		if ((reactorTemp < cruiseMaxTemp) and (reactorTemp > cruiseMinTemp)) then
-		printLog("reactor["..reactorIndex.."] in handleReactorMonitorClick(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is NOT a valid Big Reactor.")
+
 				rodPercentage = (rodPercentage - 1)
 				--Boundary check
-		printLog("reactor["..reactorIndex.."] in handleReactorMonitorClick(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is a valid Big Reactor.")
+
 					reactor.setAllControlRodLevels(0)
-			printLog("reactor["..reactorIndex.."] in handleReactorMonitorClick(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is connected.")
+
 					reactor.setAllControlRodLevels(rodPercentage)
-			printLog("reactor["..reactorIndex.."] in handleReactorMonitorClick(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is NOT connected.")
+
 			else
 				rodPercentage = (rodPercentage + 1)
 				--Boundary check
 				if rodPercentage > 99 then
-	local reactorStatus = _G[reactorNames[reactorIndex]]["ReactorOptions"]["Status"]
+
 				else
 					reactor.setAllControlRodLevels(rodPercentage)
-	if xClick >= (width - string.len(reactorStatus) - 1) and xClick <= (width-1) and (sideClick == monitorNames[monitorIndex]) then
+
-		if yClick == 1 then
+
-			reactor.setActive(not reactor.getActive()) -- Toggle reactor status
+
-			_G[reactorNames[reactorIndex]]["ReactorOptions"]["autoStart"] = reactor.getActive()
+
 			_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorCruising"] = false
 		end -- if ((reactorTemp < cruiseMaxTemp) and (reactorTemp > cruiseMinTemp)) then
 	else
-			-- If someone offlines the reactor (offline after a status click was detected), then disable autoStart
+
-			if not reactor.getActive() then
+
 	end -- if ((lastPolledTemp < cruiseMaxTemp) and (lastPolledTemp > cruiseMinTemp)) then
 	_G[reactorNames[reactorIndex]]["ReactorOptions"]["lastTempPoll"] = reactorTemp
-		end -- if yClick == 1 then
+
-	end -- if (xClick >= (width - string.len(reactorStatus) - 1) and xClick <= (width-1)) and (sideClick == monitorNames[monitorIndex]) then
+
 	_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMinTemp"] = cruiseMinTemp
-	-- Allow disabling rod level auto-adjust and only manual rod level control
+
-	if ((xClick > 23 and xClick < 28 and yClick == 4)
+
-			or (xClick > 20 and xClick < 27 and yClick == 9))
+
-			and (sideClick == monitorNames[monitorIndex]) then
+
-		_G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"] = not _G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"]
+
 local function temperatureControl(reactorIndex)
-		sideClick, xClick, yClick = 0, 0, 0 -- Reset click after we register it
+
-	end -- if (xClick > 23) and (xClick < 28) and (yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
+
 	local reactor = nil
 	reactor = reactorList[reactorIndex]
-	local newRodPercentage = rodPercentage
+
 		printLog("reactor["..reactorIndex.."] in temperatureControl(reactorIndex="..reactorIndex..") is NOT a valid Big Reactor.")
-		printLog("Decreasing Rod Levels in handleReactorMonitorClick(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
+
 	else
 		printLog("reactor["..reactorIndex.."] in temperatureControl(reactorIndex="..reactorIndex..") is a valid Big Reactor.")
 
 		if reactor.getConnected() then
 			printLog("reactor["..reactorIndex.."] in temperatureControl(reactorIndex="..reactorIndex..") is connected.")
 		else
 			printLog("reactor["..reactorIndex.."] in temperatureControl(reactorIndex="..reactorIndex..") is NOT connected.")
-		printLog("Setting reactor["..reactorIndex.."] Rod Levels to "..newRodPercentage.."% in handleReactorMonitorClick(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
+
 		end -- if reactor.getConnected() then
 	end
 
 	local reactorNum = reactorIndex
 	local rodPercentage = math.ceil(reactor.getControlRodLevel(0))
 	local reactorTemp = math.ceil(reactor.getFuelTemperature())
 	local localMinReactorTemp, localMaxReactorTemp = _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMinTemp"], _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMaxTemp"]
-		printLog("Increasing Rod Levels in handleReactorMonitorClick(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
+
 	--bypass if the reactor itself is set to not be auto-controlled
 	if ((not _G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"]) or (_G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"] == "false")) then
 		-- No point modifying control rod levels for temperature if the reactor is offline
 		if reactor.getActive() then
 			-- Actively cooled reactors should range between 0^C-300^C
 			-- Actually, active-cooled reactors should range between 300 and 420C (Mechaet)
 			-- Accordingly I changed the below lines
-		printLog("Setting reactor["..reactorIndex.."] Rod Levels to "..newRodPercentage.."% in handleReactorMonitorClick(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
+
 				-- below was 0
 				localMinReactorTemp = 300
 				-- below was 300
 				localMaxReactorTemp = 420
 			else
 				localMinReactorTemp = _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMinTemp"]
 				localMaxReactorTemp = _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMaxTemp"]
-		printLog("No change to Rod Levels requested by "..progName.." GUI in handleReactorMonitorClick(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
+
 			local lastTempPoll = _G[reactorNames[reactorIndex]]["ReactorOptions"]["lastTempPoll"]
-end -- UI.handleReactorMonitorClick = function(self, reactorIndex, monitorIndex)
+
 				--let's bypass all this math and hit the much-more-subtle cruise feature
--- Allow controlling Turbine Flow Rate from GUI
+
-UI.handleTurbineMonitorClick = function(self, turbineIndex, monitorIndex)
+
 			else
 				-- Don't bring us to 100, that's effectively a shutdown
 				if (reactorTemp > localMaxReactorTemp) and (rodPercentage ~= 99) then
 					--increase the rods, but by how much?
 					if (reactorTemp > lastTempPoll) then
 						--we're climbing, we need to get this to decrease
 						if ((reactorTemp - lastTempPoll) > 100) then
 							--we're climbing really fast, arrest it
 							if (rodPercentage + (10 * controlRodAdjustAmount)) > 99 then
 								reactor.setAllControlRodLevels(99)
 							else
 								reactor.setAllControlRodLevels(rodPercentage + (10 * controlRodAdjustAmount))
 							end
 						else
 							--we're not climbing by leaps and bounds, let's give it a rod adjustment based on temperature increase
 							local diffAmount = reactorTemp - lastTempPoll
-		printLog("turbine["..turbineIndex.."] in handleTurbineMonitorClick(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is NOT a valid Big Turbine.")
+
 							controlRodAdjustAmount = diffAmount
 							if (rodPercentage + controlRodAdjustAmount) > 99 then
-		printLog("turbine["..turbineIndex.."] in handleTurbineMonitorClick(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is a valid Big Turbine.")
+
 							else
-			printLog("turbine["..turbineIndex.."] in handleTurbineMonitorClick(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is connected.")
+								reactor.setAllControlRodLevels(rodPercentage + controlRodAdjustAmount)
 							end
-			printLog("turbine["..turbineIndex.."] in handleTurbineMonitorClick(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is NOT connected.")
+
 					elseif (reactorTemp == lastTempPoll) then
 						--temperature has stagnated, kick it very lightly
 						local controlRodAdjustment = 1
 						if (rodPercentage + controlRodAdjustment) > 99 then
 							reactor.setAllControlRodLevels(99)
 						else
-	local turbineStatus = _G[turbineNames[turbineIndex]]["TurbineOptions"]["Status"]
+
 						end
 					end --if (reactorTemp > lastTempPoll) then
-	if (xClick >= (width - string.len(turbineStatus) - 1)) and (xClick <= (width-1)) and (sideClick == monitorNames[monitorIndex]) then
+
-		if yClick == 1 then
+
-			turbine.setActive(not turbine.getActive()) -- Toggle turbine status
+				elseif (reactorTemp < localMinReactorTemp) and (rodPercentage ~=0) then
-			_G[turbineNames[turbineIndex]]["TurbineOptions"]["autoStart"] = turbine.getActive()
+
 					if (reactorTemp < lastTempPoll) then
 						--we're descending, let's stop that.
 						if ((lastTempPoll - reactorTemp) > 100) then
-		end -- if yClick == 1 then
+
-	end -- if (xClick >= (width - string.len(turbineStatus) - 1)) and (xClick <= (width-1)) and (sideClick == monitorNames[monitorIndex]) then
+							if (rodPercentage - (10 * controlRodAdjustAmount)) < 0 then
 								reactor.setAllControlRodLevels(0)
-	-- Allow disabling/enabling flow rate auto-adjust
+
-	if (xClick > 23 and xClick < 28 and yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
+								reactor.setAllControlRodLevels(rodPercentage - (10 * controlRodAdjustAmount))
-		_G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] = true
+
-		sideClick, xClick, yClick = 0, 0, 0 -- Reset click after we register it
+
-	elseif (xClick > 20 and xClick < 27 and yClick == 10) and (sideClick == monitorNames[monitorIndex]) then
+
 							local diffAmount = lastTempPoll - reactorTemp
-		if ((_G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"]) or (_G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] == "true")) then
+
-			_G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] = false
+							controlRodAdjustAmount = diffAmount
 							if (rodPercentage - controlRodAdjustAmount) < 0 then
 								reactor.setAllControlRodLevels(0)
 							else
-		sideClick, xClick, yClick = 0, 0, 0 -- Reset click after we register it
+								reactor.setAllControlRodLevels(rodPercentage - controlRodAdjustAmount)
 							end
 						end --if ((lastTempPoll - reactorTemp) > 100) then
 					elseif (reactorTemp == lastTempPoll) then
 						--temperature has stagnated, kick it very lightly
-		printLog("Decrease to Flow Rate requested by "..progName.." GUI in handleTurbineMonitorClick(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
+
 						if (rodPercentage - controlRodAdjustment) < 0 then
 							reactor.setAllControlRodLevels(0)
 						else
 							reactor.setAllControlRodLevels(rodPercentage - controlRodAdjustment)
 						end --if (rodPercentage - controlRodAdjustment) < 0 then
 
 					end --if (reactorTemp < lastTempPoll) then
 					--if we're below temp but increasing, do nothing and let it continue to rise.
 				end --if (reactorTemp > localMaxReactorTemp) and (rodPercentage ~= 99) then
 
 				if ((reactorTemp > localMinReactorTemp) and (reactorTemp < localMaxReactorTemp)) then
 					--engage cruise mode
 					_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorCruising"] = true
 				end -- if ((reactorTemp > localMinReactorTemp) and (reactorTemp < localMaxReactorTemp)) then
 			end -- if reactorCruising then
 			--always set this number
 			_G[reactorNames[reactorIndex]]["ReactorOptions"]["lastTempPoll"] = reactorTemp
 			config.save(reactorNames[reactorIndex]..".options", _G[reactorNames[reactorIndex]])
 		end -- if reactor.getActive() then
 	else
-		printLog("Increase to Flow Rate requested by "..progName.." GUI in handleTurbineMonitorClick(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
+
 	end -- if not _G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"] then
 end -- function temperatureControl(reactorIndex)
 
 -- Load saved reactor parameters if ReactorOptions file exists
 local function loadReactorOptions()
 	local reactorOptions = fs.open("ReactorOptions", "r") -- See http://computercraft.info/wiki/Fs.open
 
 	if reactorOptions then
 		-- The following values were added by Lolmer
 		minStoredEnergyPercent = reactorOptions.readLine()
 		maxStoredEnergyPercent = reactorOptions.readLine()
 		--added by Mechaet
 		-- If we succeeded in reading a string, convert it to a number
 
 		if minStoredEnergyPercent ~= nil then
 			minStoredEnergyPercent = tonumber(minStoredEnergyPercent)
 		end
 
 		if maxStoredEnergyPercent ~= nil then
 			maxStoredEnergyPercent = tonumber(maxStoredEnergyPercent)
 		end
-		printLog("No change to Flow Rate requested by "..progName.." GUI in handleTurbineMonitorClick(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
+
 		reactorOptions.close()
 	end -- if reactorOptions then
 
-		printLog("Decrease to Turbine RPM requested by "..progName.." GUI in handleTurbineMonitorClick(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
+
 	if minStoredEnergyPercent == nil then
 		minStoredEnergyPercent = 15
 	end
 
 	if maxStoredEnergyPercent == nil then
 		maxStoredEnergyPercent = 85
 	end
 
 end -- function loadReactorOptions()
-		printLog("Increase to Turbine RPM requested by "..progName.." GUI in handleTurbineMonitorClick(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
+
 
 -- Save our reactor parameters
 local function saveReactorOptions()
 	local reactorOptions = fs.open("ReactorOptions", "w") -- See http://computercraft.info/wiki/Fs.open
 
 	-- If we can save the files, save them
 	if reactorOptions then
 		local reactorIndex = 1
 		-- The following values were added by Lolmer
-		printLog("No change to Turbine RPM requested by "..progName.." GUI in handleTurbineMonitorClick(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
+
 		reactorOptions.writeLine(maxStoredEnergyPercent)
-end -- function handleTurbineMonitorClick(turbineIndex, monitorIndex)
+
 	else
 		printLog("Failed to open file ReactorOptions for writing!")
 	end -- if reactorOptions then
 end -- function saveReactorOptions()
 
 
 local function displayReactorBars(barParams)
 	-- Default to first reactor and first monitor
 	setmetatable(barParams,{__index={reactorIndex=1, monitorIndex=1}})
 	local reactorIndex, monitorIndex =
 		barParams[1] or barParams.reactorIndex,
 		barParams[2] or barParams.monitorIndex
 
 	printLog("Called as displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
-		printLog("No monitors found, continuing headless")
+
 	-- Grab current monitor
 	local monitor = nil
 	monitor = monitorList[monitorIndex]
 	if not monitor then
 		printLog("monitor["..monitorIndex.."] in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is NOT a valid monitor.")
 		return -- Invalid monitorIndex
 	end
 
 	-- Grab current reactor
 	local reactor = nil
 	reactor = reactorList[reactorIndex]
 	if not reactor then
 		printLog("reactor["..reactorIndex.."] in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is NOT a valid Big Reactor.")
 		return -- Invalid reactorIndex
-				monitor.setTextScale(1.0) -- Make sure scale is correct
+
 		printLog("reactor["..reactorIndex.."] in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is a valid Big Reactor.")
 		if reactor.getConnected() then
 			printLog("reactor["..reactorIndex.."] in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is connected.")
 		else
 			printLog("reactor["..reactorIndex.."] in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is NOT connected.")
 			return -- Disconnected reactor
 		end -- if reactor.getConnected() then
 	end -- if not reactor then
 
 	-- Draw border lines
 	local width, height = monitor.getSize()
 	printLog("Size of monitor is "..width.."w x"..height.."h in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..")")
 
 	for i=3, 5 do
 		monitor.setCursorPos(22, i)
 		monitor.write("|")
 	end
 
 	drawLine(2, monitorIndex)
 	drawLine(6, monitorIndex)
 
 	-- Draw some text
 	local fuelString = "Fuel: "
 	local tempString = "Temp: "
 	local energyBufferString = ""
 
 	if reactor.isActivelyCooled() then
 		energyBufferString = "Steam: "
 	else
 		energyBufferString = "Energy: "
 	end
 
 	local padding = math.max(string.len(fuelString), string.len(tempString), string.len(energyBufferString))
 
 	local fuelPercentage = round(reactor.getFuelAmount()/reactor.getFuelAmountMax()*100,1)
 	print{fuelString,2,3,monitorIndex}
 	print{fuelPercentage.." %",padding+2,3,monitorIndex}
 
 	local reactorTemp = math.ceil(reactor.getFuelTemperature())
 	print{tempString,2,5,monitorIndex}
 	print{reactorTemp.." C",padding+2,5,monitorIndex}
 
 	local rodPercentage = math.ceil(reactor.getControlRodLevel(0))
 	printLog("Current Rod Percentage for reactor["..reactorIndex.."] is "..rodPercentage.."% in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
 	-- Allow controlling Reactor Control Rod Level from GUI
 	-- Decrease rod button: 23X, 4Y
 	-- Increase rod button: 28X, 4Y
 	if (xClick == 23) and (yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
 		printLog("Decreasing Rod Levels in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
 		--Decrease rod level by amount
 		newRodPercentage = rodPercentage - (5 * controlRodAdjustAmount)
 		if newRodPercentage < 0 then
 			newRodPercentage = 0
 		end
 		sideClick, xClick, yClick = 0, 0, 0
 
 		printLog("Setting reactor["..reactorIndex.."] Rod Levels to "..newRodPercentage.."% in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
 		reactor.setAllControlRodLevels(newRodPercentage)
 		_G[reactorNames[reactorIndex]]["ReactorOptions"]["baseControlRodLevel"] = newRodPercentage
 
 		-- Save updated rod percentage
 		config.save(reactorNames[reactorIndex]..".options", _G[reactorNames[reactorIndex]])
 		rodPercentage = newRodPercentage
 	elseif (xClick == 29) and (yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
 		printLog("Increasing Rod Levels in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
 		--Increase rod level by amount
 		newRodPercentage = rodPercentage + (5 * controlRodAdjustAmount)
 		if newRodPercentage > 100 then
 			newRodPercentage = 100
 		end
 		sideClick, xClick, yClick = 0, 0, 0
 
 		printLog("Setting reactor["..reactorIndex.."] Rod Levels to "..newRodPercentage.."% in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
 		reactor.setAllControlRodLevels(newRodPercentage)
-				_G[reactorNames[reactorIndex]]["ReactorOptions"]["controlRodAdjustAmount"] = controlRodAdjustAmount
+
 
 		-- Save updated rod percentage
 		config.save(reactorNames[reactorIndex]..".options", _G[reactorNames[reactorIndex]])
 		rodPercentage = round(newRodPercentage,0)
 	else
 		printLog("No change to Rod Levels requested by "..progName.." GUI in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
 	end -- if (xClick == 29) and (yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
 
 	print{"Rod (%)",23,3,monitorIndex}
 	print{"<     >",23,4,monitorIndex}
 	print{stringTrim(rodPercentage),25,4,monitorIndex}
 
 
 	-- getEnergyProducedLastTick() is used for both RF/t (passively cooled) and mB/t (actively cooled)
 	local energyBuffer = reactor.getEnergyProducedLastTick()
 	if reactor.isActivelyCooled() then
 		printLog("reactor["..reactorIndex.."] produced "..energyBuffer.." mB last tick in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
 	else
 		printLog("reactor["..reactorIndex.."] produced "..energyBuffer.." RF last tick in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
 	end
 
 	print{energyBufferString,2,4,monitorIndex}
 
 	-- Actively cooled reactors do not produce energy, only hot fluid mB/t to be used in a turbine
 	-- still uses getEnergyProducedLastTick for mB/t of hot fluid generated
 	if not reactor.isActivelyCooled() then
 		printLog("reactor["..reactorIndex.."] in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is NOT an actively cooled reactor.")
 
 		-- Draw stored energy buffer bar
 		drawBar(2,8,28,8,colors.gray,monitorIndex)
 
 		local curStoredEnergyPercent = getReactorStoredEnergyBufferPercent(reactor)
 		if curStoredEnergyPercent > 4 then
 			drawBar(2, 8, math.floor(26*curStoredEnergyPercent/100)+2, 8, colors.yellow, monitorIndex)
 		elseif curStoredEnergyPercent > 0 then
 			drawPixel(2, 8, colors.yellow, monitorIndex)
 		end -- if curStoredEnergyPercent > 4 then
 
 		print{"Energy Buffer",2,7,monitorIndex}
 		print{curStoredEnergyPercent, width-(string.len(curStoredEnergyPercent)+2),7,monitorIndex}
 		print{"%",28,7,monitorIndex}
 
 		print{math.ceil(energyBuffer).." RF/t",padding+2,4,monitorIndex}
 	else
 		printLog("reactor["..reactorIndex.."] in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is an actively cooled reactor.")
 		print{math.ceil(energyBuffer).." mB/t",padding+2,4,monitorIndex}
 	end -- if not reactor.isActivelyCooled() then
 
 	-- Print rod override status
 	local reactorRodOverrideStatus = ""
 
-			if tempTable["ReactorOptions"]["controlRodAdjustAmount"] ~= nil then
+
-				_G[reactorNames[reactorIndex]]["ReactorOptions"]["controlRodAdjustAmount"] = tempTable["ReactorOptions"]["controlRodAdjustAmount"]
+
 	if not _G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"] then
 		printLog("Reactor Rod Override status is: "..tostring(_G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"]).." EOL")
 		reactorRodOverrideStatus = "Enabled"
 		monitor.setTextColor(colors.green)
 	else
 		printLog("Reactor Rod Override status is: "..tostring(_G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"]).." EOL")
 		reactorRodOverrideStatus = "Disabled"
 		monitor.setTextColor(colors.red)
 	end -- if not reactorRodOverride then
 	printLog("reactorRodOverrideStatus is \""..reactorRodOverrideStatus.."\" in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
 
 	print{reactorRodOverrideStatus, width - string.len(reactorRodOverrideStatus) - 1, 9, monitorIndex}
 	monitor.setTextColor(colors.white)
 
 	print{"Reactivity: "..math.ceil(reactor.getFuelReactivity()).." %", 2, 10, monitorIndex}
 	print{"Fuel: "..round(reactor.getFuelConsumedLastTick(),3).." mB/t", 2, 11, monitorIndex}
 	print{"Waste: "..reactor.getWasteAmount().." mB", width-(string.len(reactor.getWasteAmount())+10), 11, monitorIndex}
 
 	monitor.setTextColor(colors.blue)
 	printCentered(_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorName"],12,monitorIndex)
 	monitor.setTextColor(colors.white)
 end -- function displayReactorBars(barParams)
 
 
 local function reactorStatus(statusParams)
 	-- Default to first reactor and first monitor
 	setmetatable(statusParams,{__index={reactorIndex=1, monitorIndex=1}})
 	local reactorIndex, monitorIndex =
 		statusParams[1] or statusParams.reactorIndex,
 		statusParams[2] or statusParams.monitorIndex
 	printLog("Called as reactorStatus(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..")")
 
 	-- Grab current monitor
 	local monitor = nil
 	monitor = monitorList[monitorIndex]
 	if not monitor then
 		printLog("monitor["..monitorIndex.."] in reactorStatus(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is NOT a valid monitor.")
 		return -- Invalid monitorIndex
 	end
-			_G[reactorNames[reactorIndex]]["ReactorOptions"]["controlRodAdjustAmount"] = tonumber(_G[reactorNames[reactorIndex]]["ReactorOptions"]["controlRodAdjustAmount"])
+
 	-- Grab current reactor
 	local reactor = nil
 	reactor = reactorList[reactorIndex]
 	if not reactor then
 		printLog("reactor["..reactorIndex.."] in reactorStatus(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is NOT a valid Big Reactor.")
 		return -- Invalid reactorIndex
 	else
 		printLog("reactor["..reactorIndex.."] in reactorStatus(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is a valid Big Reactor.")
 	end
 
 	local width, height = monitor.getSize()
 	local reactorStatus = ""
 
 	if reactor.getConnected() then
 		printLog("reactor["..reactorIndex.."] in reactorStatus(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is connected.")
 
 		if reactor.getActive() then
 			reactorStatus = "ONLINE"
 
 			-- Set "ONLINE" to blue if the actively cooled reactor is both in cruise mode and online
 			if _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorCruising"] and reactor.isActivelyCooled() then
 				monitor.setTextColor(colors.blue)
 			else
 				monitor.setTextColor(colors.green)
 			end -- if reactorCruising and reactor.isActivelyCooled() then
 		else
 			reactorStatus = "OFFLINE"
 			monitor.setTextColor(colors.red)
 		end -- if reactor.getActive() then
 
 		if xClick >= (width - string.len(reactorStatus) - 1) and xClick <= (width-1) and (sideClick == monitorNames[monitorIndex]) then
 			if yClick == 1 then
 				reactor.setActive(not reactor.getActive()) -- Toggle reactor status
 				_G[reactorNames[reactorIndex]]["ReactorOptions"]["autoStart"] = reactor.getActive()
 				config.save(reactorNames[reactorIndex]..".options", _G[reactorNames[reactorIndex]])
 				sideClick, xClick, yClick = 0, 0, 0 -- Reset click after we register it
 
 				-- If someone offlines the reactor (offline after a status click was detected), then disable autoStart
 				if not reactor.getActive() then
 					_G[reactorNames[reactorIndex]]["ReactorOptions"]["autoStart"] = false
 				end
 			end -- if yClick == 1 then
 		end -- if (xClick >= (width - string.len(reactorStatus) - 1) and xClick <= (width-1)) and (sideClick == monitorNames[monitorIndex]) then
 
 		-- Allow disabling rod level auto-adjust and only manual rod level control
 		if ((xClick > 23 and xClick < 28 and yClick == 4)
 				or (xClick > 20 and xClick < 27 and yClick == 9))
 				and (sideClick == monitorNames[monitorIndex]) then
 			_G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"] = not _G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"]
 			config.save(reactorNames[reactorIndex]..".options", _G[reactorNames[reactorIndex]])
 			sideClick, xClick, yClick = 0, 0, 0 -- Reset click after we register it
 		end -- if (xClick > 23) and (xClick < 28) and (yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
 
 	else
 		printLog("reactor["..reactorIndex.."] in reactorStatus(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is NOT connected.")
 		reactorStatus = "DISCONNECTED"
 		monitor.setTextColor(colors.red)
 	end -- if reactor.getConnected() then
 
 	print{reactorStatus, width - string.len(reactorStatus) - 1, 1, monitorIndex}
 	monitor.setTextColor(colors.white)
 end -- function reactorStatus(statusParams)
 
 
 -- Display all found reactors' status to monitor 1
 -- This is only called if multiple reactors and/or a reactor plus at least one turbine are found
 local function displayAllStatus()
 	local reactor, turbine = nil, nil
 	local onlineReactor, onlineTurbine = 0, 0
 	local totalReactorRF, totalReactorSteam, totalTurbineRF = 0, 0, 0
 	local totalReactorFuelConsumed = 0
 	local totalCoolantStored, totalSteamStored, totalEnergy, totalMaxEnergyStored = 0, 0, 0, 0 -- Total turbine and reactor energy buffer and overall capacity
 	local maxSteamStored = (2000*#turbineList)+(5000*#reactorList)
 	local maxCoolantStored = (2000*#turbineList)+(5000*#reactorList)
 
 	local monitor, monitorIndex = nil, 1
 	monitor = monitorList[monitorIndex]
 	if not monitor then
 		printLog("monitor["..monitorIndex.."] in displayAllStatus() is NOT a valid monitor.")
 		return -- Invalid monitorIndex
 	end
 
 	for reactorIndex = 1, #reactorList do
 		reactor = reactorList[reactorIndex]
 		if not reactor then
 			printLog("reactor["..reactorIndex.."] in displayAllStatus() is NOT a valid Big Reactor.")
 			break -- Invalid reactorIndex
 		else
 			printLog("reactor["..reactorIndex.."] in displayAllStatus() is a valid Big Reactor.")
 		end -- if not reactor then
 
 		if reactor.getConnected() then
 			printLog("reactor["..reactorIndex.."] in displayAllStatus() is connected.")
 			if reactor.getActive() then
 				onlineReactor = onlineReactor + 1
 				totalReactorFuelConsumed = totalReactorFuelConsumed + reactor.getFuelConsumedLastTick()
 			end -- reactor.getActive() then
 
 			-- Actively cooled reactors do not produce or store energy
 			if not reactor.isActivelyCooled() then
 				totalMaxEnergyStored = totalMaxEnergyStored + 10000000 -- Reactors store 10M RF
 				totalEnergy = totalEnergy + reactor.getEnergyStored()
 				totalReactorRF = totalReactorRF + reactor.getEnergyProducedLastTick()
 			else
 				totalReactorSteam = totalReactorSteam + reactor.getEnergyProducedLastTick()
 				totalSteamStored = totalSteamStored + reactor.getHotFluidAmount()
 				totalCoolantStored = totalCoolantStored + reactor.getCoolantAmount()
 			end -- if not reactor.isActivelyCooled() then
 		else
--- Assign status, reactors, turbines and debug output to the monitors that shall display them
+
--- Depends on the [monitor,reactor,turbine]Lists being populated already
+
-local function assignMonitors()
+
 
-	local monitors = {}
+
-	monitorAssignments = {}
+
 		if not turbine then
-	printLog("Assigning monitors...")
+
 			break -- Invalid turbineIndex
-	local m = config.load(monitorOptionFileName)
+
-	if (m ~= nil) then
+
-		-- first, merge the detected and the configured monitor lists
+
-		-- this is to ensure we pick up new additions to the network
+
-		for monitorIndex, monitorName in ipairs(monitorNames) do
+
-			monitors[monitorName] = m.Monitors[monitorName] or ""
+
 			if turbine.getActive() then
-		-- then, go through all of it again to build our runtime data structure
+
-		for monitorName, assignedName in pairs(monitors) do
+
-			printLog("Looking for monitor and device named "..monitorName.." and "..assignedName)
+
-			for monitorIndex = 1, #monitorNames do
+
-				printLog("if "..monitorName.." == "..monitorNames[monitorIndex].." then", DEBUG)
+
-
+
-				if monitorName == monitorNames[monitorIndex] then
+
-					printLog("Found "..monitorName.." at index "..monitorIndex, DEBUG)
+
-					if assignedName == "Status" then
+
-						monitorAssignments[monitorName] = {type="Status", index=monitorIndex}
+
-					elseif assignedName == "Debug" then
+
-						monitorAssignments[monitorName] = {type="Debug", index=monitorIndex}
+
 
-						local maxListLen = math.max(#reactorNames, #turbineNames)
+
-						for i = 1, maxListLen do
+
-							if assignedName == reactorNames[i] then
+
-								monitorAssignments[monitorName] = {type="Reactor", index=monitorIndex, reactorName=reactorNames[i], reactorIndex=i}
+
-								break
+
-							elseif assignedName == turbineNames[i] then
+
-								monitorAssignments[monitorName] = {type="Turbine", index=monitorIndex, turbineName=turbineNames[i], turbineIndex=i}
+
-								break
+
-							elseif i == maxListLen then
+
-								printLog("assignMonitors(): Monitor "..monitorName.." was configured to display nonexistant device "..assignedName..". Setting inactive.", WARN)
+
-								monitorAssignments[monitorName] = {type="Inactive", index=monitorIndex}
+
 		-- Display liquids
 		monitor.setTextColor(colors.blue)
 		printLeft("Steam (mB)", 6, monitorIndex)
-					break
+
-				elseif monitorIndex == #monitorNames then
+
-					printLog("assignMonitors(): Monitor "..monitorName.." not found. It was configured to display device "..assignedName..". Discarding.", WARN)
+
 		monitor.setTextColor(colors.blue)
 		printRight("Coolant (mB)", 6, monitorIndex)
 		monitor.setTextColor(colors.white)
 		printRight(math.ceil(totalCoolantStored).."/"..maxCoolantStored, 7, monitorIndex)
-		printLog("No valid monitor configuration found, generating...")
+
 		monitor.setTextColor(colors.blue)
-		-- create assignments that reflect the setup before 0.3.17
+
 		monitor.setTextColor(colors.white)
-		monitorAssignments[monitorNames[1]] = {type="Status", index=1}
+
-		monitorIndex = monitorIndex + 1
+
 
-			if monitorIndex > #monitorList then
+
-				break
+	print{"Buffer: "..math.ceil(totalEnergy,3).."/"..totalMaxEnergyStored.." RF", 2, 12, monitorIndex}
 end -- function displayAllStatus()
-			monitorAssignments[monitorNames[monitorIndex]] = {type="Reactor", index=monitorIndex, reactorName=reactorNames[reactorIndex], reactorIndex=reactorIndex}
+
-			printLog(monitorNames[monitorIndex].." -> "..reactorNames[reactorIndex])
+
 -- Get turbine status
-			monitorIndex = monitorIndex + 1
+
 	printLog("Called as displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
 
-			if monitorIndex > #monitorList then
+
-				break
+
 	monitor = monitorList[monitorIndex]
-			monitorAssignments[monitorNames[monitorIndex]] = {type="Turbine", index=monitorIndex, turbineName=turbineNames[turbineIndex], turbineIndex=turbineIndex}
+
-			printLog(monitorNames[monitorIndex].." -> "..turbineNames[turbineIndex])
+
 		return -- Invalid monitorIndex
-			monitorIndex = monitorIndex + 1
+
 
-		if monitorIndex <= #monitorList then
+
-			monitorAssignments[monitorNames[#monitorList]] = {type="Debug", index=#monitorList}
+
 	turbine = turbineList[turbineIndex]
 	if not turbine then
 		printLog("turbine["..turbineIndex.."] in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is NOT a valid Big Turbine.")
-	tprint(monitorAssignments)
+
 	else
-	saveMonitorAssignments()
+
 		if turbine.getConnected() then
-end -- function assignMonitors()
+
 		else
-local eventHandler
+
--- Replacement for sleep, which passes on events instead of dropping themo
+
--- Straight from http://computercraft.info/wiki/Os.sleep
+
-local function wait(time)
+
-	local timer = os.startTimer(time)
+
 	--local variable to match the view on the monitor
-	while true do
+
-		local event = {os.pullEvent()}
+
 	-- Draw border lines
-		if (event[1] == "timer" and event[2] == timer) then
+
-			break
+
 	for i=3, 6 do
-			eventHandler(event[1], event[2], event[3], event[4])
+
 		monitor.write("|")
 	end
 
 	drawLine(2,monitorIndex)
 	drawLine(7,monitorIndex)
 
 	-- Allow controlling Turbine Flow Rate from GUI
 	-- Decrease flow rate button: 22X, 4Y
 	-- Increase flow rate button: 28X, 4Y
 	local turbineFlowRate = tonumber(_G[turbineNames[turbineIndex]]["TurbineOptions"]["LastFlow"])
 	if (xClick == 22) and (yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
 		printLog("Decrease to Flow Rate requested by "..progName.." GUI in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
 		--Decrease rod level by amount
 		newTurbineFlowRate = turbineFlowRate - flowRateAdjustAmount
 		if newTurbineFlowRate < 0 then
 			newTurbineFlowRate = 0
 		end
 		sideClick, xClick, yClick = 0, 0, 0
 
 		-- Check bounds [0,2000]
 		if newTurbineFlowRate > 2000 then
 			newTurbineFlowRate = 2000
 		elseif newTurbineFlowRate < 0 then
 			newTurbineFlowRate = 25 -- Don't go to zero, might as well power off
 		end
 
 		turbine.setFluidFlowRateMax(newTurbineFlowRate)
 		_G[turbineNames[turbineIndex]]["TurbineOptions"]["LastFlow"] = newTurbineFlowRate
 		-- Save updated Turbine Flow Rate
 		turbineFlowRate = newTurbineFlowRate
 		config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
 	elseif (xClick == 29) and (yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
 		printLog("Increase to Flow Rate requested by "..progName.." GUI in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
 		--Increase rod level by amount
 		newTurbineFlowRate = turbineFlowRate + flowRateAdjustAmount
 		if newTurbineFlowRate > 2000 then
 			newTurbineFlowRate = 2000
 		end
 		sideClick, xClick, yClick = 0, 0, 0
 
 		-- Check bounds [0,2000]
 		if newTurbineFlowRate > 2000 then
 			newTurbineFlowRate = 2000
 		elseif newTurbineFlowRate < 0 then
 			newTurbineFlowRate = 25 -- Don't go to zero, might as well power off
 		end
 
 		turbine.setFluidFlowRateMax(newTurbineFlowRate)
 
 		-- Save updated Turbine Flow Rate
 		turbineFlowRate = math.ceil(newTurbineFlowRate)
 		_G[turbineNames[turbineIndex]]["TurbineOptions"]["LastFlow"] = turbineFlowRate
 		config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
 	else
 		printLog("No change to Flow Rate requested by "..progName.." GUI in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
 	end -- if (xClick == 29) and (yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
 
 	if (xClick == 22) and (yClick == 6) and (sideClick == monitorNames[monitorIndex]) then
 		printLog("Decrease to Turbine RPM requested by "..progName.." GUI in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
 		rpmRateAdjustment = 909
 		newTurbineBaseSpeed = turbineBaseSpeed - rpmRateAdjustment
 		if newTurbineBaseSpeed < 908 then
 			newTurbineBaseSpeed = 908
 		end
 		sideClick, xClick, yClick = 0, 0, 0
 		_G[turbineNames[turbineIndex]]["TurbineOptions"]["BaseSpeed"] = newTurbineBaseSpeed
 		config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
 	elseif (xClick == 29) and (yClick == 6) and (sideClick == monitorNames[monitorIndex]) then
 		printLog("Increase to Turbine RPM requested by "..progName.." GUI in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
 		rpmRateAdjustment = 909
 		newTurbineBaseSpeed = turbineBaseSpeed + rpmRateAdjustment
 		if newTurbineBaseSpeed > 2726 then
 			newTurbineBaseSpeed = 2726
 		end
 		sideClick, xClick, yClick = 0, 0, 0
 		_G[turbineNames[turbineIndex]]["TurbineOptions"]["BaseSpeed"] = newTurbineBaseSpeed
 		config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
 	else
 		printLog("No change to Turbine RPM requested by "..progName.." GUI in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
 	end -- if (xClick == 29) and (yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
 	print{"  mB/t",22,3,monitorIndex}
 	print{"<      >",22,4,monitorIndex}
 	print{stringTrim(turbineFlowRate),24,4,monitorIndex}
 	print{"  RPM",22,5,monitorIndex}
 	print{"<      >",22,6,monitorIndex}
 	print{stringTrim(tonumber(_G[turbineNames[turbineIndex]]["TurbineOptions"]["BaseSpeed"])),24,6,monitorIndex}
 	local rotorSpeedString = "Speed: "
 	local energyBufferString = "Energy: "
 	local padding = math.max(string.len(rotorSpeedString), string.len(energyBufferString))
 
 	local energyBuffer = turbine.getEnergyProducedLastTick()
 	print{energyBufferString,1,4,monitorIndex}
 	print{math.ceil(energyBuffer).." RF/t",padding+1,4,monitorIndex}
 
 	local rotorSpeed = math.ceil(turbine.getRotorSpeed())
 	print{rotorSpeedString,1,5,monitorIndex}
 	print{rotorSpeed.." RPM",padding+1,5,monitorIndex}
 
 	-- PaintUtils only outputs to term., not monitor.
 	-- See http://www.computercraft.info/forums2/index.php?/topic/15540-paintutils-on-a-monitor/
 
 	-- Draw stored energy buffer bar
 	drawBar(1,9,28,9,colors.gray,monitorIndex)
 
 	local curStoredEnergyPercent = getTurbineStoredEnergyBufferPercent(turbine)
 	if curStoredEnergyPercent > 4 then
 		drawBar(1, 9, math.floor(26*curStoredEnergyPercent/100)+2, 9, colors.yellow,monitorIndex)
 	elseif curStoredEnergyPercent > 0 then
 		drawPixel(1, 9, colors.yellow, monitorIndex)
 	end -- if curStoredEnergyPercent > 4 then
 
 	print{"Energy Buffer",1,8,monitorIndex}
 	print{curStoredEnergyPercent, width-(string.len(curStoredEnergyPercent)+2),8,monitorIndex}
 	print{"%",28,8,monitorIndex}
 
 	-- Print rod override status
 	local turbineFlowRateOverrideStatus = ""
 
 	print{"Flow Auto-adjust:",2,10,monitorIndex}
 
 	if ((not _G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"]) or (_G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] == "false")) then
 		turbineFlowRateOverrideStatus = "Enabled"
 		monitor.setTextColor(colors.green)
 	else
 		turbineFlowRateOverrideStatus = "Disabled"
 		monitor.setTextColor(colors.red)
 	end -- if not reactorRodOverride then
 
 	print{turbineFlowRateOverrideStatus, width - string.len(turbineFlowRateOverrideStatus) - 1, 10, monitorIndex}
 	monitor.setTextColor(colors.white)
 
 	monitor.setTextColor(colors.blue)
 	printCentered(_G[turbineNames[turbineIndex]]["TurbineOptions"]["turbineName"],12,monitorIndex)
 	monitor.setTextColor(colors.white)
 
 	-- Need equation to figure out rotor efficiency and display
 end -- function displayTurbineBars(statusParams)
 
 
 -- Display turbine status
 local function turbineStatus(turbineIndex, monitorIndex)
 	-- Grab current monitor
 	local monitor = nil
 
 	printLog("Called as turbineStatus(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
-				local localControlRodAdjustAmount = _G[reactorNames[reactorIndex]]["ReactorOptions"]["controlRodAdjustAmount"]
+
 	monitor = monitorList[monitorIndex]
 	if not monitor then
 		printLog("monitor["..monitorIndex.."] in turbineStatus(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is NOT a valid monitor.")
 		return -- Invalid monitorIndex
 	end
 
 	-- Grab current turbine
-							if (rodPercentage + (10 * localControlRodAdjustAmount)) > 99 then
+
 	turbine = turbineList[turbineIndex]
 	if not turbine then
-								reactor.setAllControlRodLevels(rodPercentage + (10 * localControlRodAdjustAmount))
+
 		return -- Invalid turbineIndex
 	else
 		printLog("turbine["..turbineIndex.."] in turbineStatus(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is a valid Big Turbine.")
 	end
 
-							_G[reactorNames[reactorIndex]]["ReactorOptions"]["controlRodAdjustAmount"] = diffAmount
+
-							if (rodPercentage + diffAmount) > 99 then
+
 
 	if turbine.getConnected() then
-								reactor.setAllControlRodLevels(rodPercentage + diffAmount)
+
 		if turbine.getActive() then
 			turbineStatus = "ONLINE"
-					elseif ((lastTempPoll - reactorTemp) < (reactorTemp * 0.005)) then
+
 		else
 			turbineStatus = "OFFLINE"
 			monitor.setTextColor(colors.red)
 		end -- if turbine.getActive() then
 
 		if (xClick >= (width - string.len(turbineStatus) - 1)) and (xClick <= (width-1)) and (sideClick == monitorNames[monitorIndex]) then
 			if yClick == 1 then
 				turbine.setActive(not turbine.getActive()) -- Toggle turbine status
 				_G[turbineNames[turbineIndex]]["TurbineOptions"]["autoStart"] = turbine.getActive()
 				config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
-				elseif ((reactorTemp < localMinReactorTemp) and (rodPercentage ~=0)) or (steamRequested - steamDelivered > 0) then
+				sideClick, xClick, yClick = 0, 0, 0 -- Reset click after we register it
 			end -- if yClick == 1 then
-					if (steamRequested > (steamDelivered*2)) then
+		end -- if (xClick >= (width - string.len(turbineStatus) - 1)) and (xClick <= (width-1)) and (sideClick == monitorNames[monitorIndex]) then
-						-- Bridge to machine room: Full steam ahead!
+
-						reactor.setAllControlRodLevels(0)
+		-- Allow disabling/enabling flow rate auto-adjust
-					elseif (reactorTemp < lastTempPoll) then
+		if (xClick > 23 and xClick < 28 and yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
 			_G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] = true
 			sideClick, xClick, yClick = 0, 0, 0 -- Reset click after we register it
 		elseif (xClick > 20 and xClick < 27 and yClick == 10) and (sideClick == monitorNames[monitorIndex]) then
-							if (rodPercentage - (10 * localControlRodAdjustAmount)) < 0 then
+
 			if ((_G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"]) or (_G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] == "true")) then
 				_G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] = false
-								reactor.setAllControlRodLevels(rodPercentage - (10 * localControlRodAdjustAmount))
+
 				_G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] = true
 			end
 			sideClick, xClick, yClick = 0, 0, 0 -- Reset click after we register it
 		end
 		config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
-							_G[reactorNames[reactorIndex]]["ReactorOptions"]["controlRodAdjustAmount"] = diffAmount
+
-							if (rodPercentage - diffAmount) < 0 then
+
 		printLog("turbine["..turbineIndex.."] in turbineStatus(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is NOT connected.")
 		turbineStatus = "DISCONNECTED"
-								reactor.setAllControlRodLevels(rodPercentage - diffAmount)
+
 	end -- if turbine.getConnected() then
 
 	print{turbineStatus, width - string.len(turbineStatus) - 1, 1, monitorIndex}
 	monitor.setTextColor(colors.white)
 end -- function function turbineStatus(turbineIndex, monitorIndex)
 
 
 -- Maintain Turbine flow rate at 900 or 1,800 RPM
 local function flowRateControl(turbineIndex)
 	if ((not _G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"]) or (_G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] == "false")) then
 
 		printLog("Called as flowRateControl(turbineIndex="..turbineIndex..").")
 
 		-- Grab current turbine
 		local turbine = nil
-				if ((reactorTemp > localMinReactorTemp) and (reactorTemp < localMaxReactorTemp)) and not (steamRequested - steamDelivered > 0) then
+
 
 		-- assign for the duration of this run
 		local lastTurbineSpeed = tonumber(_G[turbineNames[turbineIndex]]["TurbineOptions"]["LastSpeed"])
 		local turbineBaseSpeed = tonumber(_G[turbineNames[turbineIndex]]["TurbineOptions"]["BaseSpeed"])
 
 		if not turbine then
 			printLog("turbine["..turbineIndex.."] in flowRateControl(turbineIndex="..turbineIndex..") is NOT a valid Big Turbine.")
 			return -- Invalid turbineIndex
 		else
 			printLog("turbine["..turbineIndex.."] in flowRateControl(turbineIndex="..turbineIndex..") is a valid Big Turbine.")
 
 			if turbine.getConnected() then
 				printLog("turbine["..turbineIndex.."] in flowRateControl(turbineIndex="..turbineIndex..") is connected.")
 			else
 				printLog("turbine["..turbineIndex.."] in flowRateControl(turbineIndex="..turbineIndex..") is NOT connected.")
 			end -- if turbine.getConnected() then
 		end -- if not turbine then
 
 		-- No point modifying control rod levels for temperature if the turbine is offline
 		if turbine.getActive() then
 			printLog("turbine["..turbineIndex.."] in flowRateControl(turbineIndex="..turbineIndex..") is active.")
 
 			local flowRate = tonumber(_G[turbineNames[turbineIndex]]["TurbineOptions"]["LastFlow"])
 			local flowRateUserMax = math.ceil(turbine.getFluidFlowRateMax())
 			local rotorSpeed = math.ceil(turbine.getRotorSpeed())
 			local newFlowRate = 0
 
 			-- Going to control the turbine based on target RPM since changing the target flow rate bypasses this function
 			if (rotorSpeed < turbineBaseSpeed) then
 				printLog("BELOW COMMANDED SPEED")
 				if (rotorSpeed > lastTurbineSpeed) then
 					--we're still increasing, let's let it level off
 					--also lets the first control pass go by on startup
 				elseif (rotorSpeed < lastTurbineSpeed) then
 					--we're decreasing where we should be increasing, do something
 					if ((lastTurbineSpeed - rotorSpeed) > 100) then
 						--kick it harder
 						newFlowRate = 2000
 						printLog("HARD KICK")
 					else
 						--let's adjust based on proximity
 						flowAdjustment = (turbineBaseSpeed - rotorSpeed)/5
 						newFlowRate = flowRate + flowAdjustment
 						printLog("Light Kick: new flow rate is "..newFlowRate.." mB/t and flowAdjustment was "..flowAdjustment.." EOL")
 					end
 				else
 					--we've stagnated, kick it.
 					flowAdjustment = (turbineBaseSpeed - lastTurbineSpeed)
 					newFlowRate = flowRate + flowAdjustment
 					printLog("Stagnated: new flow rate is "..newFlowRate.." mB/t and flowAdjustment was "..flowAdjustment.." EOL")
 				end --if (rotorSpeed > lastTurbineSpeed) then
 			else
 				--we're above commanded turbine speed
 				printLog("ABOVE COMMANDED SPEED")
 				if (rotorSpeed < lastTurbineSpeed) then
 				--we're decreasing, let it level off
 				--also bypasses first control pass on startup
 				elseif (rotorSpeed > lastTurbineSpeed) then
 					--we're above and ascending.
 					if ((rotorSpeed - lastTurbineSpeed) > 100) then
 						--halt
 						newFlowRate = 25
 					else
 						--let's adjust based on proximity
 						flowAdjustment = (rotorSpeed - turbineBaseSpeed)/5
 						newFlowRate = flowRate - flowAdjustment
 						printLog("Light Kick: new flow rate is "..newFlowRate.." mB/t and flowAdjustment was "..flowAdjustment.." EOL")
 					end
 				else
 					--we've stagnated, kick it.
 					flowAdjustment = (lastTurbineSpeed - turbineBaseSpeed)
 					newFlowRate = flowRate - flowAdjustment
 					printLog("Stagnated: new flow rate is "..newFlowRate.." mB/t and flowAdjustment was "..flowAdjustment.." EOL")
 				end --if (rotorSpeed < lastTurbineSpeed) then
 			end --if (rotorSpeed < turbineBaseSpeed)
 
 			--check to make sure an adjustment was made
 			if (newFlowRate == 0) then
 				--do nothing, we didn't ask for anything this pass
 			else
 				--boundary check
 				if newFlowRate > 2000 then
 					newFlowRate = 2000
 				elseif newFlowRate < 25 then
 					newFlowRate = 25 -- Don't go to zero, might as well power off
 				end -- if newFlowRate > 2000 then
 				--no sense running an adjustment if it's not necessary
 				if ((newFlowRate < flowRate) or (newFlowRate > flowRate)) then
 					printLog("turbine["..turbineIndex.."] in flowRateControl(turbineIndex="..turbineIndex..") is being commanded to "..newFlowRate.." mB/t flow")
 					newFlowRate = round(newFlowRate, 0)
 					turbine.setFluidFlowRateMax(newFlowRate)
 					_G[turbineNames[turbineIndex]]["TurbineOptions"]["LastFlow"] = newFlowRate
 					config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
 				end
 			end
 			--always set this
 			_G[turbineNames[turbineIndex]]["TurbineOptions"]["LastSpeed"] = rotorSpeed
 			config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
 		else
 			printLog("turbine["..turbineIndex.."] in flowRateControl(turbineIndex="..turbineIndex..") is NOT active.")
 		end -- if turbine.getActive() then
 	else
 		printLog("turbine["..turbineIndex.."] has flow override set to "..tostring(_G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"])..", bypassing flow control.")
 	end -- if not _G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] then
 end -- function flowRateControl(turbineIndex)
 
 
-	monitor.setCursorPos(1, height)
+
-	monitor.write("< ")
+
-	monitor.setCursorPos(width-1, height)
+
-	monitor.write(" >")
+
 	-- Get our initial list of connected monitors and reactors
 	-- and initialize every cycle in case the connected devices change
 	findMonitors()
 	findReactors()
 	findTurbines()
 
 	while not finished do
 		local reactor = nil
 		local monitorIndex = 1
 
 		-- For multiple reactors/monitors, monitor #1 is reserved for overall status
 		-- or for multiple reactors/turbines and only one monitor
 		if ( ( ((#reactorList + #turbineList) > 1) and (#monitorList >= 1) )   or
 		     ( ((#reactorList + #turbineList) >=1) and (#monitorList >  1) ) ) then
 			local monitor = nil
 			monitor = monitorList[monitorIndex]
 			if not monitor then
 				printLog("monitor["..monitorIndex.."] in main() is NOT a valid monitor.")
 				return -- Invalid monitorIndex
 			end
 
 			clearMonitor(progName.." "..progVer, monitorIndex) -- Clear monitor and draw borders
 			printCentered(progName.." "..progVer, 1, monitorIndex)
 			displayAllStatus()
 			monitorIndex = 2 -- Next monitor, #1 is reserved for overall status
 		end
 
 		-- Iterate through reactors, continue to run even if not enough monitors are connected
 		for reactorIndex = 1, #reactorList do
 			local monitor = nil
 			local reactorMonitorIndex = monitorIndex + reactorIndex - 1 -- reactorIndex starts at 1
 
 			printLog("Attempting to display reactor["..reactorIndex.."] on monitor["..reactorMonitorIndex.."]...")
 
 			reactor = reactorList[reactorIndex]
 			if not reactor then
 				printLog("reactor["..reactorIndex.."] in main() is NOT a valid Big Reactor.")
 				break -- Invalid reactorIndex
 			else
 				printLog("reactor["..reactorIndex.."] in main() is a valid Big Reactor.")
 			end --  if not reactor then
 
 			-- Only attempt to assign a monitor if we have a monitor for this reactor
 			if (reactorMonitorIndex <= #monitorList) then
 				printLog("Displaying reactor["..reactorIndex.."] on monitor["..reactorMonitorIndex.."].")
 				monitor = monitorList[reactorMonitorIndex]
 
 				if not monitor then
 					printLog("monitor["..reactorMonitorIndex.."] in main() is NOT a valid monitor.")
 				else
 					clearMonitor(progName, reactorMonitorIndex) -- Clear monitor and draw borders
 					printCentered(progName, 1, reactorMonitorIndex)
 
 					-- Display reactor status, includes "Disconnected" but found reactors
 					reactorStatus{reactorIndex, reactorMonitorIndex}
 
 					-- Draw the borders and bars for the current reactor on the current monitor
 					displayReactorBars{reactorIndex, reactorMonitorIndex}
 				end -- if not monitor
 			else
 				printLog("You may want "..(#reactorList + #turbineList + 1).." monitors for your "..#reactorList.." connected reactors and "..#turbineList.." connected turbines.")
 			end -- if (#monitorList ~= 1) and (reactorMonitorIndex < #monitorList) then
 
 			if reactor.getConnected() then
 				printLog("reactor["..reactorIndex.."] is connected.")
 				local curStoredEnergyPercent = getReactorStoredEnergyBufferPercent(reactor)
 
 				-- Shutdown reactor if current stored energy % is >= desired level, otherwise activate
 				-- First pass will have curStoredEnergyPercent=0 until displayBars() is run once
 				if curStoredEnergyPercent >= maxStoredEnergyPercent then
 					reactor.setActive(false)
 				-- Do not auto-start the reactor if it was manually powered off (autoStart=false)
 				elseif (curStoredEnergyPercent <= minStoredEnergyPercent) and (_G[reactorNames[reactorIndex]]["ReactorOptions"]["autoStart"] == true) then
 					reactor.setActive(true)
 				end -- if curStoredEnergyPercent >= maxStoredEnergyPercent then
 
 				-- Don't try to auto-adjust control rods if manual control is requested
 				if not _G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"] then
 					temperatureControl(reactorIndex)
 				end -- if not reactorRodOverride then
 			else
 				printLog("reactor["..reactorIndex.."] is NOT connected.")
 			end -- if reactor.getConnected() then
 		end -- for reactorIndex = 1, #reactorList do
 
 		-- Monitors for turbines start after turbineMonitorOffset
 		for turbineIndex = 1, #turbineList do
 			local monitor = nil
 			local turbineMonitorIndex = turbineIndex + turbineMonitorOffset
 
 			printLog("Attempting to display turbine["..turbineIndex.."] on monitor["..turbineMonitorIndex.."]...")
-	-- monitor switch controls
+
-	monitor.setCursorPos(1, height)
+			-- Only attempt to assign a monitor if we found a monitor for this turbine
-	monitor.write("<")
+			if (turbineMonitorIndex <= #monitorList) then
-	monitor.setCursorPos(width, height)
+				printLog("Displaying turbine["..turbineIndex.."] on monitor["..turbineMonitorIndex.."].")
-	monitor.write(">")
+				monitor = monitorList[turbineMonitorIndex]
 				if not monitor then
 					printLog("monitor["..turbineMonitorIndex.."] in main() is NOT a valid monitor.")
 				else
 					clearMonitor(progName, turbineMonitorIndex) -- Clear monitor and draw borders
 					printCentered(progName, 1, turbineMonitorIndex)
 
 					-- Display turbine status, includes "Disconnected" but found turbines
 					turbineStatus(turbineIndex, turbineMonitorIndex)
 
 					-- Draw the borders and bars for the current turbine on the current monitor
 					displayTurbineBars(turbineIndex, turbineMonitorIndex)
 				end -- if not monitor
 			else
 				printLog("You may want "..(#reactorList + #turbineList + 1).." monitors for your "..#reactorList.." connected reactors and "..#turbineList.." connected turbines.")
 			end -- if (#monitorList ~= 1) and (turbineMonitorIndex < #monitorList) then
 
 			turbine = turbineList[turbineIndex]
 			if not turbine then
 				printLog("turbine["..turbineIndex.."] in main() is NOT a valid Big Turbine.")
 				break -- Invalid turbineIndex
 			else
 				printLog("turbine["..turbineIndex.."] in main() is a valid Big Turbine.")
 			end -- if not turbine then
 
 			if turbine.getConnected() then
 				printLog("turbine["..turbineIndex.."] is connected.")
 
 				if not _G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] then
 					flowRateControl(turbineIndex)
 				end -- if not turbineFlowRateOverride[turbineIndex] then
 			else
 				printLog("turbine["..turbineIndex.."] is NOT connected.")
 			end -- if turbine.getConnected() then
 		end -- for reactorIndex = 1, #reactorList do
 
 		sleep(loopTime) -- Sleep
 		saveReactorOptions()
 	end -- while not finished do
 end -- main()
 
 
 local function eventHandler()
 	while not finished do
 		-- http://computercraft.info/wiki/Os.pullEvent
 		-- http://www.computercraft.info/forums2/index.php?/topic/1516-ospullevent-what-is-it-and-how-is-it-useful/
 		event, arg1, arg2, arg3 = os.pullEvent()
 
 		if event == "monitor_touch" then
 			sideClick, xClick, yClick = arg1, math.floor(arg2), math.floor(arg3)
 			printLog("Side: "..arg1.." Monitor touch X: "..xClick.." Y: "..yClick)
 		elseif event == "char" and not inManualMode then
 			local ch = string.lower(arg1)
 			if ch == "q" then
 				finished = true
 			elseif ch == "r" then
-	_G[reactorNames[reactorIndex]]["ReactorOptions"]["Status"] = reactorStatus
+
 				os.reboot()
 			end -- if ch == "q" then
 		end -- if event == "monitor_touch" then
 	end -- while not finished do
 end -- function eventHandler()
 
--- Display all found reactors' status to selected monitor
+
 while not finished do
-local function displayAllStatus(monitorIndex)
+	parallel.waitForAny(eventHandler, main)
 	sleep(loopTime)
 end -- while not finished do
 
 
 -- Clear up after an exit
 term.clear()
 term.setCursorPos(1,1)