A waiting train in a siding that runs a pickup/dropoff loop only when destination storage is low — then returns to the siding. Built from the data-cable system and the train station's data inputs.
What the game gives us
Confirmed mechanics that this design relies on:
Logistic Containers broadcast their contents onto the data network automatically. Connect a cable to the container's data connector (it's on one specific corner only — physical placement matters) and you get a live "Iron Ore = 200" signal with no extra wiring.
Train stations respond to enable/disable immediately from the data system.
Train stations expose a train limit input over the data network — you can set the max number of trains permitted to reserve a slot at the station from a signal.
Trains skip a stop if all stations with that name are disabled in their current schedule.
Schedules are named, shareable, and have per-stop wait conditions.
The Data Evaluator performs comparisons and outputs configurable constants. The Data Memory Cell has separate SET and RESET inputs — together they give you the hysteresis latch (set on low, reset on high) that's also the heart of the working storage-conveyor circuit on this site.
Signal values are additive across broadcasters. Two containers broadcasting "Iron Ore" on the same network sum into one signal. Useful or annoying depending on intent — keep separate cables if you want to monitor one container independently.
The known-good latch pattern (from the working conveyor circuit)
The same Eval + Eval + Memory Cell pattern that gates the conveyor on /foundry/ is what gates our train here — just with the output wired to a different consumer. To keep this consistent with the proven circuit, the train plan uses colour signals (green / red) rather than a per-item signal, so the control plane is decoupled from any item signal on the same network.
Always enabled. The container here is what we monitor.
Train schedule (one train)
Depot — wait condition: Cargo Empty (train sits here when not busy)
Pickup — wait condition: Full, or Inactivity 2s as a fallback
Dropoff — wait condition: Empty
(loop back to Depot)
Data wiring
Two Data Evaluators feeding the two inputs of a Memory Cell — identical to the conveyor circuit, just with the output going to a train station's Train Limit input instead of a conveyor's Enable input.
[Dropoff Logistic Container] broadcasts: ItemX = current_count
│ (cable from the container's data-connector corner)
▼
├──────────────────────────────────┐
▼ ▼
[Eval 1 — Low threshold] [Eval 2 — High threshold]
if ItemX <= 100 → green = 1 if ItemX >= 250 → red = 1
│ │
│ (SET input) │ (RESET input)
▼ ▼
[Data Memory Cell] latches green = 1 when below low;
cleared when red = 1 arrives.
│
▼ (output port — must be explicitly configured to broadcast)
[Pickup station — Train Limit input] Train Limit = green value
(1 = train allowed, 0 = blocked)
Step by step
Connect a data cable to the Dropoff Logistic Container's data connector (specific corner — check the container faces; not all sides have it). The item count is now on the network.
Place Eval 1 (low threshold). Configure: if ItemX <= 100 then output green = 1. Wire its output to the Memory Cell's SET input.
Place Eval 2 (high threshold). Configure: if ItemX >= 250 then output red = 1. Wire its output to the Memory Cell's RESET input.
On the Data Memory Cell, open the configuration interface and explicitly set the output slot to broadcast the green signal. This is a known gotcha: the cell stores the value internally regardless, but if the output slot is left blank nothing leaves the cell — same trap as the conveyor circuit.
Run the Memory Cell's output cable to the Pickup station and wire it to the Train Limit input.
Behaviour
Default state — train idle
Memory Cell holds green = 0, Pickup train limit = 0. Train sits at Depot with cargo empty. It looks at its schedule, sees that the next stop (Pickup) has 0 reservations available, and stays put.
Storage runs low — train dispatches
Item count drops to or below 100 → Eval 1 emits green = 1 → Memory Cell SET latches green = 1 → Pickup train limit becomes 1 → train at Depot reserves a slot at Pickup → leaves, loads, unloads at Dropoff, returns to Depot.
Storage refills — train stays home
Item count crosses to or above 250 → Eval 2 emits red = 1 → Memory Cell RESET clears the latch → output goes to 0 → Pickup train limit drops to 0 → train waits at Depot until the next dip below 100.
Why train limit, not enable/disable?
You could instead toggle the Pickup station's enabled signal from the same Dispatch latch. That works most of the time but has a failure mode: if you disable the Pickup while the train is mid-route, the train skips it and may end up sitting empty at Dropoff with nothing to do.
Train Limit gates the reservation, which happens before the train commits to the trip. Once the train has actually left the Depot, it always completes the cycle even if Dispatch flips off mid-journey. Cleaner state machine, fewer edge cases.
Gotchas
Data connector placement on the container
The Logistic Container has a data connector on one specific corner — not all faces. If the cable run doesn't reach that exact face, the broadcast won't happen. Same trap as the conveyor circuit.
Memory Cell output slot must be configured
The cell will happily latch its internal value but emit nothing if its output slot is left blank in the configuration UI. Open the cell, select the output slot, and explicitly set it to broadcast the green signal.
Signal addition
If your Dropoff has two Logistic Containers both broadcasting the same item on the same network, the evaluator sees the sum. Either accept that (treat them as one pool) or split the cable so each container is on its own subnet.
Schedule wait conditions matter
Without a wait condition, a stop is treated as a waypoint and the train passes through. "Cargo Empty" on Depot is what makes the train pause there at all.
Pick your thresholds
100 / 250 in the example is illustrative. Smaller gap = more train trips, less storage buffer. Bigger gap = fewer trips, more inventory swings. 20% / 80% of container capacity is a sensible starting point.
Keep the control signals off your item networks
Using green / red colour signals for the latch (rather than e.g. "Iron Ore = 1" which would clash with the actual item count) keeps the control logic isolated. If you build several of these systems, give each its own colour or isolate the cables.
Extending the pattern
Multiple destinations sharing one train: add more stops to the schedule, each with its own Dispatch-style latch wired to the relevant Pickup or Dropoff. The train chooses the next non-disabled stop with capacity.
Round-robin between multiple sources: two Pickup stations with the same name but different locations. The data network can drop the train limit on one when it's "exhausted" and lift it on the other.
Emergency dispatch overlay: a manual Lever wired into the Memory Cell's SET line forces a trip regardless of stock — handy for testing or for a "send the train now" button.