View difference between Paste ID: we4y9Lz8 and JxLqMr2g

 --
 -- Control passive cooled Big Reactor (http://big-reactors.com/).
 --
 -- Author: kla_sch
 -- post: http://www.computercraft.info/forums2/index.php?/topic/18515-control-passive-cooled-big-reactors/
 --
 -- History:
 --	  v0.1, 2014-05-05:
 --			first version
 --
 -- Remarks:
 --	  Reactor API: http://big-reactors.com/cc_api.html
 --
 
 -- -------------------------------
 -- Constant values (configuration)
 --
 -- Critical energy mark: give us the maximum power.
 critEnergy=3000000
 -- Low energy mark: turn reactor on to get more energy
 lowEnergy=7000000
 -- Heigh energy mark: we have enough, so turn the reactor off.
 highEnergy=9000000
 -- Refresh delay (seconds)
 delay=5
 -- Peripheriques
 pList = peripheral.getNames()
 
 
 --
 -- Calculate the control rod level (in %) by stored energy of internal
 -- recator cell.
 --
 -- * If cellEnergy <= critEnergy, the calculation results in maximum
 --	energy generation (control rod level = 0%).
 -- * If cellEnergy >= highEnergy, the calculation results in 10% energy
 --	generation (control rod level = 90%).
 --
 -- Parameters:
 --	  cellEnergy - stored energy of internal cell in RF
 --
 -- Return:
 --	  New control rod level in %.
 --
 function calcRodLevel(cellEnergy)
 	-- Delta between critical and heigh energy mark
 	local deltaEnergy = highEnergy - critEnergy
 
 	-- Calculated maximum delta energy (not the real maximum), so that
 	-- the high energy mark results into a control rod level of 90%
 	local deltaEnergy100 = deltaEnergy * 100 / 90
 
 	-- Energy for calculation: value between 0 and 'deltaEnergy'
 	local calcEnergy = cellEnergy - critEnergy
 
 	if calcEnergy < 0 then
 		calcEnergy = 0
 	elseif calcEnergy > deltaEnergy then
 		calcEnergy = deltaEnergy
 	end
 
 	-- Calculate control rod level and round the result (math.floor + 0.5)
 	return math.floor(calcEnergy * 100 / deltaEnergy100 + 0.5)
 end
 
 
 --
 -- Write text with colors, if possible (advance monitor)
 --
 -- Parameters:
 --	  mon	- handle of monitor
 --	  color - text color
 --	  text  - text to write
 --
 function writeColor(mon, color, text, bgcolor)
  bgcolor = bgcolor == nil and colors.black or bgcolor
 	if (mon.isColor()) then
 		mon.setTextColor(color)
 		mon.setBackgroundColor(bgcolor)
 	end
 	mon.write(text)
 	if (mon.isColor()) then
 		mon.setTextColor(colors.white)
 		mon.setBackgroundColor(colors.black)
 	end
 end
 function resetColor(mon)
 	mon.setTextColor(1)
 	mon.setBackgroundColor(colors.black)
 end
 function clearSquare(mon, x, y, w, h)
 	resetColor(mon)
 	for _h=1,h do
 		mon.setCursorPos(x,y+_h-1)
 		mon.write(string.rep(" ",w))
 	end
 end
 
 --
-	mon.clear()
+
 --
 -- Parameters:
 --	  mon		  - handle of monitor.
 --	  state		- state of reactor (on/off)
 --	  rodLvl	  - Level of control rods in %
 --	  cellEnergy - stored energy of internal cell (in RF)
 --
 function displayStatusToMonitor(mon, state, rodLvl, cellEnergy)
 	clearSquare(mon, 1, 3, 15, 3)
 
 	-- First get the monitor size and try to scale, if the feature ist
 	-- available.
 	if mon.setTextScale ~= nil then
 		-- reset text scale
 		mon.setTextScale(1)
 	end
 
 	local width, height = mon.getSize()
 	if width < 15 or height < 5 then
 		-- too small: try to scale down.
 		if mon.setTextScale ~= nil then
 			mon.setTextScale(0.5)
 		else
 			return -- too small und no text scale available
 		end
 
 		width, height = mon.getSize()
 		if width < 15 or height < 5 then
 			return -- still too small
 		end
 	else
 		-- Huge monitors? Try to scale up, if possible (max scale=5).
 		local scale = math.min(width / 16, height / 5, 5)
 		scale = math.floor(scale * 2) / 2 -- multiple of 0.5
 
 		if scale > 1 and mon.setTextScale ~= nil then
 			mon.setTextScale(scale)
 			width, height = mon.getSize()
 		end
 	end
 
 
 	--
 	-- Output the data
 	--
 	mon.setCursorPos(1,1)
 	mon.write("Reactor")
 
 	mon.setCursorPos(1,3)
 	mon.write("Status ")
 
 	if state then
 		writeColor(mon, colors.green, "ON")
 	else
 		writeColor(mon, colors.red, "OFF")
 	end
 
 	mon.setCursorPos(1,4)
 	mon.write("Rod Level: " .. rodLvl .. "%")
 
 	mon.setCursorPos(1,5)
 	if width < 16 then
 		mon.write("Cell: ") -- One block monitor (15x5 with scale 0.5)
 	else
 		mon.write("Energy: ")
 	end
 
 	local c
 	if cellEnergy < critEnergy then
 		c = colors.red -- Red: We use too much energy
 	elseif cellEnergy > lowEnergy then
 		c = colors.green -- Green: More energy then low water mark
 	else
 		c = colors.orange -- Orange: Less energy the low water mark, but OK
 	end
 	writeColor(mon, c, string.format("%d", math.floor(cellEnergy/1000 + 0.5)))
 	mon.write(" kRF")
 end
 
 
 --
 -- Display reactor status to any connected monitor and also to console.
 --
 -- Parameters:
 --	  state		- state of reactor (on/off)
-	local pList = peripheral.getNames()
+
 --	  cellEnergy - stored energy of internal energy cell in RF
 --
 function displayStatus(state, rodLvl, cellEnergy)
 	displayStatusToMonitor(term, state, rodLvl, cellEnergy) -- console
 	term.setCursorPos(1,17)
 	writeColor(term, colors.lightGray, "* Hold Crtl-T to terminate program")
 	term.setCursorPos(1,8)
 
 	local i, name
 	for i, name in pairs(pList) do
 		if peripheral.getType(name) == "monitor" then
 			-- found monitor as peripheral
 			displayStatusToMonitor(peripheral.wrap(name), state, rodLvl, cellEnergy)
 		end
 	end
 end
 
 
 --
-	local pList = peripheral.getNames()
+
 --
 -- If no reactor was found this function terminate the program.
 --
 -- Return:
 --	  Handle of first connected reactor found.
 --
 function getReactorHandle()
 	local i, name
 	for i, name in pairs(pList) do
 		if peripheral.getType(name) == "BigReactors-Reactor" then
 			return peripheral.wrap(name)
 		end
 	end
 
 	error("No big reactor connected: Exit program")
 	exit()
 end
 
 function main()
 	reactor = getReactorHandle()
 
 	--
 	-- Endless loop: Recalculate rod level, set rod level, display result
 	-- and wait for 5 secounds.
 	--
 	while true do
 		cellEnergy = reactor.getEnergyStored()
 		if cellEnergy < lowEnergy then
 			-- Low energy: switch reactor ON and calculate control rods by
 			-- energy cell level.
 			reactor.setActive(true)
 			rodLvl=calcRodLevel(cellEnergy)
 		elseif cellEnergy > highEnergy then
 			-- High energy: switch reactor OFF and set control rod level to 100
 			reactor.setActive(false)
 			rodLvl=100
 		elseif cellEnergy > lowEnergy then
 			-- Enough energy: do not change state of reactor. Only recalculate
 			-- control rod level.
 			--
 			-- * If the reactor ist switched off, we will wait until energy
 			--	fall below low energy mark.
 			--
 			-- * If it is turned on, we generate more energy until the
 			--	energy level exeeds the high energy mark.
 			rodLvl=calcRodLevel(cellEnergy)
 		end
 
 		reactor.setAllControlRodLevels(rodLvl)
 
 		displayStatus(reactor.getActive(), rodLvl, cellEnergy)
 
 		os.sleep(delay) -- Wait for 5s
 	end
 end
 
 function tickToMonitor(mon,frame)
 	local len = string.len(delay.."/"..delay)
 	local cx,cy = mon.getCursorPos()
 	mon.setCursorPos(16-len,1)
 	mon.write(string.rep(" ",len))
 	mon.setCursorPos(16-string.len(frame.."/"..delay),1)
 	writeColor(mon, colors.lightGray, frame.."/"..delay)
 	mon.setCursorPos(cx,cy)
-		local pList = peripheral.getNames()
+
 
 function tick()
 	local t=0
 	while true do
 		local f=t%delay+1
 		tickToMonitor(term,f)
 		local i, name
 		for i, name in pairs(pList) do
 			if peripheral.getType(name) == "monitor" then
 				-- found monitor as peripheral
 				tickToMonitor(peripheral.wrap(name),f)
 			end
 		end
 		sleep(1)
 		t=t+1
 	end
 end
 
 function shortcutToMonitor(mon)
 	local cx,cy = mon.getCursorPos()
 	mon.setCursorPos(13,2)
 	writeColor(mon, colors.black, "T", colors.orange)
 	writeColor(mon, colors.black, "R", colors.blue)
 	writeColor(mon, colors.black, "S", colors.red)
 	resetColor(mon)
-		local pList = peripheral.getNames()
+
 end
 
 function shortcut()
 	while true do
 		shortcutToMonitor(term)
 		local i, name
 		for i, name in pairs(pList) do
 			if peripheral.getType(name) == "monitor" then
 				-- found monitor as peripheral
 				shortcutToMonitor(peripheral.wrap(name))
 			end
 		end
 		event, side, xPos, yPos = os.pullEvent()
 		if ((event == "mouse_click" and side == 1) or event == "monitor_touch")
 			and yPos == 2 then
 			if xPos == 13 then --T
 				return
 			elseif xPos == 14 then --R
 				os.reboot()
 			elseif xPos == 15 then --S
 				os.shutdown()
 			end
-r = parallel.waitForAny(main, shortcut, tick)
+
-if r == 2 then
+
 	end
-	local pList = peripheral.getNames()
+
 
 term.clear()
 for i, name in pairs(pList) do
 	if peripheral.getType(name) == "monitor" then
-   mon = peripheral.wrap(name)
+		-- found monitor as peripheral
-   mon.setCursorPos(1,6)
+		mon = peripheral.wrap(name)
 		mon.clear()
 	end
 end
 r = parallel.waitForAny(shortcut, tick, main)
 if r == 1 then
 	writeColor(term, colors.red, "Terminated", colors.black)
 	local i, name
 	for i, name in pairs(pList) do
 		if peripheral.getType(name) == "monitor" then
 			-- found monitor as peripheral
 			mon = peripheral.wrap(name)
 			mon.setCursorPos(1,6)
 			writeColor(mon, colors.red, "Terminated", colors.black)
 		end
 	end
 	print("")
 end
 --
 -- EOF
 --