Factorio Multi Assembler

Post pictures and videos of your factories.
If possible, please post also the blueprints/maps of your creations!
For art/design etc. you can go to Fan Art.

Post Reply
binary101010
Manual Inserter
Manual Inserter
Posts: 1
Joined: Tue May 19, 2020 7:47 pm
Contact:

Factorio Multi Assembler

Post by binary101010 »

What do you want this factory to produce? Yes.
tl;dr;
I wanted to tinker around with the microcontroller mod and i "hate" the pre robotics gameplay when it comes to non bulk recipes (laser turrets, production buildings, specialized ammo...), handcrafting is slow, automation is tedious - so i engineered an factory design to produce virtually any recipe dynamically.
Demo
The production queue can be seen on right with Q being the number of recipes queued at the moment.

How does it work?
This screenshot provides an overview of the mostly vanilla proof of concept, only the microcontroller mod and the recipe combinator mod are required here.

Image

Resource provider
Source of raw resources (Iron, Wood...)

Multi Assembler
Dynamic assemblers with one microcontroller and two recipe combinators each, one reading the assemblers status, the other one setting the recipe delivered by the microcontroller, which in turn gets the recipe from the "wanted recipes" red signal network connecting the different subsystems.

Multi Assembler Microcontroller Code explained

Code: Select all

#
# This program manages the connected assemblers recipe based on the red signal network
#
# ### red signal input and output ###
# ----------------------------------------------------------------------
# The red signal network doubles as "assemblers working on recipe" and "recipes queued for production" network, this
# is achieved by using the most right digit (901 -> 1) as "should produce" flag with 1 indicating that the recipe 
# should be produced, and 0 indicating that the recipe should no longer be produced.
#
# The "assemblers working on recipe" part is achieved by adding 100 to the total number for each assembler working on the recipe.
# Any value in the red network with the exception of the "color red" signal can thus be described as
# (assemblersWorkingOnRecipe * 100 + shouldProduceThisRecipe) with shouldProduceThisRecipe being either 1 or 0.
#
# The "colour red" signal is defined as constant value of 9999 and must be present in order
# to reliably check the bottleneck state of an assembler.
# 
# Given the recipe set defined by the red signal network, the microcontroller will sort the signals
# and start producing the recipe with the lowest value,
# speak "least assemblers working on a given recipe".
#
# This rather modular approach allows for smarter logic to be defined
# when answering the big questions, aka what to produce with the given resources in which priority ect.
# without bloating the code of every single assembler


# ### green signal input ###
# ----------------------------------------------------------------------
# Required the bottleneck status of the connected assembler as input (colour green, yellow, red)

# ### green signal output ###
# ----------------------------------------------------------------------
# Same as red signal output, but should only be connected to the recipe combinator of the connected assembler


# Assembler instructions start here:

:reset # jump and entry point to reset the controller
clr mem1 mem2 mem3 mem4 out  # clear all registers, completely reset any temporary state
set 2000 mem3 # set mem3 to an high enough number for signal sorting, we want the smallest value, thus every queued recipe should initially be < 2000
bkr 1 # wait for at least one red signal, speak: "at least 1 recipe queued in the red recipe network"
:sort # jump point for queued recipes sorting loop
add 1 mem1  # increment loop counter
mov red@1 mem2 # remember the red signal, speak: "what is being produced in red signal at index(counter)"
tnq mem2 0 # check if the loop is finished, speak: "no more input found in red signal at index(counter)"
jmp :sorted # if the loop was finished in the prev step, we are done sorting, thus jump to :sorted
mov mem1 mem4 # now doing the actual sorting, mov mem1 to mem4, speak: "remember the loopCounter because otherwise it will be overwritten"
mov mem2 mem1 # mov our current red signal (what is being produced) to mem1
dig 1 # read the last character of the current recipe (eg. 301 -> 1), this value doubles as an "should produce (true|false)" flag  
swp mem1 mem4 # restore loop counter
teq mem4 1 # check if the current recipe should still be produced ("should produce" = 1)
jmp :sort # current recipe no longer wanted, sort next entry
tlt mem3 mem2 # do the actual sorting test
mov mem2 mem3 # checked value was smaller than cached value -> update cached value with new smallest value
jmp :sort # repeat sort for next entry
:sorted # everything sorted from here
set 100 mem3 # add 100 to lowest recipe, thus indicating that one more assembler is working on this recipe
mov mem3 out # mov the 100 x recipe to the output register, and thus updating the red currently produced network and starting the production in the current assembler, the production network count of each recipe can be defined as (assemblersWorkingOnRecipe*100+shouldProduceFlag) 
:probe # keep probing unti the currently set recipe is no longer wanted, this is essentially a "do while"
slp 180 # provide the assembler with 180 ticks of time to start the production as inserters need some time to insert the materials
mov green1 mem2 # rembember the current status of the green signal (bottleneck status)
fir mem2 # lookup the bottleneck state in the red signal network where the "color red" signal is propagated as an constant value
tnq mem1 9999 # check if the exact and known constant value was found in the red signal network
jmp :reset # red color constant was found, thus indicating that the current assembler status is "red - cannot produce" -> jump to reset and seek next recipe
fir mem3 # lookup the current recipe in the production network
dig 1 # again read the flag indicating if this recipe should still be produced
teq mem1 1 # check if the recipe should still be produced
jmp :reset # flag is 0, recipe should no longer be produced -> jump to reset and seek new recipe
jmp :probe # flag is 1, keep probing until this state changes
Possible improvements / features
  • Avoid the "180 tick do while" and react to events instead, eg. inserter read hand content
  • Invert the sorting logic, removing the "set 2000" part in the code and making the red assembler network semantically more logical "the higher the signal the more i want this recipe"
Quirks and remarks
  • An mostly vanilla build as shown in the PoC above is not feasible for larger quantities, but should be possible if combined with techniques like sushi belting and increasing the initial delay of the "do while". This is not covered in the demo map as i am using the warehouse mod to work around this.


Recipe Logic
Defines what recipes can be produced based on the given resources and the recipes configured in the "production targets" constant combinators.
In essence this subsystem will emit a constant signal of "1" for each recipe which a.) should and b.) can be produced to the red multi assembler network.

At the moment this subsystem is rather basic and can be improved upon (see quirks and remarks).

Recipe Logic Microcontroller Code (TOP) explained

Code: Select all

#
# This program removes recipes that are present in the red assembler network, but are not longer wanted because the production target is hit.
#
# ### red signal input and output ###
# ----------------------------------------------------------------------
# The red signal is connected to the recipe "cache" of the recipe logic subsystem.
# The cache contains the currently set recipes for production
# If the subsystem gets stuck for whatever reason, simply reset the cache combinator

# ### green signal input
# ----------------------------------------------------------------------
# The green signal represents an set of recipes that are wanted for production because the production target is not yet hit.

:reset # reset and entry point
clr mem1 mem2 mem3 mem4 out # reset all registers and temporary states
set 1 mem1 # avoid 0 black signal when reading red@1
:loop # jump point to iterate over the input set
clr mem2 mem3 mem4 # clear iteration states
mov red@1 mem2 # read the cached recipe at the current iteration
add 1 mem1 # increment the loop counter
tnq mem2 0 # check if there are more recipes in the cache set
jmp :reset # no more recipes, loop finished jump to program entry point
swp mem1 mem4 # move iteration register to mem4 as mem1 gets overriden 
mov mem2 mem1 # copy type of mem2 to mem1, so that the type of recipe matches and not just the quantity
fig mem2 # lookup the iteration recipe in the green input
swp mem1 mem4 # restore iteration variables
slp 60 # wait 60 ticks just because the endless loop combinator sound is nerv wrecking 
teq mem4 0 # check if the recipe is still a production target
jmp :loop # yes it is, check the next recipe in the cache
swp mem1 mem4 # no it is not, move iteration register to mem4 as mem1 gets overriden
mov mem2 mem1 # move mem2 to mem1 to once again make sure that the types match and not just the quantity 
set 1 mem2 # set mem2 to one, so we have an known quantity
sub mem2 2 # substract two of mem2, giving us a minus one signal
mov mem1 out # emit the minus one signal in order to remove the recipe from the cache
clr out # stop emitting minus values instantly or the cache will cache minus values
swp mem1 mem4 # restore iteration counter
jmp :loop # check next recipe
Recipe Logic Microcontroller Code (BOTTOM) explained

Code: Select all

#
# This program checks if the given recipe can be produced based on the resources in stock
#
# ### red signal input ###
# ----------------------------------------------------------------------
# Receives the "color red" signal if any resource of the currently checked recipe is not available

# ### red signal output ###
# ----------------------------------------------------------------------
# Emits the currently checked recipe to an recipe combinator in order to check its ingredients

# ### green signal input
# ----------------------------------------------------------------------
# The green signal represents an set of recipes that are wanted for production because the production target is not yet hit.

# ### green signal output
# ----------------------------------------------------------------------
# Same as red signal output, but will emit the value to the recipe cache only

:reset # entry and reset jump point
clr mem1 mem2 mem3 mem4 out # clear all registers and temporary states
set 1 mem1 # avoid 0 black signal when reading input
:loop # iteration jump point
bkg 1 # wait for any input on the red wire
clr mem2 mem3 mem4 out # clear all registers and temporary states
mov green@1 mem2 # read "wanted recipe" at current iteration position
tnq mem2 0 # check if we finished iterating
jmp :reset # iteration finished, restart program
mov mem2 out # mov current recipe to output
slp 90 # wait 90 ticks for the surrounding combinators to finish their calculation wheter or not the recipe is missing resources 
mov red1 mem3 # read the "red color resource missing" signal
add 1 mem1 # increment loop counter
teq mem3 0 # check if the current recipe can be produced
jmp :loop # it cannot be produces (red color > 0), move to the next recipe
set 2 mem2  # set the recipe amount to two, this is the predefined value which will be relayed to the cache, other values are ignored by the cache
mov mem2 out # outputs the current recipe to the cache
nop # wait one extra tick as this signal needs to pass trough an additional combinator
clr out # clear the output
jmp :loop # check next recipe
Possible improvements / features
  • Add configurable recipe priorities aka "I want laser turrets before walls, and belts before everything else"
  • Better recipe priorities based on recipe complexity / production targets, "I want 5 assemblers to produce cables needed in bulk for circuits, while i only want one assembler at max producing power armor"
  • Possible solution: Calculate the priority based on the distance to the production target. The higher the difference between production target and in stock items, the lower the signal to the red multi assembler network.
Quirks and remarks
  • If intermediate products go missing or cannot be produced (say you manually provide blue circuits, and remove them again after an recipe with blue circuits was added to the production queue), the recipe will be stuck indefinitely in the production queue. In order to solve this, simply reset the cache combinator of this subsystem.
  • Items with large stack sizes may lead to problems if the steel chest contains less than (number of assemblers * item stack size + 1). That's because the assemblers will "eat up" all the resources of the steel chest, which in turn leads to the system thinking no resources of this type are available, and thus aborting the production.
  • Slow raw resource input or intermediate recipe production will lead to an slow flipping binary state of "I can produce this higher tier recipe" and "I no longer have enough resources for this recipe", ultimately this is a resource input problem, but it could be handled in a more graceful way for other queued recipes.
  • Depending on the setup, production targets are not hit exactly because of an production target evaluation delay when checking if the recipe should still be produced, in some cases this leads to overproduction.
Production Target Constant Combinators
Add the recipes you want the Multi Assembler to produce here. The quantity defines the production target.

Missing Resource Indicator
Will flash red if any resources required to produce an recipe are missing in the steel chest of the multi assembler.
The missing resources are shown as positive values in the combinator to the right of the flashing light.

Production Queue Visualizer
Optional component, simply visualizes the amount of the currently queued recipes.
Download
Demo Map, Tested with version 0.18.21
https://1drv.ms/u/s!AnCArPA4VxPUi324cxr ... y?e=VNwHGp (Microsoft OneDrive)

PoC Vanilla Blueprint

Code: Select all

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
Warehouse Version aka "Basar mk1" Blueprint

Code: Select all

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
Raw multi assembler code (sadly not part of the blue print)

Code: Select all

:reset
clr mem1 mem2 mem3 mem4 out
set 2000 mem3
bkr 1
:sort
add 1 mem1
mov red@1 mem2
tnq mem2 0
jmp :sorted
mov mem1 mem4
mov mem2 mem1
dig 1
swp mem1 mem4
teq mem4 1
jmp :sort
tlt mem3 mem2
mov mem2 mem3
jmp :sort
:sorted
set 100 mem3
mov mem3 out
:probe
slp 180
mov green1 mem2
fir mem2
tnq mem1 9999
jmp :reset
fir mem3
dig 1
teq mem1 1
jmp :reset
jmp :probe
Raw recipe logic assembler code top (sadly not part of the blue print)

Code: Select all

:reset
clr mem1 mem2 mem3 mem4 out
set 1 mem1
:loop
clr mem2 mem3 mem4
mov red@1 mem2
add 1 mem1
tnq mem2 0
jmp :reset
swp mem1 mem4
mov mem2 mem1
fig mem2
swp mem1 mem4
slp 60
teq mem4 0
jmp :loop
swp mem1 mem4
mov mem2 mem1
set 1 mem2
sub mem2 2
mov mem1 out
clr out
swp mem1 mem4
jmp :loop

Raw recipe logic assembler code bottom (sadly not part of the blue print)

Code: Select all

:reset
clr mem1 mem2 mem3 mem4 out
set 1 mem1
:loop
bkg 1
clr mem2 mem3 mem4 out
mov green@1 mem2
tnq mem2 0
jmp :reset
mov mem2 out
slp 90
mov red1 mem3
add 1 mem1
teq mem3 0
jmp :loop
set 2 mem2 
mov mem2 out
nop
clr out
jmp :loop


PS: I am not a native speaker, if you need clarification on some parts feel free to ask.

The design was made possible by the following mods:

extermeon
Burner Inserter
Burner Inserter
Posts: 6
Joined: Thu May 18, 2017 7:44 pm
Contact:

Re: Factorio Multi Assembler

Post by extermeon »

Great work! How about version for a fCPU? :)

Post Reply

Return to “Show your Creations”

Who is online

Users browsing this forum: No registered users