Combinator mesuring belt throughput

[Optera]

Since I couldn't find a contraption to show belt throughput /second, I thought I'd share what I meshed together from a clock and XKnight's memory cell.

2016-07-23-18-04-32-7180810.jpg (380.93 KiB) Viewed 56971 times

Blueprint

H4sIAAAAAAAA/81X0W6jMBD8lYpnU2FIcpV6fuj9RnVCDt6kloyNbFM1Qvz72SSpIA3FIWl7fYmKPetlZnfMMnUnVEHFXU4akJZbDoY0jaQlkKgExusyBgGF
1byIKyUgQpUybpuSpHkjGdqReNG26IAwJRUiFrSshvvSk33wVmkwJraaSlMpbeM1CDvELDxm2SLGtTvfP1xcjl+cxxdKGkuljQtVrrmkVukhOPHgbABGDmS1
EvkaXugrV5o0Gy4saE+Y4VtJBWnsrnLhX7m2NRUROrDSLcZPUeti1NISjLhk8EawSygE+ecduTpC07b1z6Tcp+dyeI5w9Jc0GpjLp9Nyl3NGfqGC66Lm1v+D
W/93ZIFBwRnoURKwJwHfL6doOMTJ3Qrjh2w2XBubh9Oy18MVlEumotonQ6LfEVK1reqwQEkXqNrlHVX5Rqsy59KhyYYKA/P4Qr2lh1Mq0XOU+hhbDSAHUTCe
T3vybbQb8Nig7fsSnCvN06g0VtezlEkHyqzGRVv2dLphb6Q/3RvkIgHwTXpjdUEDpOPcBrt3OsXu8QiQdC0gZ9z43/07vZ+vgbL8hbpC9wFciqaruvf149P9
xlIxIMmMZLPzV81kt98vHTrpg1c3r6OkX0fpFY0Mr6B39oXL7S06euiSw5bGy+Faiz4W2SoUjj8xgVOrHkR5uNgUkq/2BNzXMrnCE26sZXZWoqEPpOP3afqZ
RKdiTh40z3CSn/ObMI5vYar4p14SX/AJ1Jki/kZTxP9PI6XTxvfx8zLU3eaUTHrdEIbPw6eny9ijs3lXSf89w+bYLGyMzS7nb2QIDYWPfFiEwk9G6BbxoiPy
ZPLkFspjXY+EbkfH1j74TG+3vaH1UYOttbzLH0GyfzcdKAd/EAAA

[siggboy]

While I was trying to make your contraption smaller, I came up with a variant (which also happens to be smaller):

throughput.PNG (164.28 KiB) Viewed 56922 times

This one measures the average throughput per second (configurable) and resets automatically every minute (also configurable).

It keeps outputting the current value at the top combinator.

Short explanation: The right register counts the ticks and the total counts from the belt. It is set to clear every 3600 ticks. The middle one divides the counter by 60 (to get from ticks to seconds). The left one negates the counter, so we can subtract it from the register output. The top one then divides everything by the number of seconds.

Edit: I've come to realize that the posted solution is slightly braindead. The combinator that does "Yellow * -1" to subtract the counter is not necessary. One can instead do (in the middle combinator) "Yellow / <interval> -> S" (signal "S" is then the amount of intervals passed, e.g. seconds). Then divide by "S" instead of "Yellow" in the top combinator.

For a stable output (register buffer) combine it with the idea shown in XKnight's contraption below.

Blueprint

Code: Select all

H4sIAAAAAAAA/71V7W6jMBB8lYqfJ3MHpNdT1fpJqhNy8CZZydhoveSCEO9+Bpq0+SAqadX8icA7s7sz60W7O+MKZe5y2YJlZAQv29aqEmSkCHlTAmMRF65c
olXsKBKV8yHOWdnuZJyJRsbJz9+dKJxlciZfwkZt0ZFs3/B5ONQDKLCvkDznHtdWGdlyU4VUWySulYnEmHk8jBswxv2LBm7PyrKMU+EqIDXkj35EwtVc1fPY
uoHPQvFaz0uURn9lS6BD54MITY5aLkSBVNTI/UPao16irA9cE4A9Cs2OQ8UUS9b1PzFD3qBsL3DWCY00Vtxn+3qpQRWbILSHHj7PnHeG/JplyJhzwo5zldPP
SZl+76Q+JLcLM3NS0+nxu//4EJ/IO8lyrLyGAjXQpOzJFdVfsV8m+eIhScJTWSnqC5HR87xx3AI1vEG7HkirJhRWW85X5MocbaCRTDXctj6uySnOzfhzBHh8
Z9xpnlOHL5Bd2UGwqwi8j5mU9ZUjjpdg+NjC4eKklwzc04JVSwO5Rt//y5UyHg45CZTONypslZ4gVOUHGQ/n+7djYOk0DG3MLTB7w+wH4vpX62JHKzQM1H8C
Z45gGJRQB1oNu/GefWynnd3P+Z3fIFbynWYmn9CiE1gMoBM7kKHce3F593cHL8QV7IRge3B2Br48B48HxGI24j50+UTANdm7/Ams/g+Up8MekwkAAA==

[siggboy]

Another variant: you can also put the belt to "hold" mode, and divide by the original tick count in the top combinator (the two bottom left combinators are not needed in that case). The result is a number from 0 to 7 which is the average number of items on the belt tile (rounded down). This can be used as a measure of belt density. (Related thread: viewtopic.php?f=8&t=29479)

[XKnight]

Don't even expect that someone would have any problems with throughput measuring in 0.13...
But if this is a dedicated thread, then I also share contraption (it served well to me in lots of experiments so it is time to see the big world):


Actually, it doesn't measure throughtput per second, but it measures throught per interval (if you want throught per second you can divide output value). Also, output value is stable during measurement because it is stored in memory cell.

Blueprint

To start measuring you should switch on upper const combinator.

Code: Select all

H4sIAAAAAAAA/+VVXY/aMBD8KyjPTkXoXQq6un/kVFkmXsCSY0frDSKK8t/rJHwoEGi4a9WH8oIce2c9Oztr5WbGZdLMBK/BkiYNnte1lTnwCA4FgvcxobS+
cEjxGgxFrHA+HHSW1wceJ6zi8aJhSiNk3dewOAJkznqSluLM5WttJTkci04G0SxEEToj1rCTe+2Q1xttCLC9mNdbKw2vqSoC/l4jldJErE/Xb8YIKmoCSmmJ
J0xbBQeeNA3TXgT8jTQe2m1r+4wB9j1Kop+8DoEhRVeGSmjFX1mmMSs1tYsWYYsAdnBkeXUk/NgT1ZvfFm+E/ikFWLk2IJT27X/P5JwfQSqxk1aJFiDc0HPC
8rJ/+tofzJ0CPv9YGZ7k+KhBFGRaAd7tj/mX10kNcsRpSSp9ZLPR6Ek80zB9s/I0mYdFXkhsL8Sj7xFzJRXlNDDYA1a003bbYRaV6DpRbNDlQtsA0+nSTKt9
W6o7Sgy3vg5Wq2vJ2Hu0eFLbaead/z3vvixWL6s0TZfpxcTjVbv15U0BLrx8Lo2JjcyLETpJ88B/5+76RHMNW+tHNJnRg0kzzUX/r4mWQ9uMzfGhmb49cMyV
Dnddt/iARL810x+VaCgQ/4cCTXho06mS9HUPr33WZbyaOpogP1EZ0aQ5Txr2IPDOq3cKbm/whkAl2pl4A6t+ARHm1hllCQAA

[siggboy]

Don't even expect that someone would have any problems with throughput measuring in 0.13...

Not everybody eats combinators for breakfast and spends so much time investigating game mechanics like you do . For some of us, this is actually hard, so a thread like this is very useful.

Actually, it doesn't measure throughtput per second, but it measures throught per interval (if you want throught per second you can divide output value). Also, output value is stable during measurement because it is stored in memory cell.

It's much like OPs solution, but you have found a better way for keeping the register updated.

Thanks for posting it.

[Optera]

While I was trying to make your contraption smaller, I came up with a variant (which also happens to be smaller):

This one measures the average throughput per second (configurable) and resets automatically every minute (also configurable).

Works like a charm. Summing over 3600 ticks instead of 60 makes the reset tick unnoticeable.

Another variant: you can also put the belt to "hold" mode, and divide by the original tick count in the top combinator (the two bottom left combinators are not needed in that case). The result is a number from 0 to 7 which is the average number of items on the belt tile (rounded down). This can be used as a measure of belt density. (Related thread: viewtopic.php?f=8&t=29479)

Thanks for the link, perhaps density will come in handy for something.

Don't even expect that someone would have any problems with throughput measuring in 0.13...

Not everybody eats combinators for breakfast and spends so much time investigating game mechanics like you do . For some of us, this is actually hard, so a thread like this is very useful.

Couldn't put it better. Quite often your builds use game mechanics I wouldn't ever though of using.

Actually, it doesn't measure throughtput per second, but it measures throught per interval (if you want throught per second you can divide output value). Also, output value is stable during measurement because it is stored in memory cell.

I'm happy my solution uses only one more combinator (after division for throughput/s) than yours.

[siggboy]

BlakeMW has shown me the way to build a compact counter that keeps a running average. So there's no need for clocking into a register explicitely, and the output is continuously updated. It's also possible to change the "window size", that is, how quickly the counter reacts to changes in the input.

So you can display long term trends with a slowly adjusting counter, or short term trends with a quick adjustment.

belt-counter.png (129.68 KiB) Viewed 56676 times

A basic setup requires 3 combinators, in this version there's a constant combinator for configuration and another one to scale the output value for display.

The idea behind it is to take the exponential moving average, one version of the formula for that is:

avg_new = (n * avg_old - avg_old + input) / n
or, equivalently
avg_new = avg_old - (avg_old / n) + (input / n)

The average is kept in a register. You then take (avg / -n) in one combinator (this one reads from and feeds back into the register) and (input / n) in another (that's the input from the belt into the register).

You can also think about it this way: each tick you subtract a fraction from the current result and at the same time add a new piece of input. The result will then converge to the average over the past few ticks. How many ticks depends on the value by which you divide (higher values only subtract tiny bits, so it's takes longer to converge, ie. the process is more "smooth").

Now, usually if you try to add (input / n), then this will often fail unless the inputs are large values. So it's better, or even necessary, to not divide the input at all, and instead scale the result value (the average) down by "n" before displaying it. In fact, it's even better to scale the input up, so you get more precision in the output (since we only have integer operations that's the only way to get fractional results).

The value "n" is what influences the smoothing of the output. The larger this is, the longer does it take for the average to settle, but it also makes the output more stable ("smooth") because it takes into account more of the history of past inputs.

If you pick these constants (scaling and window size) correctly, and average over multiple belt tiles, the results are almost exactly the theoretical values (so you can measure 26.66 units/minute from a red belt, or 766 units/minute from a stack inserter loading from chest to belt).

I really love this setup and I'll be using it for my belt counting needs. It's also great for other things, like measuring long term trends in accumulator charge, coal supply, train count at a junction etc.


In the blueprint the input is scaled by 60, and the smoothing factor is 100. This gives a readout of "items per second" if you connect to a belt in pulse mode. If you want items per minute, scale the input by 3600 instead of 60.

blueprint

Code: Select all

H4sIAAAAAAAA/81WTW/bMAz9K4WOg73ZbpIiKHQYim6n/YJiMBSLaQjYkkHJRQLD/32S8+U4TuK2w7BckljkI/keSVnqu1xnIr9LeQ3KokUwvK6VKICzAiRW
RQg5ZJYwC0udAwtKbZyZVrxe83ASbHjUBJlWyhm5p877hcXsN68JpENqQTcpSn4fZEhZhdb/SRr/CXaBJGQogcJMFwtUwmrqhYm/Tl2gMG4CibQNxBMf1ZLO
0wWsxBtq4vUOKHUnEnfpLJGMTQ2+KpHz2m5KF/ANyVYiZ8E2/vYwfGZtJcYKZXnkfhalIJ8NZ5wFurJlNQ7oqQUqNy6PStl0SbpIUTlvbqmCZpivVwJQJ4wl
fcaCF5bcpDZ2djewHI+do8llYQShXRVgnfg3tIm60swGpDlCfVAdT6oB7zvK/Kcz1yU4/XxG7Nu7BPzOmgsq9anvadTl9eGKYvF7aY4GJuB/oPnHZ2h+ukjz
eQOfdeme2hump71+Ra7pp8Yg+kdTACJbddfULOrS/+Uv0d9v19l4vs9n4MgjrEsCY0JLQplSkw0XkNtTIu8PN0qPun0MUGKRQyrR+G++FLmBQwIEQqYr4ZrX
A7g8TLtyD+f7p1vDQksYe31Nezu2U9ZejCs70hUVDxW1xNwC+St37LC1VwqfJPPJfPYQz2cBKgnrts3HrsUtRBxFO99kbBuMuGcGpqgJMGtRewmihWKf3fCE
NReL6/pe6KrmWN3O8HldauVTde87v9yKfySwFam79BGU/ANa1hjTCgkAAA==

[Optera]

For me this design is showing random numbers.

2016-07-30-07-28-21-7808321.jpg (472.59 KiB) Viewed 56623 times

Top counter is my version showing throughput/5s
Bottom one is your version with input set to 300. Should be for 5s too according to your description.

[siggboy]

I've just tested it again with the blueprint that I've posted above (imported it just to make sure there was nothing wrong with it).

It works fine for me. When I connect the blueprinted circuit as it is preconfigured to a compressed blue belt, I get "40" as the readout (items/s). When I put "300" into the input driver, like you've tried, I get "200" as the readout (well, actually "199" but that's due to rounding).

So you've either changed some of the other values by accident or you have some large value in the counter (in that case you need to reset it). I really don't know what else it could be.

Maybe you have the belt in "hold" mode instead of "pulse" mode?

In any case, there's nothing wrong with the counter circuit as I've posted it, it must be some error on your end.

[Optera]

Odd...when i connect it to only one belt it seems ok, when connecting it to all 8 output belts the result goes wild.

[siggboy]

Odd...when i connect it to only one belt it seems ok, when connecting it to all 8 output belts the result goes wild.

If you connect to 8 belts the input will be multiplied by 8. You have to compensate for that by reducing the factor in the input driver. If you actually want to connect 8 belts in parallel I suggest you simply divide the output by an additional factor of 8.

The result going "wild" suggests that overflow is happening. Scale the input and outputs correctly and it's never an issue.

[CaptainKonzept]

A basic setup requires 3 combinators, in this version there's a constant combinator for configuration and another one to scale the output value for display.

avg_new = avg_old - (avg_old / n) + (input / n)

The average is kept in a register. You then take (avg / -n) in one combinator (this one reads from and feeds back into the register) and (input / n) in another (that's the input from the belt into the register).

Cool! Do you think you can provide the settings in text form or post a vanilla blueprint string (0.15)? That'd be awesome.

[totobest]

A basic setup requires 3 combinators, in this version there's a constant combinator for configuration and another one to scale the output value for display.

avg_new = avg_old - (avg_old / n) + (input / n)

The average is kept in a register. You then take (avg / -n) in one combinator (this one reads from and feeds back into the register) and (input / n) in another (that's the input from the belt into the register).

Cool! Do you think you can provide the settings in text form or post a vanilla blueprint string (0.15)? That'd be awesome.

I concur!

[mrvn]

I guess the next step would be to not just measure but drive belt throughput. Say for example the steel plant should be 50 iron plates per second.

[DemiPixel]

I guess the next step would be to not just measure but drive belt throughput. Say for example the steel plant should be 50 iron plates per second.

Scan belt for items coming in, then have another belt to detect items going out. Increment a signal when an item goes through the in and decrement it when it goes through the out. Put a transport belts which can stop itself before the "out" belt. If the signal is larger than a number, stop the belt because too many items are coming through.

All the details regarding how many items fit on a belt and the speed of belts can be found on the wiki and used to get a more specific numbers.

[Anson]

Increment a signal when an item goes through the in and decrement it when it goes through the out. Put a transport belts which can stop itself before the "out" belt. If the signal is larger than a number, stop the belt because too many items are coming through.

i think this won't work like this ...
when too many items went in and thus the count is high, the output(!) is stopped and thus the count will increase even more from more items coming in and none going out.
the "stopping belt" would have to be in front of the input.
this simple method also doesn't react on throughput, but only on the number of items in a specific region, and thus has to be finetuned for every different application.

i would implement this by having a simple counter (pulsed count from the belt) that stops the belt when a given count is reached, and that is reset by a timer. thus it would allow eg 50 items to pass and then stop the belt for the rest of the desired intervall (eg 5 seconds), resulting in an average throughput of 50/5=10 items per second:

Througput Limiter.PNG (188.55 KiB) Viewed 52166 times

Factorio 0.15 blueprint, using the creative mode mod:

Code: Select all

0eNq9mEGPoyAUx7/KhrNuhNpOx+ye5jrHuW0mhuprS6JgAJtpJv3uCzqtjqsW2clc2iD0x5P/e3+g72hX1FBJxjVK3hHLBFco+fOOFDtwWthn+lwBShDTUKIAcVra1p4qHWpJuaqE1OEOCo0uAWI8hzeU4Etwl5BDxnKQYSbKHeNUC9kDkMtrgIBrphm08TSNc8rrcgfSzDAbSYAqocxvBbfTG164CtDZfpkpciYha/tiG+eATBaSySh5M0JeLSRjZ3K8jBw5g9fLwO4Rb/z0w/f1e/Ajk/vk7Y0Mb5UEpZwlHMDJCPzxBs8kUM1OEJYih9QWTahELTOYTr4B3yzunhUaZFs616K8zcCk4GFVUA3IRnKtudH+15FYcbR4JW4LMYbrIlMlLYoQCvMmkmVhJQqYTF88yiKLQ4vGNQqQ8UItRZHu4EhPzPiTGZ8xmdVMp6Yvv0H2TCqd/uN3JyZ1bZ50b9eMCOEE8qyPjB+s41nH1dTa7zqyrbKisnHDBP1q+j9mBE53BaQ5U/YbJVrW0PWanMnTI+W5jUybRVHDEdfn7VCbW+bV2/l5+9LKxo7th4S8b7rMtEjUoZq2yYxRARa6HJkTM54ripMwcUzxHMoZr72cwsGCsJ+7RQ7kzt2uedPfQKcMYhjzeG73PcM5mV/aHK5tAuM7B4ApxnOPsYqi/ilgIkEPEoAPUxRvP6conkrR7dwhZMrEo5/ry/i6fUA6T1AeptCsowLLSJcu3CfLCJCodVUvnToT1TltNEj3UpQp44bResjF3SWGEjTnuHGxHhpxiSMI93Rs2o+OWj8u0jr6Nqk72x+6/m8PCZ9mJNzTQv2nhjNCDfeFKSFItEiIb6m5p68XYri3f0VR/bv1ztfCUsEGtKmdnWCfnT0aRREf1OgZgay89lqHEzmJve5rLuS11x3ThbzxubC5gB98rpgu4K1PKph7hNlYmj8Ukt4/GAEqqPmZefZylKI+HE25/XhmpRloPcbUpmovSHFM1qsNjrHJqb8GdMlS

- the constant combinator in my layout is set to T(1) and L(300), T for the timer and L as the limit of 300 ticks for 5 seconds
- the first decider is set to: "if T<L then T(input count)" to create a timer of L ticks (L set in the constant combinator)
- the second decider combinator creates a clock signal C of only 1 tick length whenever the timer is zero: "if T=0 then C(1)"
- the third combinator is the counter which gets pulsed inputs from the belt and adds them to the itemcount: "if C=0 then iron(input count)"
- since those wires are all red, the itemcount is available at the belt too and can be used to enable the belt only when iron<50 (in this example).
as a result, the belt lets items pass at full speed and counts them until the condition is met.
when the timer resets it causes a 1-tick pulse on C that resets the itemcount and in turn re-enables the belt.
the second combinator and the conversion to a C clock (that is 0 all the time except when triggered) is important so that while counting items no other signal (like the timervalue etc) are also added up and make it difficult to have a reset condition on the third combinator.
this also makes it easy to use "everything<50" on the belt and "if C=0 then anything(input count)" on the counter, and thus use the blueprint for nay kind of item without the need to adjust the item types.

[Anson]

almost the same as in the last post, but with additional display, last-minute-display, etc, here are screens and blueprints of the throughput counter that i use since quite some time. i got some ideas for it from lots of posts and videos, but then created this myself from scratch ...

the advantage of my setup is that i get (almost) exact results instead of "running averages".
but the disadvantage is that i get those new results only at every end of the intervals and they are immediately reset.
thus i have added some memory to store the static value of the last interval.

Throughput Counter.PNG (468.69 KiB) Viewed 52159 times

detailed description of the timer and counter : see previous post.
this version displays the currently measured throughput on the big nixie tubes, and since that is a running count also the final count of the last minute is shown on the small nixies. the other small nixies count the seconds so that you can easily see when the next static display will be finished.

and here are the details to all the combinators :

Throughput Counter Wiring.PNG (132.51 KiB) Viewed 52159 times

marked red :
all "pulsed belt sensors" can be chained and connected to the red input wire 1
the output wires 2 (which are directly connected to the input wires 1 and the counter E) show the current count durin the current intervall.
the output wires 3 (which are connected to the memory G) show the throughput of the last intervall.

marked blue:
A,B,D,E: same as the combinators in the previous post.
C: simple "divide T by 60" to get the current timer value in seconds.
F: this combinator forwards the count from the counter E to the memory G. because of the runtime (1 tick per combinator), this combinator's new values are the old outputs from E on exactly the same tick when combinator E itself resets. And one tick later similar happens for F and G when F is reset (to no longer forward any values to G during the current intervall)
G: memory cell that stores the last intervall's counts. the clock C (from combinator D) is connected to all of EFG, and may also be forwarded through F together with all desired signals. thus the memory cell has to hold values when C<2 (especially 0 OR 1), and to guarantee that it is reset (and C is not only increased from 0 to 1), C would have to be 2 or more. combinator D can only output 1 or "input count", and a multiplier would add additional delays. but luckily there is a simple trick: D and G are connected by a red *and* a green wire, thus C is added to the input of G twice and C>=2 is guaranteed. I already have seen other setups in videos where similar setups have to be "primed" with some starting values. my version should require no such additional preparations.

blueprint with "comment combinators" (see screen above), mods: creative mode and nixie tubes

Code: Select all

0eNrdW1tzozYU/is7erZbdAGMp31K9yHTbrqz6zx1Mh5sK4mmGBghp5vJ+L9X4PgSWwIdDInbl2TA8CG+c9F3jsQLmiUrnkuRKjR+QWKepQUa//WCCvGQxkl5Tj3nHI2RUHyJBiiNl+VRKn4IPlSrGUfrARLpgv9AY7weNN6oZJwWeSbVcMYTdXAzcbj5Pi7U0IpAHRD4j1zyorCDsPXdAPFUCSX4honq4HmarpYzLvVL7rCKZZwkQ57wuZJiPsyzhOsH5Vmh783Scggab+gP0LP+x/QjNLmpvlhUHL8gXP6RfHH4FKGPcFS+yMEJ6q3v1uuDk9uxkN1YSrupOFXDebaciTRWmbSPRROFFkJuhlKh6NuVzJLpjD/GT0Lfq2+4F4ni0uINT0KqlT6zJ6O6YniFqvdcle6EGxzDhnFrxCAlB6cUUJNLWt8c/+SbQBiQR9o7j5874PEGwqMPpID1TsG3Dij4BqEgcHMlVutKoRsIrQUZAY2BezfG1w6M8dliDAjGFyNGCMK4NmKMzE4RAU1BejfF5BxTzJI4/RsSFNgzOPSwmvrsjkiMSNgtNMg+NMyszYWcr4Sa6t8WuzvvhSzUtGH2FzJLh3kSK76hYGNQnfzC8miZx7Ky6hj9itbu8zUJLdMzBs7P3mXn1DrfOX9eCs8dhCWAMQU4sLf13/fyPOZ5Z7leZHM9oKSh+xe/4BnktgPvu+5gBrkBOSBQWvm9m6ILcflbB6aYWExhpjGA0ch6p/GPDmj83gGNXzvw6FuQR+9F7lzyWIknPlxmCz4tc96wyFZybprY8as6wG9Nou16SP+WRmPqvDONZmRrLhiG4BmHQEywkTtsZEatn0R4Gs8SPl2IovyPxvdxUvDB7mdN7GL6GKeLcrZRenCaHiVXB1dsz28uLQ2gJzBAm+G4y2CTMcRzZ2LkzC/BdU70lOkhncKHZg8ywZOjPk0SL3MDYrBFNGGAmgueuZYjDFIR2kB8SG1qAwnalZX4/BTa1AN0zKL1msqtoCEhpAzxeqhC5lmec2lSg7jUCu3VID4OacaOT4z26aPSj7aQH8GrPs8IFIHVt/eOhI/Ok9+YHvNry6F0n0OL1Uw/vXqBEwZ00buJuZ3ftcnkx1bGtkFhpxwZ1qRICixxo52JexJl3y3pxNw8prDRY6/v4Xchza9A/XNgoYhx3xTc9FidmCnwz5GzTmqWWHKRSc/SoHa9yypqHTQXDYHQkRH5wnXt8fJZwGz5bwSkY+RMdNRa3DpoW+ZBdCmxrHlhiC61gRCILrWB0Fa6tHNZalldbqVNTyWHWy5iDKJOSQ/qtFCcJyatRFnQS5ec+XCtaVxgYIGTnKlDCMFqlbyfAcj5zeKjxOhYDbB9nlzwuVhox67tJb+K2NOZ0UTUK+KeqKKGqQbJs2XqlKYBylYqXwEg+ROXz+pRpA8b7Px5WgXx9F5my6lINdhm4gJY4LT8Ot3oMUAPkvP05NboVNMPEHF80HGFQMLjkiFyKxlY1MoVyIe5Av7PuILV8g22DEYQzwgca0Pfa7NqgdeXstBt6NHToMyfB/Ov2VhGI/jMkTYMig//YBo/iA/WY3xMuk+VVzVhUal/QFwcE02g3myJIme/JwAJELw6vQkHsuwc1gYPREo0tEV2fa9zdITvu8kGn4FiIfigWCh4iTGFppQD9n5pETOT7qYSQ8hYgsD3aqPpNMm9nWnK5Fb7u+8YY3vFH0uhHpdciXmtb4QN5c4eptPkGOjsmOk6btOtHaOfWxhaR15v6c+nNoaDNm3ZD1grN+9FDduMHr//ljvz6EetOqo9kn/dgZCagDYTR6366hdOwRfQZmKvFQX4/0QBbhUI+LJXV2Bbysk5SwsUtlHmbePIsPbw5gLT0kNAmz6Usa4+0OameMDg6JER/LIXIKwbaQIfTsDImd2g9ZIDbV5yCMJWPXradY/e/v1Wqzb9Sa/VMazbNUTph3XBSAcVSx9dsKChIXrcliQNFQkB9E8bkUB9B8d9IEHURtp+wAd7Rr8PvVYz+oV/b/g7JPRD3ErX0cvehvynnQIdUFXOHB98KTxASazzrj43eZTZ6uFRx/6nq/J2Lj/9o0txfbBcVlPrAOm0UWzyHWPEpwFmGK/X/wKyRXMh

vanilla blueprint with only nixie tubes mod

Code: Select all

0eNrVWsuOozgU/ZWR19CDHwES9axq27uu3aiFCDgVS7xkTKmiUv59DHnRYINNJVU9m4og5tice+851069g23W0IqzQoDNO2BJWdRg8+87qNlLEWftPXGoKNgAJmgOHFDEeXtVsDdGXdFsKTg6gBUpfQMbeHRmHxQ8Luqq5MLd0kz0HkYGD+/iWrhaBGyAQN8qTutaD0KOvxxAC8EEoycmuotDVDT5lnL5klesOo+zzKUZTQRniVuVGZUTVWUtny2LdgkSzyUOOMgPuTggyS3kYNZx/A5g+4fTtD8Lk1fr9j1613B9/HU89m5eloJU4dCuAH5bqUCwGQieBCFmIGgSZKUAcTuSx1DeCQmpcHyzxcDbYrrQCF5m0Zbu41dW8nZQwnjSMBHJ79LrkzvGaxHNZBnjZeFWWSy66mhrSsRtgXntRV7FPBbtFOAfcDRPC+hr0iCw4A1eePusV4aQfOilQ81LhzpFGQd6fQ60nDVl/DTpWW8GoGtz0FANOk0rLeJtRqOU1e0n2OzirKbO9WtO4zTax0Xa8i/k2iQ1gje9EZf7p6F5mUoQz4LNgbIgpGEXeuZMBMb0wqF2ZnFeKRBXF0QVhpXoeWqlgdhGr3QgxEY5dSA30bvUjCurZcuKrlp0umeWdjuWCcqN/Hzsh0nZdPVr5e5DFRhAdOmmIMFKsb0HCHZSVhXld5dsf1hv4eAGRrfa7gbo6jGw9kZPiRNae4X3iWQj8iG6gyG7UEfnTejrZisn79Y/IgB9OyvRNeWWiOwwxrpFIc9IHcMJcURwslXWWaOBdCNkiRwqkf9sexw23kQbKmzJRmDMM7GxN6Q2FbSysTcdiG9jbzqQYIm93d3dNPvGRRY3Vi8zk0OhjcmhB5hcLSjNPm9bgtbWnqXczmEzXUQTCNDa9dDnsR+s/A/ukAaqRcx6CnyT9JQmLJVJPVWa5GyGg+L01TydEW881RNEvTIumjjrcdWNcJ/m0tQBZSOqxgKSvlJ+EHtWvJywq0PUFXC042UesUKCnUzFIgLjJm58fuOAF05pMXoUj3sDByDDiYadBhz2myp4ZSrgRamAviwV4P8mFbSRn4nlsIqnM0M1WhloYufH/rXkrR1YR/uzhfPqMH70MLDveb95rzpY6iCEhrStrOrD71l4rz7IA+vj+f5S+TRRFl1nblMX4diTrLJZU0XGee9bdACXZl2FY7MPDyeLx6aT0IXo5+9RJ/gjjQReG/YNoVUxBF9UDDVtMSJbTemx931B0Tzf0UtCYy8h021DOG01rbpNfr82LLJbwx9zJvY5FSyZzI1wZq9zg7mrOvpSHku5iTsd+2zA3wsCLUvvYfqHAw3DxJv7IVN3xIPnjx4ItAcPleB/9imP9kcPguwJCIzZxUtOQvC9T0L0v38vOgwZbWrNzkIIWbTfwF+230B3sIZH7DfGe/3pDSCakX5ksVOdRbLq8JQn93IxXb5tev+l4oAsljkr7z3vedm87CVvfz21RNI2dSTJ9Sk7CEEr7EMCZSf3H3155Ds=

the above setup is easy to expand for more belts and input types: just connect more "pulsed belt sensors" to the red wire 1, and add more nixie tubes for additional types at outputs 2 and 3.
the setup also should be easy to expand to show more intervals by adding pairs of combinators like F and G. each additional pair (and corresponding nixies or lamps) can then be used to show a history of the last xx minutes (or other intervalls, set by L)

[vanatteveldt]

A basic setup requires 3 combinators, in this version there's a constant combinator for configuration and another one to scale the output value for display.

avg_new = avg_old - (avg_old / n) + (input / n)

The average is kept in a register. You then take (avg / -n) in one combinator (this one reads from and feeds back into the register) and (input / n) in another (that's the input from the belt into the register).

Cool! Do you think you can provide the settings in text form or post a vanilla blueprint string (0.15)? That'd be awesome.

I concur!

I wanted to understand / blueprint it as well, so I duplicated it and describe the settings here:
viewtopic.php?f=193&t=51471

[Labor3]

Hello everyone,

i edited Ansons circuit a bit. Now you can use it to limit the belt throughtput of items. or maybe you already know and use it. ^^
all i had to do is to set the connected belt on enable/disable too, choose the item and the amout... in my base it now limits the througput of all science items to 1k per minute.

Thanks Anson for your build! ^^

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

[cid0rz]

Hi all,

Since this thread is older than this other one I think i may present here (very humbled and scared by the raycasting engine :S) my flowmeter with scrolling display. Basically is a sum of ideas taken from many places. I started with a basic design then tuned to two final variations:

- instant flowmeter - the number displayed is the estimation in items/min that are passing through that belt every time the flowmeter measures. A standard value I used to check is every 10 seconds (or 600 ticks).

- flowmeter with average - You need to wait for the 16 ticks of the graph to complete to get a correct average of the items passing through the belt also in itemps per minute. The displayed average is weighted, 50% is the current value and 50% is the average of the last 16 values.

In both cases the scrolling display prints the current instantaneous value (or a mask of it for the averaged) in a graphical way every time flowmeter reads. The display scrolls right to left

Here is a pic of both reading:

image

flowmeters.jpg (218.34 KiB) Viewed 38877 times

I've tested many versions across the factory, in these ones the upper number is just a total thousands counter, not to be confused:

image

20190424021734_1.jpg (826.13 KiB) Viewed 38877 times

20190429151908_1.jpg (889.63 KiB) Viewed 38877 times

Configuration:

There are two combinators to set in the flowmeter:

-signal P, is the measuring interval (should be set between 200 and 3600) I recommend P=600 which measures every 10 seconds. (WARNING when setting P in operation bad readings are expected and the average won't be valid until these results are discarded)
-signal W, is the Y scale of the graph. Set it for slightly below the designed output. (if you designed for 500/min, set W=450 for example, for a full belt W=2600 is a good value) the arithmetic combinators on the right part that operate on W scale the W setting so lamps turn on from the uppermost when flow is 120% than W, next when 100% is reached, next 80, ... til the last one 10%. That is a simplified explanation. I removed some combinators where i could but i didn't push too much since I'm not a specialist. If you improve the design i'd happy to see. Also if you have suggestions or feedback please let me know.

And finally the prints to test:

Instant:

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

Copy blueprint

and with average:

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

Copy blueprint

The prints come with a looping belt, only red signal is needed from the belt reading in pulse mode. If 65electronic circuits are placed on that belt, first filling the inner lane and then the rest on the outer you should get a measure similar to the 2k shown in the firs screenshot.

The digits used are:
viewtopic.php?f=193&t=19825&start=60#p282391
(but with use colors on so it's dimmed, i dont use night vision btw)