Loading nuclear reactors

[Distelzombie]

I found that you can use a very simple setup: A inserter (with stack override to one) comming from an assembler with wires to tanks. Inserter rule is: If water = 0 insert.
This will insert only one fuel if necessary. The reactor will always stay at 500°C and there are only seconds in between where its not producing power. Very simply = simple results.

[Distelzombie]

For people who want early game setups:

One Reactor

0eNqdWO2OqjAQfZf+pje0FBWT+yQ3G1NxFpuFYkrZrNfw7reVlevHoO3+0YCdM+fMHDrFE9nWPRyM0pasT0SVre7I+s+JdKrSsvb37PEAZE2UhYYkRMvGX+m+rEEaakCWtjVkSIjSO/giaza8JQS0VVbBCHW+OG5032zBuAWzIAk5tJ2La7XP67CoW3v0X/kwJA9AfAKSXQfNtla6oo0s90oD5Y9oYgJLiIFSnWX1RmrVN/S9h5qWUNcEyZRNmRrY+dVQQ2mNKumhreExE//OtHCZXEW1W6zOhT0R5j8qA6Cva6N2jt5VYn/NXSUHTLeY2LzLzlKlOzAWzDwNL3inzMjifNuRsqatN1vYy0/lSu8CSmXKXtmN+203obwr09nNgxk+lbG9uzMxGVdQ+ARztK4BFRmld1Z6Z6X+ojlII32f1+Q3GWJKk/lKJKR16EbtYONQyw/H6i94vz1WKJ94HVyXqW1pZdpe7xCHXWrEb2skENTFhLoHaamHfmJZjrVuGUwsDee1ugFFKF2Mn2KUiltV8FXupa4wO1H+K5+QblgtEFyWRpUL5cZYFAZDMXiwwHROH8dwsxdl50+VicgthX5TK1C0PNACKzR6ERiN517+wEDLAP+sYnqPCytiIFB1PI13z/K1eTiLbH92kRm1a94OlGxuoHAeZmW0yDzwOcDLKwKtt0CjQ22/RKOj9nMcYhmmHWe/CgvGM/+3dudGqqzcMJH6A+H/7Zzsbo7E+GjON1kaWH/0+JaxQAkMVcAjFPDi8Wx192zkcxoDnw1cYuzB8eI29PCQibie3w/pmJbPliOPalo6xPnsrilijsXiigXIhtrebN2pf9aBAkVZhqLwJyCrn7UYBysidaGbqkjjdOEgLJIKQxUJ/rPy4Gc5kQWTYs9IibgCzaC8nD7jY8jQDVwEHrpmol8Nnot+PPrlGwN/Fl28iE6fBOevRsYz3jkL2ot98Fsy/mGxvvp/IyHu/bEb90IheJ4WBV+41v4DtyeZCg==

I found that you can use a very simple setup: A inserter (with stack override to one) comming from an assembler with wires to tanks. Inserter rule is: If water = 0 insert.
This will insert only one fuel if necessary. The reactor will always stay at 500°C and there are only seconds in between where its not producing power. Very simply = simple results.

[Killcreek2]

Here is the setup I'm using: One core is powered constantly [only 1 fuel cell at a time], the second core is only powered up if the 500 degree steam tanks drop below threshold level, for better fuel efficiency.

Doesn't that make the fuel efficiency *worse*, not better? When you're just running one reactor, you are consuming half as much fuel, but only generating 25% as much steam. It's most fuel efficient to always load all of the reactors with fuel at the exact same time, because of the adjacency bonus, and let them all turn off together as well when you have plenty of steam.

Derp, you are correct, I forgot the neighbour bonus when working it out. Nice catch, thanks.

[Gus_Smedstad]

@OP There is a simple 1-combinator [per reactor core] solution to only load 1 fuel at a time: the Memory cell.

Took me a while to work through exactly what was going on, but that's helpful. I created a solution last night, but I wasn't happy with the results because it required about 8 combinators, and it was still kind of finicky. I had RS latches for "reactor inserter running" and "reactor running," plus a bunch of tests to make sure that the load-the-chest inserter did not run at the same time as the load-the-reactor inserter.

I think the key thing I was missing was the idea of reading the contents of the inserter loading the reactor. You couldn't do that in version 0.12, and I'm still not up to speed on all the combinator improvements since then. I was doing it in a much clumsier fashion, by checking if the chest went from full -> empty.

It's also helpful to use a latch that uses (set signal > reset signal) instead of (signal > 0).

As for hooking the reactor to the larger grid - that part was easy. I'm using a power switch, and a RS latch that turns it on when the accumulator charge < 25 and off when it's > 80. I started with a simple test (no combinator needed), but while that works fine with steam engines it's not so great with turbines, which have a spin-up time.

If the reactor power output is much larger than the main grid demand, which it usually is with nuclear power setups, the result is that the turbines rapidly charge the main grid's accumulators and then disconnect.

One thing I belatedly realized is that nuclear power is not very sustainable until you get a Korvax enricher running. Regardless of how much ore you're mining, each centrifuge produces only 1 U235 per 1428 seconds, versus a burn time of 200 seconds per cell. A Korvax enricher centrifuge produces 1 U235 per 50 seconds, so one enricher can keep 4 reactors running continuously. Centrifuges are quite expensive at 100 Advanced Circuits each, so you can't just spam them like furnaces or even oil refineries.

[Distelzombie]

For people who want early game setups:
I found that you can use a very simple setup: A inserter (with stack override to one) comming from an assembler with wires to tanks. Inserter rule is: If water = 0 insert.
This will insert only one fuel if necessary. The reactor will always stay at 500°C and there are only seconds in between where its not producing power. Very simply = simple results.

I realized you can simply add accumulators to overcome the one or two seconds of downtime. I think its a great solution.

[Nich]

So I didn't see a High->Low transition combinators logic. Unfortunately I am not that good with combinators but what you need is

Memory ( if previous steam value >10)
AND
Current ( steam value < 10 )

When both are true inserter works which will only be true for 1 frame.

[Gus_Smedstad]

Yeah, I realized that, while Killcreek2's solution is a fine solution for loading 1 fuel at a time, it doesn't have any sort of edge detection. The setup he showed loads fuel cells as long as the steam is below the desired threshold. What we want is something that loads 1 when steam is low, and then stops.

This is the method I know for detecting transitions:

Comparison 1: If steam < 500, Green = 1.
Adder 1: Green + 0 -> output green. Delays signal by 1 tick.
Comparison 2: If adder output > comparison 1, green = 1.

The final comparator creates a 1-tick pulse (green = 1) when steam goes from above 500 to below. This should replace the simple (steam < threshold) comparison to set the "load reactor" latch.

The main drawback I can see is that it will do this every time there's a transition. So if steam gets above 500, then drops below while the reactor is running, the circuit loads another fuel cell prematurely. This seems possible if the steam is sloshing around between storage tanks, which I've seen happen.

[Nich]

Or if 1 rod is not enough to get steam reserves over the minimum your power plant will shut down for good. but at this point you are at or above the limits of the plant.

[Gus_Smedstad]

I spent some time experimenting, and ended up with a setup that's both simple and reliable.

Reactor Control

This requires one comparison combinator per reactor, does not need to be pre-loaded, and works if demand exceeds generation. No edge-transition detection is needed.

I inverted Killcreek2's memory cell. The comparator reads:

If (fuel cells > used fuel cells) then output (1 fuel cell). The meaning is "if fuel cell is 1, the reactor is currently running."

Inputs are the loading and unloading inserters, as per Killcreek2's setup, and the output is to the loading inserter. Because I'm using red wire for both, the input and the output of the combinator are linked, and it's a memory latch. Loading a fuel cell sets the latch, and unloading a used cell clears it.

The test comparison near the storage tank is:

If (steam < 2000) then output (1 reactor). The meaning is "power needed if reactor = 1."

The input inserter works if power's being requested and the reactor is not running. The test is:

Enable if (reactor > fuel cell).

You don't need to use requester chests, as I did, a belt loading fuel cells into the chests works as well. I really wanted to do that, actually, but I didn't have enough space to make it fit, and I didn't want to move my reactors because I'd lose the current stored heat, and I'd also make the heat pipes longer.

[orzelek]

Looks nice and simple.
Can you post a blueprint of control setup block?
It will be much easier to get conditions right

[Killcreek2]

Yeah, I realized that, while Killcreek2's solution is a fine solution for loading 1 fuel at a time, it doesn't have any sort of edge detection. The setup he showed loads fuel cells as long as the steam is below the desired threshold. What we want is something that loads 1 when steam is low, and then stops.
...
The main drawback I can see is that it will do this every time there's a transition. So if steam gets above 500, then drops below while the reactor is running, the circuit loads another fuel cell prematurely. This seems possible if the steam is sloshing around between storage tanks, which I've seen happen.

Actually with my setup it does not need any edge detection whatsoever: It only loads a new fuel cell when steam is low AND the reactor is empty, so it will never load multiple fuel even if the steam level flickers at the trigger point, as the input inserter trips the memory cell to OFF as soon as it grabs a fuel pack. [The right-hand reactor was setup this way in my previous pic, I now have both cores setup this way.]

Would be very easy to add a 3rd wait condition, just add it to the input inserter wire & set inserter to if >2, so it only loads when all 3 conditions are true then disables itself.

Grats for getting your setup to work.

[MeduSalem]

Awesome solution Gus_Smedstad!

Adopted it immediately due to its simplicity...

I really like how the refueling circuit is encapsuled and allows for simple remote control of the reactors.

[Gus_Smedstad]

Here's the blueprint string for just the control elements. It requires an external (reactor = 1) signal to load a fuel rod.

Nuclear Control Block

Code: Select all

0eNqdVNtu2zAM/ZWCz/YQu26B+mGfsB8YCkGW6YSoLHm6FEsD/3spOUkzLDf0xQZF8pCHtx10OuLkyARod0DKGg/t7x14Whup01vYTggtUMARCjByTFKPinp0pbJjR0YG62AugEyPf6Gt5uImgIlKo3SlQ6n+9a7n1wLQBAqESy5Z2AoTxw4dw1/LooDJena1JoVmuLIuYMu/1Y8njtGTQ7VomwKYbXBWiw438p3Ym132mIJ1fcbx6XUg54O4wSk6aSiO5RBRlwq1Tqw8JqSbrh77Mk7lWQimN0mX6bXwk51sDFP8XjrKTlvmFk0Qg7OjIMNI0A5Se5yz3pilQpl3lT4O+9M+EEuPqcUncjO/snN9wTpp5xOPQyfrY67arskHUqXaoA88FX8i//FMP6ulnTxjsLcSA2k2XWblMIJXqpBIxjTvVUr6v6QeT5Iy63IjGbEvyXh0ZxNa5YRWdw2XIqciBTHaHoUdhJ2Q+5o9OOxByzvRixQ3DWHg9JhacBHvb0/1BZbFC/VvjlQv06uO9K4ROm7L3cty5gDcuSp3rMh8u5hfFlmZzVJb8vn6dp2La+o6tYG39x2d4xsjfJDqjel+5KB89TLR9uQkF6Blh1wL+LWU62HfhIdOW/XGesbyuezPTVM/rV5e6udmnj8Bb/AHqQ==

Actually with my setup it does not need any edge detection whatsoever: It only loads a new fuel cell when steam is low AND the reactor is empty

I don't think that's true. I got fixated on edge-detection for a while there because I thought I needed a latch to address they continuous-loading issue I perceived in your setup.

I could be mis-reading it, of course. Correct me if I'm wrong: your left-hand reactor has a test for low steam, less than 90k in the screen shot, and it sends out "used cell = 1" to the latch. This sets the latch, which in turn causes the reactor to load a fuel rod. This is true even if the reactor is already running. As long as steam is low, the latch is forced to stay in the reactor-off state (used cell = 1). If a new fuel rod appears in the chest before the steam rises, the circuit will load a second fuel rod.

My first, iffy solution to this problem was to add edge-detection, so low steam would set the latch, but wouldn't hold it set (used cell = 1) beyond the initial request.

I'm not really seeing anything to prevent this, but I'm going off a screen shot, and I don't always see all the implications of combinator wiring, so I might have missed something.

EDIT: I looked at the screen shot again, and it looks like the test (steam < 90k) sends the signal to the inserter, not the latch. Which means it doesn't affect the latch, but it does force the inserter to run regardless of the latch state. The inserter's only test is (used cell > 0), there's no AND condition there.

EDIT 2: I must be missing something, because my interpretation makes it look like the left-hand reactor will load fuel rods 1 at a time regardless of steam state, and will load an extra rod when steam is low. Maybe there's something in the cut-off area of the screen. Or something.

[cbhj1]

My solution to this issue has been inserters that pull from chests that never have more than one rod each when steam or accumulators get low, then have them refill the chests with a single rod once the steam/accu gets back up, 2 deciders and an arithmetic to AND them for the reset.
should be stable up to just below the point of overloading the output of the reactor, but at that point there isn't much that can be done with circuits and is anyone seriously using reactors at 100%?

[Killcreek2]

Actually with my setup it does not need any edge detection whatsoever: It only loads a new fuel cell when steam is low AND the reactor is empty

I don't think that's true. I got fixated on edge-detection for a while there because I thought I needed a latch to address they continuous-loading issue I perceived in your setup.

I could be mis-reading it, of course. Correct me if I'm wrong: your left-hand reactor has a test for low steam, less than 90k in the screen shot, and it sends out "used cell = 1" to the latch. This sets the latch, which in turn causes the reactor to load a fuel rod. This is true even if the reactor is already running. As long as steam is low, the latch is forced to stay in the reactor-off state (used cell = 1). If a new fuel rod appears in the chest before the steam rises, the circuit will load a second fuel rod.

My first, iffy solution to this problem was to add edge-detection, so low steam would set the latch, but wouldn't hold it set (used cell = 1) beyond the initial request.

I'm not really seeing anything to prevent this, but I'm going off a screen shot, and I don't always see all the implications of combinator wiring, so I might have missed something.

EDIT: I looked at the screen shot again, and it looks like the test (steam < 90k) sends the signal to the inserter, not the latch. Which means it doesn't affect the latch, but it does force the inserter to run regardless of the latch state. The inserter's only test is (used cell > 0), there's no AND condition there.

EDIT 2: I must be missing something, because my interpretation makes it look like the left-hand reactor will load fuel rods 1 at a time regardless of steam state, and will load an extra rod when steam is low. Maybe there's something in the cut-off area of the screen. Or something.

I see where you got confused: The green wire running up the left of the screen is between big power poles.
The left reactor in that pic was not connected to the steam signal at all ~ that one was set to load 1 fuel only if empty, thus ran continuously on a single fuel cell at a time. [Was from testing one core at max load, my apologies that the wiring was not clearly shown to be separate.]

The right reactor input inserter is connected to both the output of the memory latch and the steam signal via different wires. As you noticed with your first edit, the steam signal does not enter or affect the "is reactor empty" latch.

The inserter is set to if >1, so it requires both the latch outputting "reactor empty"=1, and the signal to indicate "steam low "=1 before it activates.
If the reactor is empty, but there is plenty of steam it waits until the steam=low signal "tops up" the latch signal to the trigger point [>1]. Which then immediately trips the latch back to zero when the inserter grabs the next fuel cell, so that if the steam=low signal flickers it will not load extras.

[Nich]

So I changed my setup to be like yours and it works amazingly well. However I think you did not do a good job for formatting it.

1. Wire reactor output inserter to steam reserve tank.
2. Test if water is less then x (I used 1,000)
3. Set stack size to 1
4. Enable read hand contents

5. Wire reactor input inseter to reactor output inseter
6. Test if used fuel cores is greater then 0
8. Change stack size to 1
7. Seed your reactor with 1 fuel core

The only issue I can see is if you run out of fuel cores the reactor will not restart its self when more get made. However I not have a back log of 1500k U-235 so I dont see that happening any time soon

[kanvil]

reactor-control.jpg (435.24 KiB) Viewed 7702 times

I built something a little different than others I've looked at, although it's not the most compact or scalable.

I have a belt running around my reactors with splitters to pull off a single fuel cell for each reactor. The splitters make sure there's always a fuel cell ready under the fuel inserters so when they activate they all work simultaneously. I have a decider combinator wired up as a counter to count the empty cells as they're extracted. All of the inserters are set to read hand contents, so as soon as a reactor is finished the counter increments. The next decider just checks the steam level and forwards the counter if steam is low. The last combinator isn't strictly necessary, but makes the wiring simpler. It checks if empty fuel cells = 4 (number of cores) and outputs F=1. The fuel inserters are set to enable if F=1. When they pick up a fuel cell, they send that onto the circuit network which causes the counter to reset.

Since all of the fuel inserters operate simultaneously, they each load one fuel cell into their reactor before the counter resets. Because I'm using a counter to track empty fuel cells, if they're not synchronized it still works, and they won't start a new fuel cycle until the last one is finished.

blueprint string for the whole setup

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

[Billiam]

My setup is fairly simple (4 deciders, 1 constant combinator).

• Constant combinator with a count of number of reactors, and the lower threshold for steam in a storage tank.
• One box per reactor containing one full fuel cell (stack size=1 inserter wired directly to it)
• One box per reactor containing one used fuel cell (stack size=1 inserter wired directly to it)
• Wire all the boxes together
• Wire the inserters which empty the boxes together
• Activate the inserters to empty the boxes when:
  • Full fuel cells in boxes match the number of reactors (meaning that fuel is available for all of them), and
  • Used fuel cells in boxes match the number of reactors (meaning that reactors have completed), and
  • Steam in tank is below the defined threshold.
• The unused fuel cell box is refilled with from supply, and the empty fuel cell box remains empty until the reactors finish.

Adding another reactor means wiring the new inserters and boxes to the old ones, and increasing the reactor count by 1 in the combinator.

This does mean that if I'm consuming energy faster than I can produce it (so that steam tanks aren't filling), I'll continue burning fuel cells, but that's what I want anyway.

[Rapier31]

I've got a 2.4 GW reactor with perfect fuel cell loading across all cores. viewtopic.php?f=8&t=47070
It may be more power than what you're looking for, but it's controlled by just 5 combinators. Or maybe 6, I can't remember. I'm reaching the point in my game that I need another one. It's very easily scalable as well.

[cerberusti]

I built a system which can handle 16 reactors (it can buffer more than twice a single fuel rod of output on each, or run over full capacity with 440 turbines. I have the steam to turbines separately controlled based on an accumulator (not part of this circuit). I might expand it more, it lives within the footprint of a single side of the reactors in case I want to do something insane like stack 128 of them.

My control circuit for the reactor and steam storage follows. It inserts exactly enough fuel to keep the reactor going when necessary, and starts instantly when steam goes below the specified level.

Blueprint for the main control (one pole, four decider combinators, one arithmetic combinator

main control

Code: Select all

0eNrFl21vozAMx79LXsOUpAVd0e2kSfd6X+A0IQruZgkCCqG6quK7n4Fe16dRXLVaX7QK2M7f/sWmbMUyb6CyaJyItgLT0tQi+rMVNb6bJO+uuU0FIhLooBCeMEnRrTJIMQPrp2WxRJO40orWE2gy+Csi1b55AoxDhzBE6xeb2DTFEiwZ7OMUkGFT+JBD6iymflXmQLtUZU3Open2p4A+OWzoR9MepNCQMfZCt0J1Xxayw22QVnOyRJs26Pqlar2j28Hxbd2+te2ByX+heizhM5nyKRh00m4iQzvI7KOQamfLPF7CR7JGciaPXciY7mW4T2iFtnbxWfnXaF1DV/aCBgtfiaEmtUs6hKpbFFVie4WR+EUOZeOqhh+y2pCyxrh4ZcsiRkMxRLRK8hra6RhmZ3X2xLsFMFd46XFedMJIg+42vRhtdm5+Ce/sNrz6+/CqxWJxgvjnnRE72zyEsD5vuR3C61FP21eP3w6n4Z+z8Ptqx1/eH/8qb0joJyUHSXFMPgxk93kwe257X+tDPQ1EsNeYWHQfBTh6FExpxWmD9jPoHZqxhi7GdCfdOZUVELJeo3h5/X0DtRfRMriENzalGm3Kr/CFN41R+W1TVJ900fMNPPRDH5IjEIJLLUV4Hea7P1unc0sPT61Zu8+BdKUWHIgO5hfmmmeuWOaSZc2LPVW44pVF8fJUrDwVK0/FyVOy0pQs+JJVE8kpieRURHIKwuOuWAXhHRLWGWEdEdYJ4c0H3njgTQfWcGDNhpHRQLOzf7eNDl6FPbEGW/fu4XyuAxXOf8hZ2/4DU3sSTA==

Blueprint for each reactor (one inserter, one pole, one arithmetic combinator, one belt)

each reactor

Code: Select all

0eNqdVNFuo0AM/Bc/Q5UQWp14qHTfUVVoAaexDnaR1xs1jfj3eqElqGlFei8gY+94POPlDFUbsGeyAsUZqHbWQ/F0Bk8v1rTxm5x6hAJIsIMErOliZJjk0KFQndauq8gacQxDAmQbfIViOySrGPjaM3qfChvre8eSVtjKAiQbnhNAKySEE6sxOJU2dBWydlnDSqB3Xo87G1koZJolcNKX8oOGGOspl0W6X8CzGbzDhkKXYqvlrBP3rsVr6M0FWVW0E7SPyW18MDbLEUijXCuJ60AyhtvheRi+IbKbieyNl5SsRxZN/DTcZmIg7NqywoM5klqjFZ+9NNfMx/bEXsorp47EEvTL3HqqSP/CBO7FxI3ZxKDrDY/2F/A4pj/6MJqmPBjbxI6iQ6kYwgF/EOiFEe2KRFmUKAF3RGZqsFQa9T9l/4YfK/dFunxlYa9NvLufNVzux/eKXkAvovr/VdVjxChXLk3QBY/LuA/YpjW2bTzqelQHRqaQaq0L0off9R9uX9vxWt7qVgLZreYuDYzxbrwP2mtUoFj8qRLQBfDjvA95nt1vH/I/m90wvAPWuqch

Usage: Connect the reactor circuits and the the steam tanks to the main control pole with red wire. The decision combinator sticking out chooses the amount of steam watch for, if it is under this amount the reactor will be on. To start it the first time, you must switch the top combinator (with the condition "1" < 11999) from an output of "input" to 1 and back to "input".

The only failure mode I am aware of is that no provision was really made for running out of fuel (I have a huge amount buffered). It will wait and pick up the next available fuel, but it uses a 200 second timer and will stack charges such that missing 5 fuelings means it will pick the next 5 up.