View difference between Paste ID: C228rXm4 and 8Arm47SX

 --
--- Control passive cooled Big Reactor (http://big-reactors.com/).
+-- Control passively cooled Big Reactor (http://big-reactors.com/).
 --
--- Author: kla_sch
+-- Author: VirtualDXS
 -- Based heavily on original by kla_sch
 --
 -- History:
---         first version
+
 --         first version by kla_sch
 --     v0.2, 2015-10-24:
---     Reactor API: http://big-reactors.com/cc_api.html
+--         Minor adjustments
 --     v0.3, 2020-01-26
 --         Transmit telemetry if wireless modem present, allowing
 --         for things like remote displays
 --
 -- Remarks:
 --     Reactor API: http://big-reactors.com/#/api.computer
 --
 sleep(5) --Let the entire chunk load, just in case
 --
 -- Constant values (configuration)
 --
 
--- Heigh energy mark: we have enough, so turn the reactor off.
+-- Port to transmit telemetry on (requires wireless modem)
 transmitPort=39124
 
 -- Critical energy mark: give us the maximum power.
 critEnergy=3000000
 
--- recator cell.
+
 lowEnergy=7000000
 
 -- High energy mark: we have enough, so turn the reactor off.
 highEnergy=9000000
 
 
 --
 -- Calculate the control rod level (in %) by stored energy of internal
 -- reactor cell.
 --
 -- * If cellEnergy <= critEnergy, the calculation results in maximum
 --   energy generation (control rod level = 0%).
 -- * If cellEnergy >= highEnergy, the calculation results in 10% energy
-   -- Delta between critical and heigh energy mark
+
-   local deltaEnergy = highEnergy - critEnergy
+
 -- Parameters:
 --     cellEnergy - stored energy of internal cell in RF
 --
 -- Return:
 --     New control rod level in %.
 --
 function calcRodLevel(cellEnergy)
    -- Delta between critical and high 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)
    if (mon.isColor()) then
       mon.setTextColor(color)
    end
    mon.write(text)
    if (mon.isColor()) then
       mon.setTextColor(colors.white)
---     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)
+
 -- Display reactor status to a monitor.
 --
 -- Parameters:
 --     mon        - handle of monitor.
 --     state      - state of reactor (dictionary, see main loop for structure)
 --
 function displayStatusToMonitor(mon, state)
    mon.clear()
 
    -- 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
-         return -- too small und no text scale available
+
    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 and no text scale available
       end
 
-      scale = math.floor(scale * 2) / 2 -- multiple of 0.5
+
       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
 
 
    --
-   mon.write("Status ")
+
    --
-   if state then
+
-      writeColor(mon, colors.green, "ON")
+
    mon.write("Reactor")
-      writeColor(mon, colors.red, "OFF")
+
    mon.setCursorPos(1,3)
    mon.write("Status: ")
 
-   mon.write("Rod Level: " .. rodLvl .. "%")
+   if state.power then
       writeColor(mon, colors.green, "ACTIVE")
    else
       writeColor(mon, colors.red, "INACTIVE")
    end
 
-      mon.write("Energy: ")
+
    mon.write("Rod Level: " .. state.rodLevel .. "%")
 
    mon.setCursorPos(1,5)
-   if cellEnergy < critEnergy then
+
       mon.write("Cell: ") -- One block monitor (15x5 with scale 0.5)
    else
       mon.write("Energy Buffer: ")
    end
 
    local c
-   writeColor(mon, c, string.format("%d", math.floor(cellEnergy/1000 + 0.5)))
+   if state.cellEnergy < critEnergy then
       c = colors.red -- Red: We use too much energy
    elseif state.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(state.cellEnergy/1000 + 0.5)))
    mon.write(" kRF")
---     state      - state of reactor (on/off)
+
---     rodLvl     - Level of control rods in %
+
---     cellEnergy - stored energy of internal energy cell in RF
+
 --
-function displayStatus(state, rodLvl, cellEnergy)
+
-   displayStatusToMonitor(term, state, rodLvl, cellEnergy) -- console
+
 -- Parameters:
-   term.write("* Hold Crtl-T to terminate program")
+--     state      - state of reactor (dictionary, see main loop for structure)
 --
 function displayStatus(state)
    displayStatusToMonitor(term, state) -- console
    term.setCursorPos(1,7)
    term.write("* Hold Ctrl-T to terminate program")
    term.setCursorPos(1,8)
 
-         displayStatusToMonitor(peripheral.wrap(name),
+
-                                state, rodLvl, cellEnergy)
+
    for i, name in pairs(pList) do
       if peripheral.getType(name) == "monitor" then
          -- found monitor as peripheral
          displayStatusToMonitor(peripheral.wrap(name), state)
       end
    end
 end
 
 
 --
 -- Transmit reactor state to allow for things like wireless displays
 --
 -- Parameters:
 --     state      - state of reactor (dictionary, see main loop for structure)
 --
 function transmitStatus(state)
    local pList = peripheral.getNames()
    local i, name
    for i, name in pairs(pList) do
       if peripheral.getType(name) == "modem" then
          -- found modem as peripheral; check if wireless
          local modem = peripheral.wrap(name)
          if modem.isWireless() then
             modem.transmit(transmitPort,transmitPort,textutils.serialize(state))
          end
       end
    end
 end
 
 
 --
 -- Find the first connected big reactor and return the wraped handle.
 --
 -- If no reactor was found this function terminate the program.
 --
 -- Return:
 --     Handle of first connected reactor found.
 --
 function getReactorHandle()
-      rodLvl=calcRodLevel(cellEnergy)
+
    local i, name
    for i, name in pairs(pList) do
       if peripheral.getType(name) == "BigReactors-Reactor" then
-      rodLvl=100
+
       end
    end
 
    error("No big reactor connected: Exit program")
    exit()
 end
 
 
 reactor = getReactorHandle()
-      rodLvl=calcRodLevel(cellEnergy)
+
 --
 -- Endless loop: Recalculate rod level, set rod level, display result
-   reactor.setAllControlRodLevels(rodLvl)
+
 --
-   displayStatus(reactor.getActive(), rodLvl, cellEnergy)
+
    cellEnergy = reactor.getEnergyStored()
-   os.sleep(5) -- Wait for 5s
+
       -- Low energy: switch reactor ON and calculate control rods by
       -- energy cell level.
       reactor.setActive(true)
--- EOF
+      rodLevel=calcRodLevel(cellEnergy)
---
+
       -- High energy: switch reactor OFF and set control rod level to 100
       reactor.setActive(false)
       rodLevel=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.
       rodLevel=calcRodLevel(cellEnergy)
    end
 
    reactor.setAllControlRodLevels(rodLevel)
 
    state = {
       power = reactor.getActive(),
       rodLevel = rodLevel,
       cellEnergy = cellEnergy
    }
 
    displayStatus(state)
    transmitStatus(state)
 
    os.sleep(0.5)
 end