Balanced Bot Train Loader

[Case]

After fiddling with my bots and them loading chests not evenly I finally came up with this solution.
Not sure if it is useful for someone else but for me it works quite well.

This setup works like the well known mazuri loader but with bots and can balance load a train station (or whatever else you need balanced for that matter). You can put your roboports around it just make sure the requester chests are in roboport range.

Balanced Bot Train Load.jpg (195.96 KiB) Viewed 15236 times

Blueprint

Blueprint.jpg (156.6 KiB) Viewed 15236 times

Wire Layout

Wire Layout.jpg (161.71 KiB) Viewed 15236 times

Settings

Decider Overflow Guard.jpg (86.06 KiB) Viewed 15236 times

Arithmetic Combinator Average.jpg (34.57 KiB) Viewed 15236 times

Constant Combinator Start.jpg (32.9 KiB) Viewed 15236 times

Requester Chest Setting.jpg (73.63 KiB) Viewed 15236 times

Constant Combinator 1.jpg (42.88 KiB) Viewed 15236 times

The setting for the "Constant Combinator 1" is actually -2147483648 but my client has somehow issues with the '-' sign and is not showing it (the blueprint should have the correct value)

The 'Constant Combinator Start' is to initialise the system when the chests have zero items - the number is the number of loading chests.

The 'Decider Overflow Guard' is for when the loader chests are fully filled up and the bots can stop delivering items because of that. 43200 = 18 * 2400. 18 = chest count (adjust if you have another chest count) - 2400 = a full "steel" chest of ore (iron/coal/copper/uranium/stone). When you use another kind of chest (wood/iron) you need to adjust this number to the max items that the chest can hold.

Blueprintstring

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

[RocketManChronicles]

Why such a large negative number in the first constant combinator? Wouldn't you want this to total the maximum amount the chests can hold?

[leitk]

I don't understand the need for this.
The bots will load the requester chests fairly evenly, just set them to request more than the inserters can load, probably 400 or so if you're close to the miners, more if the bots have to travel further.
Skip the steel chest buffer and load straight from the requesters to the train cars. No need for wires, unless you want to set the request by wire.

Unloading is a bit trickier, but I just set up provider chests (active, storage, or passive should all work) with wires to sum their contents, and all the inserters from train to providers set to go when the amount is less than will fit in one chest (depends on stack size).

[quyxkh]

I maintain bot-station balance by not delivering to a stop unless there's so little resource there that even if it's all in a single chest there's room for an evenly-distributed unload, generally <4000 is enough, high-throughput stations like green chips that are doing two-input delivery and simultaneous pickup need <2000 (those have seven unload-buffer chests, 4000/7=571+ so there's never more than 2572 of any resource in a chest).

For pickup, yeah, just set the requesters at enough that the limit is high enough that loading can't drain it before the wagon's full but it gets hit before the next pickup, or (again for high-throughput simultaneous-drop/pickup stations) just take what's there and use timed stops to be sure you can pick up everything that could have been made.

[leitk]

I don't understand the need for this.
The bots will load the requester chests fairly evenly,

Well, open mouth, insert foot...
The bots do NOT load evenly as the OP suggested, and this is a very good solution.
The only thing I really changed on it is that I moved the top constant combinator over one to fit in a medium pole to power the inserters.

RocketManChronicles: The huge negative number is to take advantage of overflow. I think this avoids a combinator for every pair of chests.

[RocketManChronicles]

RocketManChronicles: The huge negative number is to take advantage of overflow. I think this avoids a combinator for every pair of chests.[/quote]
Ok, that makes sense. I look forward to implementing this into my base.

[mrvn]

Lets see if I can explain what is going on:

1) The constant combinator "start" adds one per chest, as if one extra item had been in each chest. So chests are never empty to the arithmetic combinator.
2) The arithmetic combinator computes the average of all chests (+1 from "start"), rounded down (floor) and negated. So it is always negative.
3) The constant combinator "1" adds MIN_INT. With the arithmetic combinator being negative this causes an integer underflow so it becomes positive. The requester chest get a signal of MAX_INT - average chest content from the green wire.
4) The red wire adds the actual chest content. The combined signal is "MAX_INT - average + chest", which overflows if the chest has more items than the average.

Note: So far at least one chest will always request something, They can never all be above the average.

5) The decider combinator checks if all chests are full. In that case it adds one to the green wire. This causes the requester chests to overflow one early, when the chests have reached the average, which they have since they are all full. Only this in fact stops requesting items at all.


Now here is where I see a problem: I have 1m iron ore in my logistics network and 100k logistic robots. Each requester chest requests 2 billion iron ore. So all 100k logistic robots are dispatched to fetch iron ore. But 600 logistic bots already fill the chest to completion, then 600 more fill the requester chest too. All the rest then hover over the requester chest failing to deliver. Worse if it is only one chest that is below average. Now all 100k robots go to that one chest.

Obviously you don't have so many logistic robots. But the problem remains I think. Whatever chest is below the average gets all the logistic robots. It then gets hugely more than the average. Due to the delay between bots getting dispatched and items arriving any imbalance could cause massive delivery spikes that make things even worse. I think the whole thing only works when you do not have enough logistic bots or not enough iron ore and that slows down delivery.

Here is how I would fix it:

Have each requester chest request one stack or iron ore (or 2 or 10, doesn't matter, enough to keep iron ore in them). Then wire up the inserters just like you did the requester chests and set to anything > 0. The logic is still the same but now it reacts in one tick. By the time the inserter has returned to pick up the next iron ore the arithmetic and decider combinator have updated their output and the inserter will not overfill the buffer chest.

Note: For single item type stations you don't need the underflow trick but for multi item type stations you want filter inserters with "set filter" programming.

[RocketManChronicles]

Now here is where I see a problem: I have 1m iron ore in my logistics network and 100k logistic robots. Each requester chest requests 2 billion iron ore. So all 100k logistic robots are dispatched to fetch iron ore. But 600 logistic bots already fill the chest to completion, then 600 more fill the requester chest too. All the rest then hover over the requester chest failing to deliver. Worse if it is only one chest that is below average. Now all 100k robots go to that one chest.

Obviously you don't have so many logistic robots. But the problem remains I think. Whatever chest is below the average gets all the logistic robots. It then gets hugely more than the average. Due to the delay between bots getting dispatched and items arriving any imbalance could cause massive delivery spikes that make things even worse. I think the whole thing only works when you do not have enough logistic bots or not enough iron ore and that slows down delivery.

Here is how I would fix it:

Have each requester chest request one stack or iron ore (or 2 or 10, doesn't matter, enough to keep iron ore in them). Then wire up the inserters just like you did the requester chests and set to anything > 0. The logic is still the same but now it reacts in one tick. By the time the inserter has returned to pick up the next iron ore the arithmetic and decider combinator have updated their output and the inserter will not overfill the buffer chest.

Note: For single item type stations you don't need the underflow trick but for multi item type stations you want filter inserters with "set filter" programming.

This is why I question the negative 2 billion number. Why would you not make this the maximum that can be held in the requester chests, so that you don't have robots waiting to load the chests? To make it simple, let's just say that you can hold 10k ore in the chests, make "Combinator 1" have a value of -9000 (the difference just for stack sizes/timing of bots), therefore, you get exactly what is needed. I do like the idea of attaching the inserters to the network to control how much they transfer to the buffer chests.

[mrvn]

Now here is where I see a problem: I have 1m iron ore in my logistics network and 100k logistic robots. Each requester chest requests 2 billion iron ore. So all 100k logistic robots are dispatched to fetch iron ore. But 600 logistic bots already fill the chest to completion, then 600 more fill the requester chest too. All the rest then hover over the requester chest failing to deliver. Worse if it is only one chest that is below average. Now all 100k robots go to that one chest.

Obviously you don't have so many logistic robots. But the problem remains I think. Whatever chest is below the average gets all the logistic robots. It then gets hugely more than the average. Due to the delay between bots getting dispatched and items arriving any imbalance could cause massive delivery spikes that make things even worse. I think the whole thing only works when you do not have enough logistic bots or not enough iron ore and that slows down delivery.

Here is how I would fix it:

Have each requester chest request one stack or iron ore (or 2 or 10, doesn't matter, enough to keep iron ore in them). Then wire up the inserters just like you did the requester chests and set to anything > 0. The logic is still the same but now it reacts in one tick. By the time the inserter has returned to pick up the next iron ore the arithmetic and decider combinator have updated their output and the inserter will not overfill the buffer chest.

Note: For single item type stations you don't need the underflow trick but for multi item type stations you want filter inserters with "set filter" programming.

This is why I question the negative 2 billion number. Why would you not make this the maximum that can be held in the requester chests, so that you don't have robots waiting to load the chests? To make it simple, let's just say that you can hold 10k ore in the chests, make "Combinator 1" have a value of -9000 (the difference just for stack sizes/timing of bots), therefore, you get exactly what is needed. I do like the idea of attaching the inserters to the network to control how much they transfer to the buffer chests.

Because for filter inserters or requester chests you need a positive number if the chest has less than average items in it: But "average - chest contents" means adding an arithmetic combinator per chest. "chest - average - MIN_INT" underflows to become positive saving you the arithmetic combinator per chest while loosing the exact count needed.

[RocketManChronicles]

Now here is where I see a problem: I have 1m iron ore in my logistics network and 100k logistic robots. Each requester chest requests 2 billion iron ore. So all 100k logistic robots are dispatched to fetch iron ore. But 600 logistic bots already fill the chest to completion, then 600 more fill the requester chest too. All the rest then hover over the requester chest failing to deliver. Worse if it is only one chest that is below average. Now all 100k robots go to that one chest.

Obviously you don't have so many logistic robots. But the problem remains I think. Whatever chest is below the average gets all the logistic robots. It then gets hugely more than the average. Due to the delay between bots getting dispatched and items arriving any imbalance could cause massive delivery spikes that make things even worse. I think the whole thing only works when you do not have enough logistic bots or not enough iron ore and that slows down delivery.

Here is how I would fix it:

Have each requester chest request one stack or iron ore (or 2 or 10, doesn't matter, enough to keep iron ore in them). Then wire up the inserters just like you did the requester chests and set to anything > 0. The logic is still the same but now it reacts in one tick. By the time the inserter has returned to pick up the next iron ore the arithmetic and decider combinator have updated their output and the inserter will not overfill the buffer chest.

Note: For single item type stations you don't need the underflow trick but for multi item type stations you want filter inserters with "set filter" programming.

This is why I question the negative 2 billion number. Why would you not make this the maximum that can be held in the requester chests, so that you don't have robots waiting to load the chests? To make it simple, let's just say that you can hold 10k ore in the chests, make "Combinator 1" have a value of -9000 (the difference just for stack sizes/timing of bots), therefore, you get exactly what is needed. I do like the idea of attaching the inserters to the network to control how much they transfer to the buffer chests.

Because for filter inserters or requester chests you need a positive number if the chest has less than average items in it: But "average - chest contents" means adding an arithmetic combinator per chest. "chest - average - MIN_INT" underflows to become positive saving you the arithmetic combinator per chest while loosing the exact count needed.

Ok, that makes sense.

[tamanous]

TL;DR
I did a version where I controlled the inserters, not the requester chests as the OP did. The balancing was improved. Support for multi-item added. Blueprint attached at very bottom of the post.

---

Some month ago, I wanted to solve the same problem and was satisfied with my solution of reading each chest's content. Reading of your solution really got me, thanks for that. After reading this threat and testing your setup, I have to agree with the given objections by mrvn and RocketManChronicles.


Assumptions & design concept
1. I too didn't want the requester chests to request that much Items. I would like to design the train loading station in a way that could work with not-separated roboports, even if I would prefer to at least have the option keep it separated.

2.1 It might happen, that a train entering the station to be loaded is already partly loaded.
2.2 The trains will either go to a (de-)centralized unloading station where everything will be unloaded evenly, or directly to i.e. an assembling station where maybe they would not be unloaded evenly.
2.3 Reading train content and controlling delivering adequate demand only is not included here.

3. A train loading station of that kind would probably be installed near furnaces or mass producing assembling plants. A one-sided 4 wagon loading station with therefore 6 (maxed out) stack inserters can load around 17880 (744.5 x 6 x 4) items per minute, plus the time window for the trains entering and leaving the station. Mining drills at ore patches might not keep up with that speed.
3.1 As for ore patches, imagining that a solution here might be delivering different ores to one train, i.e. in shared ore patches, setting different items -per wagon- for the requester chests might be a choice you want to have. Though there are some other, like setting filters for the cargo wagons' slots - which I don't prefer here, as our intention here is to do a balanced loading.
3.2 Of course, you can sort the items later, but just loading what comes first will probably lead to random chest contents, which we don't want for several reasons.
3.3 Loading different items in the same train requires (here):
a) different combinator logic per item
b) a closer look at the trains leaving setting (i.e. the 2 wagons with iron ore might be full, but the 1 with coal might only be half filled)
c) for reasons of simplicity, every bot/roboport on the loading station is in range of every chest.

4. Thinking this any further, by setting the filter for each requester chest, the basis for multi-item cargo wagons is done, though this might need further train inventory control.

5. Therefore I decided to not combinator-control the requester chests, but the inserters. I chose to set the item requests per wagon manually (or with a constant combinator i.e. per wagon).

6. I ran some test with 6 provider chests (positioned centralized above the station) and 480 bots delivering to a 4 cargo wagon station and found, that for large numbers the balancing of the OP's design was doing good, but looking at small numbers the balancing was somewhat off. In the solution posted in this post, the balancing is too when running multiple items. It works very well in terms of balancing for small numbers too, assuming that there are enough items in stock to be delivered to the requester chests and only 1 item type is delivered. At least, there is no big variation in the delivered amount per item (every chest containing iron has nearly the same amount, though the chests containing stone have different amount(s)).

---

Setup

Overview over the station. Logic elements are pulled out a bit to offer a better view.

overview.jpg (1.18 MiB) Viewed 12437 times

The 4 wagon station loads 4 different items.

1st wagon: 6 chests iron ore
2nd wagon: 4 chests iron ore, 2 chests stone
3rd wagon: 6 chests copper ore
4th wagon: 6 coal

Number-boxes are redwired to the corresponding chest and showing the amount of items inside. Don't get distracted by the redwires between inserter and steel chest.


wiring

Detailed look at the wiring.

wiring.jpg (565.72 KiB) Viewed 12437 times

The items (per chest) are set with the top constant combinators. They are only (green-)wired to the corresponding requester chests. As Wagon 1 and 2 share a resource (iron ore), there are 3 greenwire connections between them (1. requester chests, 2. inserters, 3. steel chests). The connection ends before the row with stone. I've chosen an amount of 200. The arithmetic combinator is set to input: [each] / [number of chests], output: Signal A. Its input is wired to the inserters, its output to the steel chests. The inserters are connected via greenwire and set to mode: enable/disable, enable condition: [everything] <= Signal A. Each steel chest is redwired to the corresponding inserter.

blueprint string

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

Enjoy.