Stationeers Community Wiki - User contributions [en]

Furnace

2026-03-06T04:00:36Z

TK421: restore previous mention of being able to simply using a furnace to melt ice

<languages/>
<translate>

[[Category:Machines]]
{{Itembox
| name = Kit (Furnace)
| image = [[File:ItemKitFurnace.png]]
| recipe_machine1 = Autolathe
| recipe_cost1 = 30g [[Special:MyLanguage/Iron|Iron]], 10g [[Special:MyLanguage/Copper|Copper]]
| recipe_machine2 = Fabricator
| recipe_cost2 = 30g [[Special:MyLanguage/Iron|Iron]], 10g [[Special:MyLanguage/Copper|Copper]]
| volume = 1000 L


}}

''This article is about the basic furnace. For the advanced version, see [[Advanced Furnace]].
{{Structurebox
| name = Furnace
| image = [[File:Furnace.jpg]]
| prefab_hash = 1947944864
| prefab_name = StructureFurnace
| placed_with_item = [[Kit (Furnace)]]
| placed_on_grid = Small Grid
| const_with_tool1 = [[Wrench]]
| const_with_item1 = 2x [[Iron Sheets]]
| decon_with_tool1 = [[Crowbar]]
| item_rec1 = [[Kit (Furnace)]]
| const_with_tool2 = [[Welding Torch]]
| const_with_item2 = 2x [[Iron Sheets]]
| decon_with_tool2 = [[Special:MyLanguage/Crowbar|Crowbar]]
| item_rec2 = 2x [[Iron Sheets]]
| decon_with_tool3 = [[Angle Grinder]]
| item_rec3 = 2x [[Iron Sheets|Iron Sheets]]
}}

== Description == 
The <b>Furnace</b> is used to smelt [[Ore|ore]] into ingots and alloys using an oxygen/volatile gas mix. [[Special:MyLanguage/Ice (Oxite)|Ice (Oxite)]] and [[Special:MyLanguage/Ice (Volatiles)|Ice (Volatiles)]] can be manually input directly in the furnace in order to create crude gas mixtures, or to be directly extracted as an easy trick for melting ice.

It features a gas pipe input port (connected to its internal storage through an internal always-open [[One_Way_Valve_(Gas)|one-way valve]]), a gas pipe output port (which lacks a one-way valve and acts as a bidirectional gas port), and a liquid output port (which acts as an always-open [[Condensation_Valve|condensation valve]]).


If the contents of the furnace are ejected without reaching the required temperature and pressure for smelting, they'll come out as [[Special:MyLanguage/Reagent Mix|Reagent Mix]] which can be processed in a [[Special:MyLanguage/Centrifuge|Centrifuge]] to recover the raw ores. [[Special:MyLanguage/Reagent Mix|Reagent Mix]] can also be re-smelted if the ingredients and ratios are a valid alloy recipe. This allows an intermission when the resources for reaching the required temperature / pressure are not on hand / need to be gathered first. Effectively, this means that the used metals can be 'reserved' for the intended alloy.

The Furnace can be used to smelt basic ores and simpler alloys, but an [[Advanced Furnace]] will be required for the more complex alloys.

An [[Arc Furnace]] (included in the starting gear) is required to make the metals for manufacturing a Furnace. By comparison, the Furnace can do everything the Arc Furnace can do, but without using electricity, and far more efficiently.

'''Danger''': The furnace is '''not insulated''', so it interacts with the surrounding atmosphere and can heat rooms to dangerous levels within minutes.


All the alloys the furnace can smelt are easily achieved with ice, and they can also be smelted using gases fed into the furnace through the pipe inputs. Regardless of which method is used the furnace gases must be purged thru a working piping setup (a valve and passive vent at bare minimum to vent the internal gasses).

 Gaseous fuel can be premixed and fed into the furnace. This can be done either by feeding Volatile ices and Oxite ices in an Ice Crusher in the correct ratio to produce [[Fuel#Basic_Ice_Crusher_Setup|fuel]]. The optimal gas mix that burns completely is 1 part (33.3%) oxygen to 2 parts (66.6%) volatiles, other mixes could also work but leave either leftover oxygen or volatiles depending on the percentages used. <br> Alternately you could separate the gases into tanks using atmospheric units and pipe individual gases through a mixer and a [[Special:MyLanguage/Pressure Regulator|Pressure Regulator]] or a [[Special:MyLanguage/Pipe Volume Pump|Pipe Volume Pump]] connected to the furnace input. The Furnace's output can also be extracted and vented/recycled through a backpressure regulator to maintain furnace pressure. Adding additional gases to the furnace can result in lower temperature if that is desired, but you could also use a volume pump with a lower fuel input setting.


'''Make sure to put the fuel in first, then press the activate button. Afterwards put in the ingredients and press the handle after you see the "will produce" while hovering over the furnace.''' Also, You MUST put in exact amounts matching the recipe amounts. For instance, you must put in 12 iron and 4 coal to make 16 steel. You cannot put in 12 iron and 7 coal. The furnace will not manufacture anything if the ingredient ratios are not correct and you will have to eject it all or add resources to balance the recipe.

== Required conditions for smelting == 
The following table shows the pressure and temperature conditions required to smelt various ores and alloys.
{{:Furnace/Recipes}}

===Alloy recipes=== 
====Ice only recipes====

The ices should be loaded into the furnace and ignited, and then the ores should be loaded immediately after. No wait time is necessary. '''Make sure to put the fuel in first, then press the activate button. Afterwards put in the ingredients and wait for the button to turn green again, or until you see the "will produce" while hovering over the furnace.''' Then pull the handle and your alloy will be ejected.

<div style="overflow-x: auto;">
{| class="wikitable"
<div style="overflow-x: auto;">
{| class="wikitable"
|-
! colspan="1" rowspan="1" |Ice Chunks
! colspan="1" rowspan="1" |Ingredients
! colspan="1" rowspan="1" |Temperature
! colspan="1" rowspan="1" |Pressure
! colspan="1" rowspan="1" |Alloy
|-
|<div class="stationeers-icon">[[File:ItemVolatiles.png|link=Ice_(Volatiles)]] <div class="stationeers-icon-text">2</div></div>'''[[Ice_(Volatiles)|Volatiles]]''' <br> <div class="stationeers-icon">[[File:ItemOxite.png|link=Ice_(Oxite)]] <div class="stationeers-icon-text">1</div></div>'''[[Ice_(Oxite)|Oxite]]'''
|<div class="stationeers-icon">[[File:ItemIronOre.png|link=Ore (Iron)]] <div class="stationeers-icon-text">75</div> </div> '''[[Ore (Iron)|Iron Ore]]''' <br> <div class="stationeers-icon">[[File:ItemCoalOre.png|link=Ore (Coal)]] <div class="stationeers-icon-text">25</div></div> '''[[Ore (Coal)|Coal]]'''
|1.05 kK
|6.2 MPa
|<div class="stationeers-icon">[[File:ItemSteelIngot.png|link=Ingot (Steel)]] <div class="stationeers-icon-text">100</div></div>'''[[Ingot (Steel)|Steel]]'''
|-
|<div class="stationeers-icon">[[File:ItemVolatiles.png|link=Ice_(Volatiles)]] <div class="stationeers-icon-text">12</div></div>'''[[Ice_(Volatiles)|Volatiles]]'''<br> <div class="stationeers-icon">[[File:ItemOxite.png|link=Ice_(Oxite)]] <div class="stationeers-icon-text">6</div></div>'''[[Ice_(Oxite)|Oxite]]'''
|<div class="stationeers-icon">[[File:ItemCopperOre.png|link=Ore (Copper)]] <div class="stationeers-icon-text">50</div></div> '''[[Ore (Copper)|Copper Ore]]''' <br> <div class="stationeers-icon">[[File:ItemNickelOre.png|link=Ore (Nickel)]] <div class="stationeers-icon-text">50</div></div> '''[[Ore (Nickel)|Nickel Ore]]'''
|1.81 kK
|21 MPa
|<div class="stationeers-icon">[[File:ItemConstantanIngot.png|link=Ingot (Constantan)]] <div class="stationeers-icon-text">100</div></div>'''[[Ingot (Constantan)|Constantan]]'''
|-
|<div class="stationeers-icon">[[File:ItemVolatiles.png|link=Ice_(Volatiles)]] <div class="stationeers-icon-text">8</div></div>'''[[Ice_(Volatiles)|Volatiles]]'''<br> <div class="stationeers-icon">[[File:ItemOxite.png|link=Ice_(Oxite)]] <div class="stationeers-icon-text">24</div></div>'''[[Ice_(Oxite)|Oxite]]'''
|<div class="stationeers-icon">[[File:ItemNickelOre.png|link=Ore (Nickel)]] <div class="stationeers-icon-text">50</div></div> '''[[Ore (Nickel)|Nickel Ore]]''' <br> <div class="stationeers-icon">[[File:ItemIronOre.png|link=Ore (Iron)]] <div class="stationeers-icon-text">50</div></div> '''[[Ore (Iron)|Iron Ore]]'''
|1.5 kK
|19 MPa
|<div class="stationeers-icon">[[File:ItemInvarIngot.png|link=Ingot (Invar)]] <div class="stationeers-icon-text">100</div></div>'''[[Ingot (Invar)|Invar]]'''
|-
|<div class="stationeers-icon">[[File:ItemVolatiles.png|link=Ice_(Volatiles)]] <div class="stationeers-icon-text">3</div></div>'''[[Ice_(Volatiles)|Volatiles]]'''<br> <div class="stationeers-icon">[[File:ItemNitrice.png|link=Ice_(Nitrice)]] <div class="stationeers-icon-text">30</div></div>'''[[Ice_(Nitrice)|Nitrice]]'''
|<div class="stationeers-icon">[[File:ItemNickelOre.png|link=Ore (Nickel)]] <div class="stationeers-icon-text">150</div></div> '''[[Ore (Nickel)|Nickel Ore]]''' <br> <div class="stationeers-icon">[[File:ItemIronOre.png|link=Ore (Iron)]] <div class="stationeers-icon-text">150</div></div> '''[[Ore (Iron)|Iron Ore]]'''
|1.32 kK
|18.6 MPa
|<div class="stationeers-icon">[[File:ItemInvarIngot.png|link=Ingot (Invar)]] <div class="stationeers-icon-text">300</div></div>'''[[Ingot (Invar)|Invar]]'''
|-
|<div class="stationeers-icon">[[File:ItemVolatiles.png|link=Ice_(Volatiles)]] <div class="stationeers-icon-text">1</div></div>'''[[Ice_(Volatiles)|Volatiles]]''' <br> <div class="stationeers-icon">[[File:ItemOxite.png|link=Ice_(Oxite)]] <div class="stationeers-icon-text">1</div></div>'''[[Ice_(Oxite)|Oxite]]'''
|<div class="stationeers-icon">[[File:ItemSilverIngot.png|link=Ingot (Silver)]] <div class="stationeers-icon-text">50</div></div>'''[[Ingot (Silver)|Silver Ingot]] ***''' <br> <div class="stationeers-icon">[[File:ItemGoldIngot.png|link=Ingot (Gold)]] <div class="stationeers-icon-text">50</div></div>'''[[Ingot (Gold)|Gold Ingot]] ***'''
|997 K
|1.1 MPa
|<div class="stationeers-icon">[[File:ItemElectrumIngot.png|link=Ingot (Electrum)]] <div class="stationeers-icon-text">100</div></div>'''[[Ingot (Electrum)|Electrum]]'''
|-
|<div class="stationeers-icon">[[File:ItemVolatiles.png|link=Ice_(Volatiles)]] <div class="stationeers-icon-text">1</div></div>'''[[Ice_(Volatiles)|Volatiles]]''' <br> <div class="stationeers-icon">[[File:ItemNitrice.png|link=Ice_(Nitrice)]] <div class="stationeers-icon-text">2</div></div>'''[[Ice_(Nitrice)|Nitrice]]''' <br> <div class="stationeers-icon">[[File:ItemIce.png|link=Ice_(Water)]] <div class="stationeers-icon-text">3</div></div>'''[[Ice_(Water)|Water Ice]]'''
|<div class="stationeers-icon">[[File:ItemLeadIngot.png|link=Ingot (Lead)]] <div class="stationeers-icon-text">50</div></div>'''[[Ingot (Lead)|Lead Ingot]] ***''' <br> <div class="stationeers-icon">[[File:ItemIronOre.png|link=Ore (Iron)]] <div class="stationeers-icon-text">50</div></div> '''[[Ore (Iron)|Iron Ore]]'''
|528 K
|1.16 MPa
| <div class="stationeers-icon">[[File:ItemSolderIngot.png|link=Ingot (Solder)]] <div class="stationeers-icon-text">100</div></div>'''[[Ingot (Solder)|Solder]]'''
|}
</div>
'''***''' Ingots are used instead of raw ores to prevent the production of extra gases when making these recipes
</div>

====Gaseous Fuel Recipes====
[[File:ICE_CRUSHER.png|thumb|'''A basic [[Fuel#Basic_Ice_Crusher_Setup|ice crushing]], gas collection and measuring setup''']]
In this setup fuel is pumped into the furnace from either pre-measured canisters or pumped into the furnace in measured amounts. Fuel is a 2:1 Volatile to O2 mixture, a close approximtion of this ratio can be obtained from the raw gases produced when 2 Volatile and 1 Oxite ices are put into an Ice crusher, or by melting the gases in an enclosed area and pumping the gases into a canister with an active vent. Raw gasses made from ices will have a ratio of 3.6% Nitrogen, 32.7% Oxygen, and 63.7% Volatiles, and the Volatile to Oxygen ratio will be 1.95:1 instead of 2:1, but it will burn adequately well. <br> The gas should be pumped into the furnace and ignited; the ores should be placed in the furnace as soon as the gases are ignited. It is not necessary to wait for the furnace to come up to temperature. '''Make sure to put the fuel in first, then press the activate button. Afterwards put in the ingredients and wait for the button to turn green again, until you see the "will produce" while hovering over the furnace.''' Then pull the handle and your alloy will be ejected.
<div style="overflow-x: auto;">
{| class="wikitable"
! colspan="1" rowspan="1" |Canister Pressure @ 0°C
! colspan="1" rowspan="1" |Gases
! colspan="1" rowspan="1" |Ingredients
! colspan="1" rowspan="1" |Temperature
! colspan="1" rowspan="1" |Pressure
! colspan="1" rowspan="1" |Alloy
|-
|''' &ensp; &emsp;1,400 KPa''' <div class="stationeers-icon">[[File:ItemGasCanisterFuel.png|link=Fuel]] <div class="stationeers-icon-text"></div> </div> '''[[Fuel|Fuel]]''' <br> <br>
|<div class="stationeers-icon">[[File:Icon-volatiles.png|link=Volatiles]] <div class="stationeers-icon-text"></div></div>'''24 Mols''' '''[[Volatiles|Volatiles]]''' <br> <div class="stationeers-icon">[[File:Icon-oxygen.png|link=Oxygen]] <div class="stationeers-icon-text"></div></div>'''12.3 Mols''' '''[[Oxygen|Oxygen]]'''
|<div class="stationeers-icon">[[File:ItemIronOre.png|link=Ore (Iron)]] <div class="stationeers-icon-text">75</div> </div> '''[[Ore (Iron)|Iron Ore]]''' <br> <div class="stationeers-icon">[[File:ItemCoalOre.png|link=Ore (Coal)]] <div class="stationeers-icon-text">25</div></div> '''[[Ore (Coal)|Coal]]'''
|'''910 K'''
|'''4.63 MPa'''
|<div class="stationeers-icon">[[File:ItemSteelIngot.png|link=Ingot (Steel)]] <div class="stationeers-icon-text">100</div></div>'''[[Ingot (Steel)|Steel]]'''
|-
| ''' &emsp; &emsp; 160 KPa''' <div class="stationeers-icon">[[File:ItemGasCanisterFuel.png|link=Fuel]] <div class="stationeers-icon-text"></div> </div> '''[[Fuel|Fuel]]'''<br> <br>
|<div class="stationeers-icon">[[File:Icon-volatiles.png|link=Volatiles]] <div class="stationeers-icon-text"></div></div>'''2.8 Mols''' '''[[Volatiles|Volatiles]]''' <br> <div class="stationeers-icon">[[File:Icon-oxygen.png|link=Oxygen]] <div class="stationeers-icon-text"></div></div>'''1.43 Mols''' '''[[Oxygen|Oxygen]]'''
|<div class="stationeers-icon">[[File:ItemSilverOre.png|link=Ore_(Silver)]] <div class="stationeers-icon-text">50</div></div>'''[[Ore_(Silver)|Silver Ore]]''' <br> <div class="stationeers-icon">[[File:ItemGoldOre.png|link=Ore_(Gold)]] <div class="stationeers-icon-text">50</div></div>'''[[Ore_(Gold)|Gold Ore]]'''
|'''610 K'''
|'''1.39 MPa'''
|<div class="stationeers-icon">[[File:ItemElectrumIngot.png|link=Ingot (Electrum)]] <div class="stationeers-icon-text">100</div></div>'''[[Ingot (Electrum)|Electrum]]'''
|-
| '''&ensp; &emsp; &emsp; 30 KPa''' <div class="stationeers-icon">[[File:ItemGasCanisterFuel.png|link=Fuel]] <div class="stationeers-icon-text"></div> </div> '''[[Fuel|Fuel]]''' <br> <br>
|<div class="stationeers-icon">[[File:Icon-volatiles.png|link=Volatiles]] <div class="stationeers-icon-text"></div></div>'''0.516 Mols''' '''[[Volatiles|Volatiles]]''' <br> <div class="stationeers-icon">[[File:Icon-oxygen.png|link=Oxygen]] <div class="stationeers-icon-text"></div></div>'''0.264Mols''' '''[[Oxygen|Oxygen]]'''
|<div class="stationeers-icon">[[File:ItemLeadOre.png|link=Ore_(Lead)]] <div class="stationeers-icon-text">50</div></div>'''[[Ore_(Lead)|Lead Ore]]''' <br> <div class="stationeers-icon">[[File:ItemIronOre.png|link=Ore (Iron)]] <div class="stationeers-icon-text">50</div></div> '''[[Ore (Iron)|Iron Ore]]'''
|'''417 K'''
|'''1.09 MPa'''
| <div class="stationeers-icon">[[File:ItemSolderIngot.png|link=Ingot (Solder)]] <div class="stationeers-icon-text">100</div></div>'''[[Ingot (Solder)|Solder]]'''
|-
|'''(2x) 7,500 KPa''' <div class="stationeers-icon">[[File:ItemGasCanisterFuel.png|link=Fuel]] <div class="stationeers-icon-text"></div></div> '''[[Fuel|Fuel]]''' <br><br>'''
|<div class="stationeers-icon">[[File:Icon-volatiles.png|link=Volatiles]] <div class="stationeers-icon-text"></div></div>'''256 Mols''' '''[[Volatiles|Volatiles]]''' <br> <div class="stationeers-icon">[[File:Icon-oxygen.png|link=Oxygen]] <div class="stationeers-icon-text"></div></div>'''131 Mols''' '''[[Oxygen|Oxygen]]'''
|<div class="stationeers-icon">[[File:ItemCopperOre.png|link=Ore (Copper)]] <div class="stationeers-icon-text">50</div></div> '''[[Ore (Copper)|Copper Ore]]''' <br> <div class="stationeers-icon">[[File:ItemNickelOre.png|link=Ore (Nickel)]] <div class="stationeers-icon-text">50</div></div> '''[[Ore (Nickel)|Nickel Ore]]'''
|'''1.9 kK'''
|'''21.2 MPa'''
|<div class="stationeers-icon">[[File:ItemConstantanIngot.png|link=Ingot (Constantan)]] <div class="stationeers-icon-text">100</div></div>'''[[Ingot (Constantan)|Constantan]]'''
|-
|'''(2x) 6,000 KPa''' <div class="stationeers-icon">[[File:ItemGasCanisterFuel.png|link=Fuel]] <div class="stationeers-icon-text"></div></div> '''[[Fuel|Fuel]]'''</div> <br><br> <br> <br>'''(2x) 9,500 KPa'''<div class="stationeers-icon">[[File:ItemGasCanisterCarbonDioxide.png|link=Carbon_Dioxide]] <div class="stationeers-icon-text"></div></div>'''[[Carbon_Dioxide|Pressurant]]'''
|<div class="stationeers-icon">[[File:Icon-volatiles.png|link=Volatiles]] <div class="stationeers-icon-text"></div></div>'''205 Mols''' '''[[Volatiles|Volatiles]]''' <br> <div class="stationeers-icon">[[File:Icon-oxygen.png|link=Oxygen]] <div class="stationeers-icon-text"></div></div>'''105 Mols''' '''[[Oxygen|Oxygen]]''' <br> <br> <div class="stationeers-icon">[[File:ItemGasCanisterCarbonDioxide.png|link=Carbon_Dioxide]] <div class="stationeers-icon-text"></div></div>'''538 Mols''' '''[[Carbon_Dioxide|Pressurant]] ^^^'''
|<div class="stationeers-icon">[[File:ItemNickelOre.png|link=Ore (Nickel)]] <div class="stationeers-icon-text">50</div></div>'''[[Ore (Nickel)|Nickel Ore]]''' <br> <div class="stationeers-icon">[[File:ItemIronOre.png|link=Ore (Iron)]] <div class="stationeers-icon-text">50</div></div> '''[[Ore (Iron)|Iron Ore]]'''
|'''1.38 kK'''
|'''19 MPa'''
|<div class="stationeers-icon">[[File:ItemInvarIngot.png|link=Ingot (Invar)]] <div class="stationeers-icon-text">100</div></div>'''[[Ingot (Invar)|Invar]]'''
|}

'''^^^'''These recipes use CO2 @ 0°C as a pressurant. Other pressurants such as Nitrogen, Pollutants, and Oxygen are possible, but they may result in different outcomes.

=== Tips === 
*Placing 15 ice(volatiles) and 15 ice(oxite) will bring pressure to around 22000kpa and temp 2000k. For Invar, you will have to wait for the temperature to drop before you can process. You can use this time while the pressure is still over 20000kpa to make constantan. <br />
*All other alloys can be achieved with a ratio of 2 volatiles to 1 oxite
*If atmosphere inside and/or around furnace is too cold to melt ice one can press 'activate' button to manually melt one ice per ignition attempt. You will need to press the ignition button for each piece of ice from the first stack that you put in. Until all solid matter was melted the import slot will remain blocked.
*[[Special:MyLanguage/Reagent Mix|Reagent Mix]] can be re-melted to continue balancing the recipe should you need to gather more resources or find yourself unable to balance the temperature/pressure manually.
*On [[Vulcan]] the daytime temperatures allow smelting of many basic alloys right from the start by using an active vent, even high enough for [[Steel]]. This will save the very valuable, and limited oxygen of the player, especially on brutal start conditions.
*Placing 50 silver ore into an ignited furnace will produce 50 Mol of N2O inside the furnace, which can be further burned in the presence of volatiles resulting in a higher temperature after smelting. This will push the furnace temperature beyond what may be otherwise obtainable (early game daytime Vulcan, for example).

===Additional fuel mixes=== 


<div style="overflow-x: auto;">
{| class="wikitable"
! colspan="1" rowspan="2" |Prime
! colspan="1" rowspan="2" |FAR
! colspan="2" rowspan="1" |In: Mols
! colspan="3" rowspan="1" |Result
! colspan="4" rowspan="1" |Out: Mols
|-
!H2
!O2
!Press.
!Celcius
!Kelvin
!O2
!H2
!Co2
!X
|-
|100 kPa
|2:1
|29
|14
|2 135
|1 953
|2 216
|1
|3
|82
|33
|-
|200 kPa
|2:1
|59
|29
|4 500
|2 000
|2 273
|1
|5
|169
|80
|-
|200 kPa
|3:1
|65
|21
|3 400
|1 900
|2 173
|2
|26
|118
|52
|-
|200 kPa
|4:1
|72
|18
|3 000
|1 800
|2 273
|1
|40
|99
|42
|-
|200 kPa
|1:1
|43
|43
|3 493
|1 917
|2 190
|22
|2
|127
|59
|-
|200 kPa
|1:4
|17
|68
|1 646
|1 319
|1 592
|63
|2
|50
|18
|-
|300 kPa
|2:1
|86
|42
|6 850
|2 109
|2 382
|2
|7
|242
|115
|-
|902.7 kPa
|2:1
|263
|108
|19.25 MPa
|2 054
|2 357
|70
|7
|767
|151
|-
|1 MPa
|2:1
|291
|120
|21.62 MPa
|2 061
|2 334
|74
|7
|862
|170
|-
|1.497 MPa
|2:1
|408
|204
|35.34 MPa
|2 121
|2 394
|10
|20
|1163
|581
|}
</div>

===Ore Off-Gassing=== 
Ores being smelted release gases, unless they have been previously sent through a furnace or centrifuge. However both the centrifuge and arc furnace require additional time and energy to remove gases from ores, and the gases will be lost. These gases will increase pressure and lower temperature inside the furnace, but can also be beneficial to the smelting process. For example Solder, requires very little fuel to smelt due to the N20 released from the Lead Ore during smelting. Removing the N20 from the lead ore prior to smelting will result in the need for additional fuel to make up for it's loss.

'''CAUTION: As Vol is far more reactive with N2O and burns at a rate of 1:1, rather than 2:1 with O2, be cautious to not add additional volatiles after smelting silver or lead ores. Doing so could lead to rapid spikes in pressure and, not managed properly, could lead to a furnace exploding.'''


<div style="overflow-x: auto;">
{| class="wikitable"
! colspan="1" rowspan="2" |Ore
! colspan="6" rowspan="1" |Out: Mols
|-
| style="text-align:center;"| Vol
| style="text-align:center;"| X
| style="text-align:center;"| N2
| style="text-align:center;"| CO2
| style="text-align:center;"| O2
| style="text-align:center;"| N2O
|-
| <div class="stationeers-icon">[[File:ItemOrganicMaterial.png|link=Biomass]] <div class="stationeers-icon-text">1</div></div> [[Biomass|Biomass]]
| style="text-align:center;"| 8.0
| style="text-align:center;"| 4.0
| style="text-align:center;"| 0.0
| style="text-align:center;"| 0.0
| style="text-align:center;"| 0.0
| style="text-align:center;"| 0.0
|-
| <div class="stationeers-icon">[[File:ItemCoalOre.png|link=Ore (Coal)]] <div class="stationeers-icon-text">1</div></div> [[Ore (Coal)|Coal]]
| style="text-align:center;"| 0.0
| style="text-align:center;"| 3.0
| style="text-align:center;"| 0.0
| style="text-align:center;"| 10.0
| style="text-align:center;"| 0.0
| style="text-align:center;"| 0.0
|-
| <div class="stationeers-icon">[[File:ItemSiliconOre.png|link=Ore (Silicon)]] <div class="stationeers-icon-text">1</div></div> [[Ore (Silicon)|Silicon]]
| style="text-align:center;"| 0.0
| style="text-align:center;"| 1.0
| style="text-align:center;"| 1.0
| style="text-align:center;"| 1.0
| style="text-align:center;"| 0.0
| style="text-align:center;"| 0.0
|-
| <div class="stationeers-icon">[[File:ItemIronOre.png|link=Ore (Iron)]] <div class="stationeers-icon-text">1</div></div> [[Ore (Iron)|Iron]]
| style="text-align:center;"| 0.0
| style="text-align:center;"| 2.0
| style="text-align:center;"| 0.0
| style="text-align:center;"| 0.5
| style="text-align:center;"| 0.0
| style="text-align:center;"| 0.0
|-
| <div class="stationeers-icon">[[File:ItemGoldOre.png|link=Ore (Gold)]] <div class="stationeers-icon-text">1</div></div> [[Ore (Gold)|Gold]]
| style="text-align:center;"| 0.0
| style="text-align:center;"| 2.0
| style="text-align:center;"| 0.5
| style="text-align:center;"| 0.2
| style="text-align:center;"| 0.2
| style="text-align:center;"| 0.0
|-
| <div class="stationeers-icon">[[File:ItemCopperOre.png|link=Ore (Copper)]] <div class="stationeers-icon-text">1</div></div> [[Ore (Copper)|Copper]]
| style="text-align:center;"| 0.0
| style="text-align:center;"| 1.0
| style="text-align:center;"| 0.5
| style="text-align:center;"| 1.0
| style="text-align:center;"| 0.0
| style="text-align:center;"| 0.0
|-
| <div class="stationeers-icon">[[File:ItemSilverOre.png|link=Ore (Silver)]] <div class="stationeers-icon-text">1</div></div> [[Ore (Silver)|Silver]]
| style="text-align:center;"| 0.0
| style="text-align:center;"| 1.0
| style="text-align:center;"| 0.4
| style="text-align:center;"| 0.0
| style="text-align:center;"| 0.0
| style="text-align:center;"| 1.0
|-
| <div class="stationeers-icon">[[File:ItemLeadOre.png|link=Ore (Lead)]] <div class="stationeers-icon-text">1</div></div> [[Ore (Lead)|Lead]]
| style="text-align:center;"| 0.0
| style="text-align:center;"| 2.0
| style="text-align:center;"| 1.0
| style="text-align:center;"| 0.4
| style="text-align:center;"| 0.0
| style="text-align:center;"| 0.4
|-
| <div class="stationeers-icon">[[File:ItemNickelOre.png|link=Ore (Nickel)]] <div class="stationeers-icon-text">1</div></div> [[Ore (Nickel)|Nickel]]
| style="text-align:center;"| 0.0
| style="text-align:center;"| 1.0
| style="text-align:center;"| 0.5
| style="text-align:center;"| 1.0
| style="text-align:center;"| 0.0
| style="text-align:center;"| 0.0
|-
| <div class="stationeers-icon">[[File:ItemCobaltOre.png|link=Ore (Cobalt)]] <div class="stationeers-icon-text">1</div></div> [[Ore (Cobalt)|Cobalt]]
| style="text-align:center;"| 1.0
| style="text-align:center;"| 0.0
| style="text-align:center;"| 3.0
| style="text-align:center;"| 0.0
| style="text-align:center;"| 0.0
| style="text-align:center;"| 0.0
|-
|}
</div>


{{Data Network Header}}


{{Data Parameters}}
{| class="wikitable mw-collapsible"
|-
! Parameter Name !! Data Type !! Description
|-
| Activate || Boolean || Activates the Furnace, when set to 1.
|-
| ClearMemory || Boolean || When set to 1,clears the counter memory(e.g.ExportCount). Will set itself back to 0 when actioned.
|-
| Lock || Boolean || Locks the Furnace, when set to 1. Unlocks it when set to 0.
|-
| Mode|| Integer || Returns whether the Furnace is smelting. (0 for no, 1 for yes).
|-
| Open || Boolean || Opens the Furnace, when set to 1. Closes it, when set to 0.
|-
| Setting || Float || (Unknown) Affects the Setting output.
|}


{{Data Outputs}}
{| class="wikitable mw-collapsible"
|-
! Output Name !! Data Type !! Description
|-
| Activate || Boolean || Returns if the furnace is active.
|-
| Combustion|| Boolean || Returns 1 if the furnace atmosphere is on fire.
|-
| ExportCount || Integer || How many items exported since last ClearMemory.
|-
| ImportCount || Integer || How many items imported since last ClearMemory.
|-
| Lock || Boolean || Returns whether the Furnace is locked.
|-
| Maximum || Integer || (Unknown) Returns 100.
|-
| Mode || Integer || Returns whether the Furnace is smelting. (0 for no, 1 for yes).
|-
| Open || Boolean || Returns whether the Furnace is open. (0 for no, 1 for yes).
|-
| PrefabHash || Integer || The hash of the structure.
|-
| Pressure || Float || Returns the pressure in the Furnace in kilo pascal.
|-
| Ratio || Float || (Unknown) Returns 0.5.
|-
| RatioCarbonDioxide || Float || Returns a range from 0.0 to 1.0. Returns the percentage ratio of the amount of carbon dioxide in the Furnace.
|-
| RatioNitrogen || Float || Returns a range from 0.0 to 1.0. Returns the percentage ratio of the amount of nitrogen in the Furnace.
|-
| RatioNitrousOxide || Float || Returns a range from 0.0 to 1.0. Returns the percentage ratio of the amount of nitrous oxide in the Furnace.
|-
| RatioOxygen || Float || Returns a range from 0.0 to 1.0. Returns the percentage ratio of the amount of oxygen in the Furnace.
|-
| RatioPollutant || Float || Returns a range from 0.0 to 1.0. Returns the percentage ratio of the amount of pollutant in the Furnace.
|-
| RatioVolatiles || Float || Returns a range from 0.0 to 1.0. Returns the percentage ratio of the amount of volatiles in the Furnace.
|-
| RatioWater || Float || Returns a range from 0.0 to 1.0. Returns the percentage ratio of the amount of water in the Furnace.
|-
| Reagents || Float || Returns the amount of reagents (smeltable ores, not counting ice) in the Furnace, in grams.
|-
| RecipeHash || int || Current hash of the recipe the device is set to produce.
|-
| Setting || Float || (Unknown) Affected by the Setting parameter.
|-
| Temperature || Float || Returns the temperature in the Furnace in kelvin.
|-
| TotalMoles || Float || Returns the total moles of the furnace.
|}

</translate>

User talk:Eearslya

2026-02-26T07:03:00Z

TK421: /* skipcaptcha rights request */

Hi. Is it possible to get permissions to translate pages? I want to translate into german. I use this wiki to find informations for the game and make it easyer for german players.

THX
Adi2412

== Hiring for german translation ==

Hallo there! I'd love to bring the german translation a bit foreword. :-)<br>
May you grant me permissons?

--[[User:Rot-Fuxs|Rot-Fuxs]] ([[User talk:Rot-Fuxs|talk]]) 09:43, 24 March 2019 (CDT)

== skipcaptcha rights request ==
I've been getting into captcha hell territory where completing captchas takes longer than minor page edits.
<br>Not sure if this is better handled with an extended-autoconfirmed role or similar granting that right so you don't have to be nagged every time someone requests this but i guess i'm the first one to have requested it so far.
<br>--[[User:RA2lover|RA2lover]] ([[User talk:RA2lover|talk]]) 02:07, 25 February 2026 (CST)

I've had the same issue with the captcha's, but it's been effective at stopping the spam for sure. I'd suggest some users (RA2lover for example) who frequently make edits shouldn't have to complete captchas at all. [[User:TK421|TK421]] ([[User talk:TK421|talk]]) 01:03, 26 February 2026 (CST)

Stirling Engine

2026-02-24T08:35:06Z

TK421: correct spelling of celsius. Mention can only use it on Vulcan at night, remove loulan.

[[Category:Power]]
<languages/>
<translate>

{{Itembox
| name = Kit (Stirling Engine) [[File:Kit (Stirling Engine).jpg|thumb|Creates a Stirling Engine]]
| createdwith = [[Electronics Printer]]
| cost = 5 [[Gold]], 20 [[Copper]], 30 [[Steel]]
| stacks = 10
| prefabname = ItemKitStirlingEngine
| prefabhash = -1821571150
}}
{{Structurebox
| name = Stirling Engine [[File:Stirling Engine Front.jpg|thumb|Front]] [[File:Stirling Engine Back.jpg|thumb|Back]]
| prefab_hash = -260316435
| prefab_name = StructureStirlingEngine
| power_usage = 1W
| placed_with_item = [[Kit (Stirling Engine)]]
| placed_on_grid = Small Grid
| requires_frames = Yes
| build states = Three
| decon_with_tool1 = [[Hand Drill]]
| item_rec1 = 2x [[Electronic Parts]]
| decon_with_tool2 = [[Wrench]]
| item_rec2 = 2x [[Steel Sheets]]
| decon_with_tool3 = [[Hand Drill]]
| item_rec3 = [[Kit (Stirling Engine)]]

}}
{{Itembox
| name = Overall Stirling Engine Cost/Requirements [[File:Stirling Engine Front.jpg|thumb|Front]]
| createdwith = [[Electronics Printer]], [[Autolathe]]
| cost = 6 [[Iron]], 9 [[Gold]], 26 [[Copper]], 31 [[Steel]]
}}

== Description == 
Harnessing an ancient thermal exploit, the Recurso 'Libra' Stirling Engine generates power via the expansion and contraction of a working gas to drive pistons operating an electrical generator.

When high pressure hot gas is supplied into the input pipe, this gas will heat the hot side of the unit, then pass into the output pipe. The cooler side uses the room's ambient atmosphere, which must be kept at a lower temperature in order to create a differential. Add a working gas by inserting a gas canister. The unit must be deactivated when adding or removing canisters, or the working gas may leak into the surrounding atmosphere.

Gases with a low molecular mass make the most efficient working gases. Increasing the moles of working gas can result in a greater potential power output. However, overpressuring the unit may have... sub-optimal results.

== Efficiency ==
The Stirling Engine has an efficiency curve that is dependent on three factors:
* Environment
* Working Gas
* Input to Output efficiency
The best a Stirling Engine can provide in power is 15% efficiency of the input heat, whereas a [[Kit (Gas Fuel Generator)|Gas Fuel Generator]] has a much higher efficiency ratio per Mol of fuel.

== Environment ==
The Stirling engine itself is best placed in a 13-25 Celsius environment to provide the highest efficiency. The only planets where it cannot effectively be used outside are: Venus, Moon and Mimas. On Vulcan it can only be used outside during the night.

<gallery>
Stirling_temp.png|Temperature dependency
</gallery>

=== In World ===
* Moon (Vacuum): 0%
* [[Venus]]: 12% efficiency @ 463 Celsius
* Vulcan (Night): 91% efficiency @ 126 Celsius
* Mars: 100%

=== In Room ===
The Stirling engine can be kept in a room to cool it down at maximum efficiency, since the exposed working gas canister heats the room up, it requires an effective cooling system.

== Working Gas ==
The working gas is a canister of gas that must be provided to the machine before it can be used. The gas itself is not lost, only used as a heat transfer gas.
When filling it, 60 mols of gas in the canister is needed, which is usually around 2.4MPa when it is pressurized at room temperature.

'''''If the canister's pressure ever reaches 11 MPa, the machine will have a chance of instantly exploding.''''' This sets a limit on maximum safe operation temperature based on how many mols are present in the canister. At 60 mols, that's 1411 K.

Here are the efficiencies of several gasses:
* Steam: 5%
* Pollutants: 5%
* Carbon Dioxide: 8%
* Oxygen: 12%
* Nitrogen: 12%
* Nitrous Oxide: 12%
* Volatiles: 15% (Best)


== User Comments== 
The Stirling Generator has a maximum pressure differential of 11000 KPa (11 MPa): If the difference in pressure between the internal working gas and external atmosphere exceeds this, it will explode in a radius of more than 3x3, destroying everything in its path and killing players. There needs to be one canister that is used to transfer the heat, it explodes easily if overpressure is reached, unlike normal canisters it doesn't take time to explode as it is instant. Due to its explosive nature, steps of caution i.e. pressure regulators are advised to be placed before the generator input. <br>
<br>
The power output scales on how fast it can transfer heat from the input gas to the outside atmosphere, which depends on the pressure and heat transfer rate of the working gas, and the temperature difference between the input gas and the outside temperature. The cooled down input gas is transferred to the output pipe - you can connect the output to the input in order to extract heat energy from a pipe network.<br>
To increase the pressure differential efficiency, you can increase the temperature delta between the input gas and the outside atmosphere, or increase the working gas pressure.
<br>
Details<br>
Max power: 8000W<br>

Maximum internal-external pressure differential: 11000kPa<br>

Environment operating efficiency: Around 300K for 100%<br>
Minimum power for maximum internal pressure differential efficiency: 4600.452W ((0.15×20.4×2500×5)÷8.3144)<br>
Maximum working gas efficiency: 15% (0.15) with volatiles<br>

Technical details<br>

Ideal pressure differential: 2500<br>
Internal volume: 54L<br>
Piston volume: 5L<br>
Heat exchanger volume: 10L<br>
Hot side area: 2<br>
Cold side area: 3.5<br>
Convection factor: 0.15<br>
Radiation factor: 0.15<br>
Surface area: 8.499227<br>

<br/><br/>

==Vulcan==

The Stirling Engine is a reasonable way to generate night time power on Vulcan when solar power is unavailable. Place it outside so it's in night time (400K) atmosphere, and capture mid-day (900 to 950K) atmosphere into a tank and run the Stirling Generator from that hot air at night, the generator can produce around 1.8 kW from the temperature difference. For the working gas, a good starting point is 70 moles of H2 in the canister. You can boost the power output to about 2.1kW by using an active vent to blow cold night air into the large grid that the Stirling Engine is in to cool it down.

{{Data Network Header}}

{{Data Parameters|
{{Data Parameters/row|On|Boolean|The current state of the Stirling Engine.|multiple=2|0|Off|1|On}}
{{Data Parameters/row|Setting|Integer|?.}}
{{Data Parameters/row|Power|Boolean|w=0|Can be read to return if the Stirling Engine is correctly powered or not, set via the power system, return 1 if powered and 0 if not|multiple=2|0|Unpowered|1|Powered}}
{{Data Parameters/row|Error|Boolean|w=0|1 if device is in error state, otherwise 0|multiple=2|0|<p></p>|1|Error}}
{{Data Parameters/row|Pressure|Float|w=0|In kPa}}
{{Data Parameters/row|Temperature|Float|w=0|In Kelvin}}
{{Data Parameters/row|RatioOxygen|Float|w=0|Ratio of gaseous [[Oxygen]] in the atmosphere}}
{{Data Parameters/row|RatioCarbonDioxide|Float|w=0|Ratio of gaseous [[Carbon Dioxide]] in the atmosphere}}
{{Data Parameters/row|RatioNitrogen|Float|w=0|Ratio of gaseous [[Nitrogen]] in the atmosphere}}
{{Data Parameters/row|RatioPollutant|Float|w=0|Ratio of gaseous [[Pollutant]] in the atmosphere}}
{{Data Parameters/row|RatioVolatiles|Float|w=0|Ratio of gaseous [[Volatiles]] in the atmosphere}}
{{Data Parameters/row|RatioWater|Float|w=0|Ratio of liquid [[Water]] in the atmosphere}}
{{Data Parameters/row|Maximum|Integer|w=0|?}}
{{Data Parameters/row|Ratio|Float|w=0|?}}
{{Data Parameters/row|Quantity|Integer|w=0|?}}
{{Data Parameters/row|RequiredPower|Integer|w=0|Idle operating power quantity, does not necessarily include extra demand power}}
{{Data Parameters/row|PowerGeneration|Integer|w=0|Returns how much power is being generated}}
{{Data Parameters/row|TotalMoles|Float|w=0|}}
{{Data Parameters/row|Volume|Integer|w=0|In L}}
{{Data Parameters/row|RatioNitrousOxide|Float|w=0|Ratio of gaseous [[Nitrous Oxide]] in the atmosphere}}
{{Data Parameters/row|Combustion|Boolean|w=0|1 if the atmosphere is on fire, 0 otherwise}}
{{Data Parameters/row|EnvironmentEfficiency|Float|w=0|Environment Efficiency reported by the machine, as a float between 0 and 1}}
{{Data Parameters/row|WorkingGasEfficiency |Float|w=0|Working Gas Efficiency reported by the machine, as a float between 0 and 1}}
{{Data Parameters/row|RatioLiquidNitrogen|Float|w=0|Ratio of liquid [[Nitrogen]] in the atmosphere}}
{{Data Parameters/row|RatioLiquidOxygen|Float|w=0|Ratio of liquid [[Oxygen]] in the atmosphere}}
{{Data Parameters/row|RatioLiquidVolatiles|Float|w=0|Ratio of liquid [[Volatiles]] in the atmosphere}}
{{Data Parameters/row|RatioSteam|Float|w=0|Ratio of gaseous [[Water]] in the atmosphere}}
{{Data Parameters/row|RatioLiquidCarbonDioxide|Float|w=0|Ratio of liquid [[Carbon Dioxide]] in the atmosphere}}
{{Data Parameters/row|RatioLiquidPollutant|Float|w=0|Ratio of liquid [[Pollutant]] in the atmosphere}}
{{Data Parameters/row|RatioLiquidNitrousOxide|Float|w=0|Ratio of liquid [[Nitrous Oxide]] in the atmosphere}}
{{Data Parameters/row|RatioHydrogen|Float|w=0|Ratio of gaseous Hydrogen in the atmosphere (Hydrogen is deprecated and has been replaced by [[Volatiles]])}}
{{Data Parameters/row|RatioLiquidHydrogen|Float|w=0|Ratio of liquid Hydrogen in the atmosphere (Hydrogen is deprecated and has been replaced by [[Volatiles]])}}
{{Data Parameters/row|RatioPollutedWater|Float|w=0|Ratio of liquid [[Polluted Water]] in the atmosphere}}
{{Data Parameters/row|PrefabHash|Integer|w=0|The hash of the structure}}
{{Data Parameters/row|ReferenceId|Integer|w=0|Unique Reference Identifier for this object}}
{{Data Parameters/row|NameHash|Integer|w=0|Provides the hash value for the name of the object as a 32 bit integer.}}
}}

</translate>

Advanced IC10 Programming

2026-02-22T07:48:32Z

TK421: Using syntax highlighting module instead

2026-02-20T07:23:40Z

TK421: oops... deleted a 0 by mistake...

[[Category:IC10 Programming]]
= VS code extension =
'''For convenient operation, there is an extension for the visual studio code IDE''' [https://marketplace.visualstudio.com/items?itemName=Traineratwot.stationeers-ic10 Link]

Web version: https://ic10.dev/

and compiler [http://traineratwot.aytour.ru/wiki/icx ICX]

= Flow Control And Data Manipulation =

''NOTE: This level of coding is NOT needed to play the game to it's full extent. it's aimed at people looking for custom, self-inspired challenges.''

== Devices By Register ==

<p>You can use a register to access the device based on pin number.</p>

<div style="background: #000000;>
<p style="float: none; white-space: pre; line-height: 1; color: #FFFFFF; background: #000000; font-size: 110%;font-family: Consolas; margin-left: 10px;>
<span style="color: #FF0000;">move</span> r0 0
next:
<span style="color: #FF0000;">s</span> dr0 Horizontal 0
<span style="color: #FF0000;">s</span> dr0 Vertical 0
<span style="color: #FF0000;">s</span> dr0 On 0
<span style="color: #FF0000;">add</span> r0 r0 1
<span style="color: #FF0000;">blt</span> r0 6 next

</p>
</div>

== Functions ==

<div style="background: #000000;>
<p style="float: none; white-space: pre; line-height: 1; color: #FFFFFF; background: #000000; font-size: 110%;font-family: Consolas; margin-left: 10px;><span>main:</span><span>
</span><span style="color: #FF0000;">jal</span><span> </span><span>MyFunction</span><span>
</span><span style="color: #FF0000;">j</span><span> </span><span>main</span><span>

</span><span>MyFunction:</span><span>
</span><span>...</span><span>
</span><span style="color: #FF0000;">j</span><span> </span><span>ra</span><span>

</span>
</p>
</div>
A function is just a label we jump to, but using the -al version of branch instructions (jal, beqzal) as they store the return address into the special '''ra''' register.
When calling a function from another function (or from itself), ra will be overwritten so we have to store it in the stack and take it out when the function completes:

<div style="background: #000000; float: none">
<p style="float: none; white-space: pre; line-height: 1; color: #FFFFFF; background: #000000; font-size: 110%;font-family:Consolas; margin-left: 10px;><span>main:</span><span>
</span><span style="color: #FF0000;">jal</span><span> </span><span>_MyFunction</span><span>
</span><span style="color: #FF0000;">j</span><span> </span><span>main</span><span>

</span><span>_MyFunction:</span><span>
</span><span style="color: #6666FF;">push</span><span> </span><span>ra</span><span>
</span><span style="color: #FF0000;">jal</span><span> </span><span>_MySecondFunction</span><span>
</span><span style="color: #6666FF;">pop</span><span> </span><span>ra</span><span>
</span><span style="color: #FF0000;">j</span><span> </span><span>ra</span><span>

</span><span>_MySecondFunction:</span><span>
</span><span>...</span><span>
</span><span style="color: #FF0000;">j</span><span> </span><span>ra</span><span>

</span>
</p>
</div>
If we hadn't used the stack, the jump at the end of _MyFunction would take us to the call of _MySecondFunction instead of the main section.

== Loops ==

<div style="background: #000000; float: none">
<p style="float: none; white-space: pre; line-height: 1; color: #FFFFFF; background: #000000; font-size: 110%;font-family:Consolas; margin-left: 10px;><span style="color: #00FFFF;">alias</span><span> </span><span>rIterator</span><span> </span><span>r0</span><span>
</span><span>main:</span><span>
</span><span style="color: #6666FF;">move</span><span> </span><span>rIterator</span><span> </span><span>0</span><span>
</span><span>Loop:</span><span>
</span><span>...</span><span>
</span><span style="color: #6666FF;">add</span><span> </span><span>rIterator</span><span> </span><span>rIterator</span><span> </span><span>1</span><span>
</span><span style="color: #FF0000;">blt</span><span> </span><span>rIterator</span><span> </span><span>4</span><span> </span><span>Loop</span><span>

</span><span style="color: #FF0000;">j</span><span> </span><span>main</span><span>

</span>
</p>
</div>
The challenge with loops is to keep them clean. Relative jumps are a great way to save lines but they can quickly turn code messy because adding lines might break them if you don't adjust the relative jump. If code length is not an issue, stick to labels where possible.

== Indexing With Relative Jump ==

<div style="background: #000000; float: none">
<p style="float: none; white-space: pre; line-height: 1; color: #FFFFFF; background: #000000; font-size: 110%;font-family:Consolas; margin-left: 10px;><span style="color: #00FFFF;">alias</span><span> </span><span>rIndex</span><span> </span><span>r0</span><span>
</span><span style="color: #00FFFF;">alias</span><span> </span><span>rTemp</span><span> </span><span>r1</span><span>
</span><span style="color: #00FFFF;">alias</span><span> </span><span>rValue</span><span> </span><span>r2</span><span>

</span><span>main:</span><span>
</span><span style="color: #6666FF;">move</span><span> </span><span>rIndex</span><span> </span><span>1</span><span>
</span><span style="color: #6666FF;">mul</span><span> </span><span>rTemp</span><span> </span><span>rIndex</span><span> </span><span>2</span><span>
</span><span style="color: #6666FF;">add</span><span> </span><span>rTemp</span><span> </span><span>rTemp</span><span> </span><span>1</span><span>
</span><span style="color: #FF0000;">jr</span><span> </span><span>rTemp</span><span>
</span><span style="color: #6666FF;">move</span><span> </span><span>rValue</span><span> </span><span>123</span><span> </span><span style="color: #FF8000;">#Index 0
</span><span style="color: #FF0000;">j</span><span> </span><span>Select_end</span><span>
</span><span style="color: #6666FF;">move</span><span> </span><span>rValue</span><span> </span><span>456</span><span> </span><span style="color: #FF8000;">#Index 1
</span><span style="color: #FF0000;">j</span><span> </span><span>Select_end</span><span>
</span><span style="color: #6666FF;">move</span><span> </span><span>rValue</span><span> </span><span>789</span><span> </span><span style="color: #FF8000;">#Index 2
</span><span style="color: #FF0000;">j</span><span> </span><span>Select_end</span><span>
</span><span>...</span><span>
</span><span>Select_end:</span><span>
</span><span style="color: #FF0000;">j</span><span> </span><span>main</span><span>

</span>
</p>
</div>
Use this to set one or more parameters or call functions using an index number you calculated (or read from a dial button). We multiply it by 2 because we need space for a jump after each move command so we don't run the subsequent ones and we add 1 because for a 0 index "jr 0" would lock up our IC.

== Indexing With Comparison ==

<div style="background: #000000; float: none">
<p style="float: none; white-space: pre; line-height: 1; color: #FFFFFF; background: #000000; font-size: 110%;font-family:Consolas; margin-left: 10px;><span style="color: #00FFFF;">alias</span><span> </span><span>rIndex</span><span> </span><span>r0</span><span>
</span><span style="color: #00FFFF;">alias</span><span> </span><span>rValue</span><span> </span><span>r1</span><span>

</span><span>main:</span><span></span>
<span style="color: #6666FF;">move</span><span> </span><span>rIndex</span><span> </span><span>1</span>
<span style="color: #6666FF;">move</span><span> </span><span>rValue</span><span> </span><span> 123</span><span> </span><span style="color: #FF8000;"> #Index 0</span>
<span style="color: #6666FF;">sub</span><span> </span><span>rIndex</span><span> </span><span>rIndex</span><span> 1</span>
<span style="color: #FF0000;">select</span><span> rValue</span><span> rIndex</span><span> rValue</span><span> 456</span><span style="color: #FF8000;"> #Index 1</span>
<span style="color: #6666FF;">sub</span><span> </span><span>rIndex</span><span> </span><span>rIndex</span><span> 1</span>
<span style="color: #FF0000;">select</span><span> rValue</span><span> rIndex</span><span> rValue</span><span> 789</span><span style="color: #FF8000;"> #Index 2</span>
<span style="color: #FF0000;">j</span><span> </span><span>main</span><span>

</span>
</p>
</div>
In most programming languages, you can do the same thing in different ways. A third way would be to use the stack.

== Redefining Aliases ==

Say you have a complex function that manipulates a device (reads/writes multiple parameters, controls timing etc) and you want to reuse it for multiple devices. You could copy paste the whole function, or you could redefine the alias you used and point it to another device, like this:

<div style="background: #000000; float: none">
<p style="float: none; white-space: pre; line-height: 1; color: #FFFFFF; background: #000000; font-size: 110%;font-family:Consolas; margin-left: 10px;><span>main:</span><span>
</span><span style="color: #00FFFF;">alias</span><span> </span><span>dCurrent</span><span> </span><span>d0</span><span>
</span><span style="color: #FF0000;">jal</span><span> </span><span>_MyFunction</span><span>
</span><span style="color: #00FFFF;">alias</span><span> </span><span>dCurrent</span><span> </span><span>d1</span><span>
</span><span style="color: #FF0000;">jal</span><span> </span><span>_MyFunction</span><span>
</span><span style="color: #FF0000;">j</span><span> </span><span>main</span><span>

</span>
</p>
</div>
''NOTE: This wouldn't work in real languages since aliases and defines are just directives for the (pre)compiler, they're not evaluated during runtime by the CPU''

You can combine this with a loop and indexing to run your function on multiple devices automatically.
<div style="background: #000000; float: none">
<p style="float: none; white-space: pre; line-height: 1; color: #FFFFFF; background: #000000; font-size: 110%;font-family:Consolas; margin-left: 10px;><span style="color: #00FFFF;">alias</span><span> </span><span>rIterator</span><span> </span><span>r0</span><span>
</span><span style="color: #00FFFF;">alias</span><span> </span><span>rTemp</span><span> </span><span>r1</span><span>
</span><span>main:</span><span>
</span><span style="color: #6666FF;">move</span><span> </span><span>rIterator</span><span> </span><span>0</span><span>
</span><span>Loop:</span><span>
</span><span style="color: #FF0000;">jal</span><span> </span><span>_UpdateReference</span><span>
</span><span style="color: #FF0000;">jal</span><span> </span><span>_FunctionForDevice</span><span>
</span><span style="color: #6666FF;">add</span><span> </span><span>rIterator</span><span> </span><span>rIterator</span><span> </span><span>1</span><span>
</span><span style="color: #FF0000;">bgt</span><span> </span><span>rIterator</span><span> </span><span>3</span><span> </span><span>Loop_End</span><span>
</span><span style="color: #FF0000;">j</span><span> </span><span>Loop</span><span>
</span><span>Loop_End:</span><span>
</span><span style="color: #FF0000;">j</span><span> </span><span>main</span><span>

</span><span>_UpdateReference:</span><span>
</span><span style="color: #6666FF;">mul</span><span> </span><span>rTemp</span><span> </span><span>rIterator</span><span> </span><span>2</span><span>
</span><span style="color: #6666FF;">add</span><span> </span><span>rTemp</span><span> </span><span>rTemp</span><span> </span><span>1</span><span>
</span><span style="color: #FF0000;">jr</span><span> </span><span>rTemp</span><span>
</span><span style="color: #00FFFF;">alias</span><span> </span><span>dCurrentDevice</span><span> </span><span>d0</span><span> </span><span style="color: #FF8000;">#Index 0
</span><span style="color: #FF0000;">j</span><span> </span><span>Select_end</span><span>
</span><span style="color: #00FFFF;">alias</span><span> </span><span>dCurrentDevice</span><span> </span><span>d1</span><span> </span><span style="color: #FF8000;">#Index 1
</span><span style="color: #FF0000;">j</span><span> </span><span>Select_end</span><span>
</span><span style="color: #00FFFF;">alias</span><span> </span><span>dCurrentDevice</span><span> </span><span>d2</span><span> </span><span style="color: #FF8000;">#Index 2
</span><span style="color: #FF0000;">j</span><span> </span><span>Select_end</span><span>
</span><span style="color: #00FFFF;">alias</span><span> </span><span>dCurrentDevice</span><span> </span><span>d3</span><span> </span><span style="color: #FF8000;">#Index 3
</span><span style="color: #FF0000;">j</span><span> </span><span>Select_end</span><span>
</span><span>Select_end:</span><span>
</span><span style="color: #FF0000;">j</span><span> </span><span>ra</span><span>

</span><span>_FunctionForDevice:</span><span>
</span><span style="color: #FF8000;">#Manipulate dCurrentDevice
</span><span style="color: #FF0000;">j</span><span> </span><span>ra</span><span>

</span>
</p>
</div>

= Device Manipulation =

== Timing And Parameters ==

Some devices don't react well to having parameters changed while they're performing an action such as import or export. Notable mentions are the stacker, sorter and the vending machine. You can avoid them locking up (or getting jammed with items) either by adding delays (yield, sleep) or by actively waiting for their slots to become unoccupied, or their Activation to become 0.
{{ICCode|
WaitForDevices:
yield
ls rBusy dSorter 0 Occupied
bgtz rBusy WaitForDevices
ls rBusy dSorter 1 Occupied
bgtz rBusy WaitForDevices
ls rBusy dSorter 2 Occupied
bgtz rBusy WaitForDevices
ls rBusy dVender 0 Occupied
bgtz rBusy WaitForDevices
ls rBusy dVender 1 Occupied
bgtz rBusy WaitForDevices
j ra
}}

'''NOTE:''' The slot reader labels slots from 1 but in the IC they start at 0. It is also a good idea to check any device involved in your solution with both a logical and slot reader as the current databases may not list all existing slots or parameters. You should always make use of all data available from devices as they may greatly simplify your project.

Using delays is convenient, but has downsides. You're giving up real-time control over the process and may miss certain events or react too late and cause a device to jam. You also need to consider that code takes time to run, and for example if you have a complicated condition for setting the output of a sorter depending on the item that entered it, it may be better to leave it OFF by default and only turn it on once the output is correctly set. (Devices react differently to being fed items while powered down. ie the stacker will keep it in the Import slot but the vending machine will completely import it, so make sure to manually test everything you can prior to automating it)

== Detecting devices on a network ==

Sometimes it is convenient to use code to detect the devices connected to the data network, instead of using pins on the housing, or via usage of the batch commands (such as <code>lbn</code> or <code>sbn</code>). The current way to detect attached devices is via a <code>get</code> command, passing in a network id: <code>get r0 db:0 3</code>.

What the above snippet does is to run the <code>get</code> command, addressed to the network connection (network <code>0</code> in <code>db:0</code>) attached to the housing of the chip (<code>db</code>). The <code>get</code> command normally accesses the stack of the device being addressed (such as the chip itself, or a sorter), but if the address being passed to the <code>get</code> command is a network reference (with the colon and number indicating which connection), then the <code>get</code>command will return the <code>ReferenceId</code> of the device at the given index (<code>3</code> in the example above - if there is no such a device at the index, then <code>-1</code> is returned). The order is not determined by anything specific (even though it seems to remain the same until the network itself is changed, so write your code accordingly).

With a <code>ReferenceId</code> being returned (in the example above it is saved in <code>r0</code>), this can be used in a later command to obtain information about the device - such as their <code>PrefabHash</code> to detect the device type (and/or any other LogicProperty it has available).

One scenario where this is useful is in dynamically detecting newly attached structures without a priori having their device name(s), or even a count of how many, and being able to control them individually (rather than as a batch like one would for solar tracking) - centrifuges is one such type of device where this is helpful, since their cycle times are not synced up, you cannot use a batch command to control them (without losing efficiency). Below is reproduced some code from [https://old.reddit.com/r/Stationeers/comments/1r7k148/ic10_control_centrifuges_via_data_connection/ various] [https://old.reddit.com/r/Stationeers/comments/1r6uer7/ic10_is_there_a_way_to_dynamically_adress_all/ reddit] [https://old.reddit.com/r/Stationeers/comments/1q30e9z/coal_power_plant_math_check/nxy1g7n/ posts] that discuss this scenario:

{{ICCode|
alias refid r14
alias index r15
alias devicecount r13
alias ticks r12
define centrifuge HASH("StructureCentrifuge")

discoveryinit:
yield
move sp 0
lb r0 centrifuge PrefabHash Sum
div devicecount r0 centrifuge
move index 0

discovery:
get refid db:0 index
l r0 refid PrefabHash
bne r0 centrifuge wrongid
push refid
s refid On 1

wrongid:
beq devicecount sp maininit
add index index 1
j discovery

maininit:
move ticks 0
beqz sp discoveryinit

main:
bge ticks 120 discoveryinit
add ticks ticks 1
move sp devicecount
yield

loop:
beqz sp main
pop refid
bdns refid discoveryinit
l r0 refid Error
beqz r0 loop
l r0 refid Reagents
sge r0 r0 5
s refid Open r0
j loop
}}

= Sample Projects =

== Vending Machine Exporter ==

[[Vending_Machine_Export_IC10]]

Advanced IC10 Programming

2026-02-20T07:21:52Z

2026-02-20T06:28:14Z

TK421: using iccode template

[[Category:IC10 Programming]]
=Scripting language for IC10 housings / chips=
MIPS is [[Stationeers]]' inspiration for the in-game scripting language called IC10. It runs on [[Integrated Circuit (IC10)|IC10 chips]] crafted at the [[Electronics Printer]].

==Registers==
Internal registers '''r?''': The IC contains 16 CPU registers, numbered '''r0''' to '''r15'''. From now on referred to as '''r?'''.

Device registers '''d? logicType''': Device registers are written to and from the IC. A device register is numbered '''d0''' to '''d5''' (select via screw), or '''db''' (connected device). From now on referred to as '''d?'''.

=== Logic and algorithmic with '''Internal registers''' ===
All calculations are exclusively performed to and from '''r?''' registers, or generally more understood as variables in programming. You can use aliases to give convenient names with the <code>alias string r?|d?</code>command (see below).

Internal registers can be manipulated in various ways.
* Write constant values <code>move r? (r?|num)</code>: Example: <code>move r0 2</code> sets r0 to the number 2.
* Calculate: Calculations are done to- and from these registers, like <code>add r? a(r?|num) b(r?|num)</code>. Example: <code>add r1 r0 3</code> adds 3 to r0, and writes to r1.

Note, for any kind of if statements or loop behaviours, knowing about labels, branching, and jumps is essential knowledge. See below.

=== IO to '''Device registers''' ===
Acronym '''d?''' stands for device, where ? is a number corresponding to the screw device selector on the socket.
You can also read/write to the device where the IC is planted in using device '''db'''.

Generally, there are up to 6 devices which can be set using the screwdriver '''d0''' to '''d5'''. A special device register '''db''' is the device wherever the IC is mounted upon. Very convenient for atmospheric devices where no separate IC socket is required.

Note, the IC is completely unaware where d? is actually connected to. So if you get a logicType error, check d? number, or check if the screw has been set on the socket. An alias is only convenient to convey what is expected to be set on the d? screw, it does not actually set or program the screw.

* Read from device (load) <code>l r? d? logicType</code>: Reads logicType, like Pressure from a [[Sensors|gas sensor]], from device d? to register r?. Values can be read from connected devices and put into the register using the '''l''' (load) command. For example, if you want to load the state of a door. <br> Example: <code>l r0 Door Open</code> reads the 'Open' field of an object named 'Door', that would be connected to the IC housing of the chip.
* Write to a device (set) <code>s d? logicType r?</code>: Write a value from a register back to a device using the command <code>s d? logicType r?</code>. For example, if d0 is set to a door using the screwdriver, <code>s d0 Open 0</code> sets the 'Open' status of the d0 (a door) to 0, effectively closing the door.

=== batch IO to - '''Device registers''' ===
'''Batch writing''' needs to be done to a specific '''deviceHash''' instead of d?. Is unique per device type, which you can find in the [[Stationpedia]] entries.
{{ICCode|
lb r? deviceHash logicType batchMode
sb deviceHash logicType r?
}}
Additionally, using the following batch commands, a '''nameHash''' can be provided to only modify devices with a certain name.
{{ICCode|
lbn r? deviceHash nameHash logicType batchMode
sbn deviceHash nameHash logicType r?
}}

All hashes used in the game are CRC-32 checksums computed from the strings they represent.

'''batchMode''' is a parameter equal to 0, 1, 2, or 3. These are also defined as the constants '''Average''', '''Sum''', '''Minimum''', and '''Maximum''' respectively. The word or number can be used.

Combining one of these functions with the <code>HASH()</code> function can be advantageous:

{{ICCode|
lbn r0 HASH("StructureGasSensor")
HASH("Sensor 1") Temperature Average
}}

This code will load the average temperature of all gas sensors on the network named "Sensor 1" onto register '''r0'''

If the batch read (lb/lbn) is done on a network without any matching devices the results will be as specified in the table:
{| class="wikitable"
|+ Batch read with no devices
|-
! Batch Mode !! Result
|-
| Average (0) || nan
|-
| Sum (1) || 0
|-
| Minimum (2) || 0*
|-
| Maximum (3) || ninf
|}

<nowiki>*</nowiki> This apparently used to result in pinf, but in version 0.2.6091.26702 both lb and lbn are returning 0.

pinf and ninf are the IC10 constants for "positive infinity" and "negative infinity" respectively, and work much like other numerical constants.

=== Examples ===

Here are some examples demonstrating all three operations:

<code>move r0 10</code><br>Sets register '''r0''' to the value 10

<code>move r0 r1</code><br>Copies the value of register '''r1''' to register '''r0'''

<code>l r0 d0 Temperature</code><br>Reads the Temperature parameter from device '''d0''' and places the value in register '''r0'''.
Note: not all devices have a Temperature parameter, check the in-game stationpedia.

To set a device specific value (like '''On'''), you can write into this value.

<code>s d0 On r0</code><br>Writes the value from register '''r0''' out to '''On''' parameter of device '''d0'''. In this example the device will be turned On, if valve of register r0 equals 1, otherwise (register r0 equals 0) it will turned off. See section [[IC10#Device_Variables|Device Variables]].

It's recommended to use labels (like: ''someVariable'') instead of a direct reference to the register. See '''alias''' in section [[IC10#Instructions|Instructions]].

=== Special registers ===
There are two more registers. One called '''ra''' (return address) and one called '''sp''' (stack pointer). The '''ra''' is used by certain jump and branching instructions (those ending with '''-al''') to remember which line in the script it should return to. The '''sp''' tracks the next index within the stack (a memory that can store up to 512 values) to be pushed (written) to or popped (read) from. Neither '''ra''' nor '''sp''' is protected, their values can be changed by instructions like any other register.

==Stack Memory==
The Stack is a memory that can hold 512 different values. Each IC10 has its own Stack, and some devices (like the Logical Sorter) also have a Stack.
;push r?: adds the value '''r?''' and increments the '''sp''' by 1.
;pop r?: loads the value in the stack memory at index <code>sp-1</code> into register '''r?''' and decrements the '''sp''' by 1.
;peek r?: loads the value in the stack memory at index <code>sp-1</code> into register '''r?'''.
;poke address(r?|num) value(r?|num): Stores the provided value at the provided address in the stack.
;get r? d? address(r?|num): loads the value in the stack memory at index <code>address</code> on provided device into register '''r?'''.
;getd r? id(r?|num) address(r?|num): loads the value in the stack memory at index <code>address</code> on provided device id into register '''r?'''.
;put d? address(r?|num) value(r?|num): adds the value to the stack memory off the provided device at index <code>address</code>.
;putd id(r?|num) address(r?|num) value(r?|num) : adds the value to the stack memory off the provided device id at index <code>address</code>.

As mentioned previously, '''sp''' can be both written to and read from any time. When reading ('''peek''' or '''pop'''), '''sp''' must be between 1 and 512, inclusive. While writing ('''push'''), '''sp''' must be between 0 and 511, inclusive.

Stack memory is persistent on logic chips. This means that if you have a logic chip and push values to the stack, the code that pushes those values can be removed and the stack will retain those values.

Note that this does not carry over to any other logic chips which receive the program of the original; They will need to have their stack memories programmed individually.

'''Stack Traversing'''

Traversing the stack can be done similarly to how an array would be traversed in some other languages:
{{ICCode|
#this will traverse indices {min value} through {max value}-1
move sp {min value}
loop:
add sp sp 1
peek r0

#do something here with your stack values (loaded into r0)

blt sp {max value} loop

#continue on
}}

Alternatively, you can use the pop function's decrementing to make a more efficient loop:
{{ICCode|
move sp {max value}
add sp sp 1
loop:
pop r0

#do something here with your stack values (loaded into r0)

bgt sp {min value} loop

#continue on

}}

==Comments==
Comments can be placed using a '''#''' symbol. All comments are ignored by the game when it reads commands. Below is an example of valid code with two comments.
{{ICCode|
alias MyAlias r0 # Text after the hash tag will be ignored to the end of the line.
# You can also write comments on their own lines, like this.
}}

==Device Ports==
ICs can interact with up to 6 other devices via d0 - d5, as well as the device it's attached to via db. To change or set a device, use a screwdriver and adjust the device in the IC housing. You can read or set any of the device's properties, so it is possible to do things like read the pressure or oxygen content of a room on the same Device port.

Additionally, it's possible to set other IC housings as devices, allowing you to create programs that run across multiple ICs together. For example, an Gas Mixing IC could check the ''' Setting''' field of a Atmosphere Sensor IC and act based on the value of the sensor chip.

The '''l''' (load) or '''s''' (set) instructions you have to read or set these values to your device. Examples:
{{ICCode|
#Reads the 'Temperature' from an atmosphere sensor
# at device port 'd0' into register 'r0'.
l r0 d0 Temperature
}}
{{ICCode|
# Writes the value of the register 'r0' to the
# device on port 'd1' into the variable 'Setting'.
s d1 Setting r0
}}

==Labels==
Labels are used to make it easier to jump between lines in the script. The label will have a numerical value that is the same as its line number. Even though it's possible to use a labels value for calculations, doing so is a bad idea since any changes to the code can change the line numbers of the labels.
{{ICCode|
main: # define a jump mark with label 'main'
j main # jumps back to 'main'
}}

==Constants==
Instead of using a register to store a fixed value, a constant can be made. Using this name will refer to the assigned value. With the help of Constants you can save register places.
{{ICCode|
# defines a Constant with name 'pi'
# and set its value to 3.14159
define pi 3.14159
}}

You can use these constants like any other variables (see: alias in section [[IC10#Instructions|Instructions]]). Example:
{{ICCode|
# set the value of register 'r0' to the value of constant named 'pi'.
move r0 pi
}}

==Numeric values==
Registers and constants are usually decimal values using double-precision floating point (confirmed?).

Unlike real CPU architectures, integers are not supported as a distinct type, but double FP can represent integers up to about 54 bits before rounding causes problems (the exact number depending what bit patterns you happen to have).

Numbers can be written in hexadecimal by preceding the value with a $ symbol. Values larger than 54 bits might get corrupted. Hex numbers are typically used for ReferenceId values.

Examples:
{{ICCode|
move r0 12345
move r1 123.456
move r2 $E1B2
}}

==Indirect referencing==
This is a way of accessing a register by using another register as a pointer. Adding an additional r in front of the register turns on this behaviour. The value stored in the register being used as the pointer must be between 0 to 15, this will then point to a register from r0 to r15, higher or lower values will cause an error.
{{ICCode|
move r0 5 # stores the value 5 in r0
move rr0 10
# is now the same as 'move r5 10'
# since r0 has the value 5, rr0 points at the register r5
}}

Additional r's can be added to do indirect referencing multiple times in a row.
{{ICCode|
move r1 2
move r2 3
move rrr1 4
# is now the same as 'move r3 4'
# since r1 points at r2 which points at r3
}}

This also works with devices
{{ICCode|
move r0 2 # stores the value 2 in r0
s dr0 On 1
# is now the same as 's d2 On 1'
# r0 has the value 2 so dr0 points at d2
}}

== Dynamically changing LogicType when interacting with Device Registers ==
When the <code>l</code> or <code>s</code> instructions are used to read from or write to a Device Register, the LogicType is the variable that will be interacted with (example: in <code>l r0 myDevice Temperature</code> the LogicType is the Temperature). In most scripts the LogicType will be hardcoded. But it's also possible to change the LogicType dynamically. The LogicType is an enum, where each type is identified by a unique integer value. This makes it possible to cycle through them in various ways, either as a list placed on the Stack, or by increasing the LogicType value via addition in each loop.
{{ICCode|
#loop through a list of LogicTypes
push LogicType.RatioOxygen
push LogicType.RatioVolatiles
push LogicType.Temperature
loop:
pop r1
l r0 myDevice r1
...
bgtz sp loop #loop until the Stack is empty}}

==Network Referencing / Channels==

All cable networks have 8 Channels which can have data loaded from/stored to via a device and connection reference. Connections for each supported device are listed in the stationpedia. All 'connections' a device can make are a connection (pipe, chute, cable), but only cable networks have channels.

The 8 channels (Channel0 to Channel7) are however volatile, in that data is destroyed if any part of the cable network is changed, removed, or added to, and also whenever the world is exited. All these channels default to NaN. Strictly speaking, they default to what we would call "quiet NaN", in that its not an error it simply means its not a number yet. Recommend you use these channels for reading and writing between networks, rather than as a data store. This effectively means an IC can read all the networks for all devices to connected to it, so not just their own local network, but any networks any device they can reference is connected to.
{{ICCode|
# d0 is device zero, and the :0 refers
# to that device's 0 connection
l r0 d0:0 Channel0}}

For example: on an IC Housing, the 0 connection is the data port and 1 is power, so you could write out r0 to Channel0 of the power network of the Housing using <code>s db:1 Channel0 r0</code>
{{ICCode|
#read all 8 channels with a loop and
#place the values in r0 to r7
move r15 LogicType.Channel0 #LogicType integer
move r14 0 #pointer for indirect referencing
loop:
l rr14 db:0 r15
add r15 r15 1 #next channel
add r14 r14 1 #next register
ble r15 LogicType.Channel7 loop
}}

==Logic gates, Bitwise and Logical==

All logic gates in MIPS have a bitwise behavior. The available gates are NOT, AND, OR, XOR and NOR (XNOR and NAND are missing).

In Bitwise operations, each bit is matched separately, which includes the sign bit.

To understand what is going on with bitwise operations, a little bit of computer theory is needed. In Stationeers each register uses 64 bits for integer values (a number without decimals), where the 64th bit is the sign-bit (0 for positive and 1 for negative). Since the number 0 is counted as a positive value, this gives each register a range of (2^63 - 1) to -2^63. Negative numbers also behave according to Two's complement (https://en.wikipedia.org/wiki/Two%27s_complement). Which means that a number with a sign-bit of 1 will have all of its number bits flipped as well, so that the decimal value of -1 is represented by a binary value of sixtyfour 1's (this is the smallest possible negative integer since zero counts as a positive integer).

MIPS have binary notation (https://en.wikipedia.org/wiki/Binary_number) that is activated by placing a % in front of the number. The _ characters are ignored and only used for readability.

<code>not r0 0</code><br>
<code># 0 = %00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000</code><br>
<code># flip all bits</code><br>
<code># -1 = %11111111_11111111_11111111_11111111_11111111_11111111_11111111_11111111</code><br>
<code># r0 equals -1</code>

<code>and r0 3 6</code><br>
<code># 3 = %011</code><br>
<code># 6 = %110</code><br>
<code># only the bits in the "2" position are matching</code><br>
<code># r0 equals %010 = 2</code>

Logical operations can still be performed via alternative instructions. But these are not perfect substitutes, they treat negative values differently, and some can produce non-binary outputs. When using these, keep in mind that devices that wants a binary value will treat any non-binary values like this: >= 1 counts as "1" and <1 counts as "0".

<code># r0 = result</code><br>
<code># r1 = input A</code><br>
<code># r2 = input B</code><br>

<code>Logical NOT = seqz r0 r1</code><br>
<code>Logical AND = min r0 r1 r2</code><br>
<code>Logical OR = max r0 r1 r2</code><br>

<code>Logical XOR = sne r0 r1 r2 (only for binary inputs)</code><br>
<code>Logical NAND = not and</code><br>
<code>Logical NOR = not or</code><br>
<code>Logical XNOR = not xor</code>

==Debugging advices==
The value stored in a register or variable can easily be displayed by writing it to the Setting parameter of the IC housing. This has no side effects unless the housing is an [[Air Conditioner]]. To see the value, just stand close to the IC housing and look directly at the housing.<br>
<code>s db Setting r0</code>. # sets/writes the value of register '''r0''' into the parameter '''Setting''' of the IC Housing('''db''')

To check if a certain block of code is executed, use the above trick but with a random number that you choose, like the line number.<br> This example will display the number 137 on the IC housing.<br>
<code>s db Setting 137</code> # sets/writes the number 137 into the parameter '''Setting''' of the IC Housing('''db''')

Always use unique names for labels. When a label is named after a IC10 keyword like "Temperature:" or "Setting:" the original meaning of the keyword is overwritten, so when an instruction tries to use it an error will occur.

A [[Cartridge#Configuration|configuration cartridge]] installed in a [[Handheld_Tablet|tablet]] can be used to see all available values and configuration parameter for all devices you focus on.

==Learning IC10==
IC10 can be difficult to get started with. So here is a list of instructions that are useful for beginners. These can be used to write many different scripts.

General:
* <code>alias</code> make the script easier to read by assigning a name to a register or device, example: <code>alias rTemperature r15</code>
* <code>label:</code> where "label" can be replaced with almost any word, jump and branch instructions can use these in place of line numbers, example: <code>start:</code>
* <code>yield</code> pause for 1-tick and then resume, if not used the script will automatically pause for 1-tick after 128 lines

<br>Jumps:
*<code>j someLabelName</code> jump to line with '''someLabelName'''
*<code>jal someLabelName</code> stores the next line number into the register ra (return address) and then jump to '''someLabelName'''
*<code>j ra</code> jump to register ra (return address)

<br>Branching (jump-if):<br>
<code>beq a(r?|num) b(r?|num) c(r?|num)</code> if '''a''' is equal to '''b''' goto '''c''' (label or linenumber) <br>
<code>bne a(r?|num) b(r?|num) c(r?|num)</code> if '''a''' not-equal '''b''' goto '''c''' (label or linenumber) <br>
<code>bgt a(r?|num) b(r?|num) c(r?|num)</code> if '''a''' greater than '''b''' goto '''c''' (label or linenumber) <br>
<code>blt a(r?|num) b(r?|num) c(r?|num)</code> if '''a''' less than '''b''' goto '''c''' (label or linenumber) <br>
The suffix -al can be added to each of these (example: beqal) to save the '''next''' line number into the "return address" register. this is called using <code>j ra</code>

<br>Device interactions:
<pre>
l (load)
lb (load batch, requires one of the following: 0(Average) / 1(Sum) / 2(Minimum) / 3(Maximum))
ls (load slot)
s (store)
sb (store batch)
</pre>

<br>Logic and Math:
<pre>
seqz (common NOT-gate: turns 0 into 1, and all other values into 0)
move
add (addition)
sub (subtraction)
mul (multiplication)
div (division)
</pre>

<br>Common device variables:
<pre>
On (1 is on, 0 is off)
Open (1 is open, 0 is closed)
Setting (meaning varies between devices, example: a LED display(console) will show this value)
Activate (1 usually means running, example: a Daylight sensor is 1 when the sun shines on it)
Temperature (in Kelvin, Celsius - 273.15)
Pressure (in kPa)
</pre>

<br>Notes:
<br>-All instructions and variables can be seen in-game in the IC editor window by clicking the "f", "x" and "s(x)" buttons on the top right.
<br>-The stationpedia is the best source to see which variables are available to each device.
<br>-Most scripts are loops, they end with a jump instruction that leads back up to the start. Otherwise they will just run once and then stop.

Two practice scripts:
<br>Automatic Night Light: Load "Activate" from a Daylight sensor, flip the value with a NOT-gate, store the value to the "On" variable of one or more lights.
<br>Automatic Wall Cooler: Read "Temperature" from a Gas Sensor. Branch if the value is greater than X, turn on the cooler. Branch if the value is less than Y, turn off the cooler. (Wall coolers need a minimum of 12.5 kPa pressure in the connected pipe)

----

== Accessing devices via batch or ReferenceId ==

The IC housing has 6 pins you can use to configure the devices it
uses. This provides flexibility to let the installer configure which
devices will be controlled by the IC.

Alternatives for accessing devices include the batch load/store and
the ReferenceId load/store instructions.

{{ICCode|
# get the average charge ratio across station batteries
lb r0 HASH("StructureBattery") Ratio Average
}}

{{ICCode|
# get the ReferenceId for the sorter named "Sorter Corn"
lbn r1 HASH("StructureLogicSorter") HASH("Sorter Corn") ReferenceId Maximum
ble r1 ninf ra
#use the ReferenceId to set that sorter's mode.
sd r1 Mode 1
}}

Using the 6 configuration pins makes it easy to write reusable MIPS
scripts where the installer uses the pins to select the devices that
will be managed.

Using batch-name instructions frees you from the hassle of adjusting
the pins, but requires you to name the devices via the [[Labeller]]. It
can also allow you to control more than 6 devices.

=== Batch instructions ===

The batch instructions can address multiple devices only via their '''PrefabHash''' generated from the prefab name using the `HASH("Name")` macro or copied directly from the [[Stationpedia]]. A prefab hash is always an integer. All devices that can be read with logic contain the logic value '''PrefabHash''' and '''NameHash'''.

See [[#Slot.2FLogic_.2F_Batched|Batched instructions]] for a comprehensive list of all batch instructions.

[[#sb|sb]], [[#sbn|sbn]], [[#sbs|sbs]], (no sbns)<br>
[[#lb|lb]], [[#lbs|lbs]], [[#lbn|lbn]], [[#lbns|lbns]]

=== Direct reference instructions ===

Direct reference instructions can address a specific device via its '''ReferenceId'''.

[[#clrd|clrd]], [[#getd|getd]], [[#putd|putd]],<br>
[[#ld|ld]], [[#sd|sd]], (no slot access via reference ID)

=Instructions=
----

See [[IC10/instructions]]

{{:IC10/instructions}}

[https://www.cs.tufts.edu/comp/140/lectures/Day_3/mips_summary.pdf Other examples]

== Conditional functions cheatsheet ==
{| class="wikitable"
|-
! suffix !! description !! branch to line !! branch and store return address !! relative jump to line !! set register
|-
| prefix: || || b- || b-al || br- || s-
|-
| || unconditional || j || jal || jr ||
|-
| -eq || if a == b || beq || beqal || breq || seq
|-
| -eqz || if a == 0 || beqz || beqzal || breqz || seqz
|-
| -ge || if a >= b || bge || bgeal || brge || sge
|-
| -gez || if a >= 0 || bgez || bgezal || brgez || sgez
|-
| -gt || if a > b || bgt || bgtal || brgt || sgt
|-
| -gtz || if a > 0 || bgtz || bgtzal || brgtz || sgtz
|-
| -le || if a <= b || ble || bleal || brle || sle
|-
| -lez || if a <= 0 || blez || blezal || brlez || slez
|-
| -lt || if a < b || blt || bltal || brlt || slt
|-
| -ltz || if a < 0 || bltz || bltzal || brltz || sltz
|-
| -ne || if a != b || bne || bneal || brne || sne
|-
| -nez || if a != 0 || bnez || bnezal || brnez || snez
|-
| -nan || if a == NaN || bnan || || brnan || snan
|-
| -nanz || if a != NaN || || || || snanz
|-
| -dns || if device d is not set || bdns || bdnsal || brdns || sdns
|-
| -dse || if device d is set || bdse || bdseal || brdse || sdse
|-
| -ap || if a approximately equals b || bap || bapal || brap || sap
|-
| -apz || if a approximately equals 0 || bapz || bapzal || brapz || sapz
|-
| -na || if a not approximately equals b || bna || bnaal || brna || sna
|-
| -naz || if a not approximately equals 0 || bnaz || bnazal || brnaz || snaz
|}

All <code>b-</code> commands require target line as last argument, all <code>s-</code> commands require register to store result as first argument. All <code>br-</code> commands require number to jump relatively as last argument. e.g. <code>breq a b 3</code> means if a=b then jump to 3 lines after.

All approximate functions require additional argument denoting how close two numbers need to be considered equal. E.g.: <code>sap r0 100 101 0.01</code> will consider 100 and 101 almost equal (not more than 1%=0.01 different) and will set r0 to 1. The exact formula is <code>if abs(a - b) <= max(c * max(abs(a), abs(b)), float.epsilon * 8)</code> for <code>-ap</code> and is similar for other approximate functions.

https://en.wikipedia.org/wiki/Machine_epsilon
<br/>
'''Example:'''
FLT_EPSILON = 2^(−23) ≈ 1.19e−07; <span style="color:blue;">float (32 bit)</span>
DBL_EPSILON = 2^(−52) ≈ 2.20e−16; <span style="color:#4c9700;">double (64 bit)</span>
<br/>
<code>if abs(100 - 101) <= max(0.01 * max(abs(100), abs(101)), float.epsilon * 8)</code>
<code>if abs(-1) <= max(0.01 * 101, float.epsilon * 8)</code>
<code>if 1 <= max(0.01 * 101, float.epsilon * 8)</code>
<br/>
<span style="color:blue;">if 1 <= max(1.01, FLT_EPSILON * 8)</span>
<span style="color:#4c9700;">if 1 <= max(1.01, DBL_EPSILON * 8)</span>
<br/>
<span style="color:blue;">if 1 <= max(1.01, 1.19e−07 * 8)</span>
<span style="color:#4c9700;">if 1 <= max(1.01, 2.20e−16 * 8)</span>
<br/>
<span style="color:blue;">if 1 <= max(1.01, 0.000000952)</span>
<span style="color:#4c9700;">if 1 <= max(1.01, 0.00000000000000176)</span>
<br/>
<span style="color:blue;">if 1 <= 1.01 TRUE 1</span>
<span style="color:#4c9700;">if 1 <= 1.01 TRUE 1</span>

==Device Variables==
-----

<div id="Activate"></div>
;Activate
:1 if device is activated (usually means running), otherwise 0
:<code>l r0 d0 Activate # sets r0 to 1 if on or 0 if off</code>

<div id="AirRelease"></div>
;AirRelease
<div id="Charge"></div>
;Charge
: The current charge the device has.
<div id="CLearMemory"></div>
;ClearMemory
: When set to 1, clears the counter memory (e.g. ExportCount). Will set itself back to 0 when triggered.
<div id="Color"></div>
;Color
: <div style="display: inline-block; vertical-align: top; height: 20px; width: 20px; border: 1px solid black; margin-right: 5px; background-color:#212AA5;"></div> 0 (or lower) = Blue
: <div style="display: inline-block; vertical-align: top; height: 20px; width: 20px; border: 1px solid black; margin-right: 5px; background-color:#7B7B7B;"></div> 1 = Grey
: <div style="display: inline-block; vertical-align: top; height: 20px; width: 20px; border: 1px solid black; margin-right: 5px; background-color:#3F9B39;"></div> 2 = Green
: <div style="display: inline-block; vertical-align: top; height: 20px; width: 20px; border: 1px solid black; margin-right: 5px; background-color:#FF662B;"></div> 3 = Orange
: <div style="display: inline-block; vertical-align: top; height: 20px; width: 20px; border: 1px solid black; margin-right: 5px; background-color:#E70200;"></div> 4 = Red
: <div style="display: inline-block; vertical-align: top; height: 20px; width: 20px; border: 1px solid black; margin-right: 5px; background-color:#FFBC1B;"></div> 5 = Yellow
: <div style="display: inline-block; vertical-align: top; height: 20px; width: 20px; border: 1px solid black; margin-right: 5px; background-color:#E7E7E7;"></div> 6 = White
: <div style="display: inline-block; vertical-align: top; height: 20px; width: 20px; border: 1px solid black; margin-right: 5px; background-color:#080908;"></div> 7 = Black
: <div style="display: inline-block; vertical-align: top; height: 20px; width: 20px; border: 1px solid black; margin-right: 5px; background-color:#633C2B;"></div> 8 = Brown
: <div style="display: inline-block; vertical-align: top; height: 20px; width: 20px; border: 1px solid black; margin-right: 5px; background-color:#63633F;"></div> 9 = Khaki
: <div style="display: inline-block; vertical-align: top; height: 20px; width: 20px; border: 1px solid black; margin-right: 5px; background-color:#E41C99;"></div> 10 = Pink
: <div style="display: inline-block; vertical-align: top; height: 20px; width: 20px; border: 1px solid black; margin-right: 5px; background-color:#732CA7;"></div> 11 (or higher) = Purple
<div id="CompletionRatio"></div>
;CompletionRatio
<div id="ElevatorLevel"></div>
;ElevatorLevel
<div id="ElevatorSpeed"></div>
;ElevatorSpeed
<div id="Error"></div>
;Error
: 1 if device is in error state, otherwise 0
<div id="ExportCount"></div>
;ExportCount
: How many items exporfted since last ClearMemory.
<div id="Filtration"></div>
;Filtration
: The current state of the filtration system. For example filtration = 1 for a Hardsuit when filtration is On.
<div id="Harvest"></div>
;Harvest
: Performs the harvesting action for any plant based machinery.
: <code>s d0 Harvest 1 # Performs 1 harvest action on device d0</code>
<div id="Horizontal"></div>
;Horizontal
<div id="HorizontalRatio"></div>
;HorizontalRatio
<div id="Idle"></div>
;Idle
<div id="ImportCount"></div>
;ImportCount
<div id="Lock"></div>
;Lock
<div id="Maximum"></div>
;Maximum
<div id="Mode"></div>
;Mode
<div id="On"></div>
;On
<div id="Open"></div>
;Open
<div id="Output"></div>
;Output
<div id="Plant"></div>
;Plant
: Performs the planting operation for any plant based machinery.
: <code>s d0 Plant 1 # Plants one crop in device d0</code>
<div id="PositionX"></div>
;PositionX
<div id="PositionY"></div>
;PositionY
<div id="PositionZ"></div>
;PositionZ
<div id="Power"></div>
;Power
<div id="PowerActual"></div>
;PowerActual
<div id="PowerPotential"></div>
;PowerPotential
<div id="PowerRequired"></div>
;PowerRequired
<div id="Pressure"></div>
;Pressure
<div id="PressureExternal"></div>
;PressureExternal
<div id="PressureInteral"></div>
;PressureInteral
<div id="PressureSetting"></div>
;PressureSetting
<div id="Quantity"></div>
;Quantity
: Total quantity in the device.
<div id="Ratio"></div>
;Ratio
: Context specific value depending on device, 0 to 1 based ratio.
<div id="RatioCarbonDioxide"></div>
;RatioCarbonDioxide
<div id="RatioNitrogen"></div>
;RatioNitrogen
: The ratio of nitrogen in device atmosphere.
<div id="RatioOxygen"></div>
;RatioOxygen
: The ratio of oxygen in device atmosphere.
<div id="RatioPollutant"></div>
;RatioPollutant
: The ratio of pollutant in device atmosphere.
<div id="RatioVolatiles"></div>
;RatioVolatiles
: The ratio of volatiles in device atmosphere.
<div id="RatioWater"></div>
;RatioWater
: The ratio of water in device atmosphere.
<div id="Reagents"></div>
;Reagents
<div id="RecipeHash"></div>
;RecipeHash
<div id="RequestHash"></div>
;ReferenceId
: Unique Identifier of a Device, this value is different for every device in a save.
<div id="ReferenceId"></div>
;RequestHash
<div id="RequiredPower"></div>
;RequiredPower
<div id="Setting"></div>
;Setting
<div id="SolarAngle"></div>
;SolarAngle
: Solar angle of the device.
: <code>l r0 d0 SolarAngle # Sets r0 to the solar angle of d0.</code>
<div id="Temperature"></div>
;Temperature
<div id="TemperatureSettings"></div>
;TemperatureSettings
<div id="TotalMoles"></div>
;TotalMoles
<div id="VelocityMagnitude"></div>
;VelocityMagnitude
<div id="VelocityRelativeX"></div>
;VelocityRelativeX
<div id="VelocityRelativeY"></div>
;VelocityRelativeY
<div id="VelocityRelativeZ"></div>
;VelocityRelativeZ
<div id="Vertical"></div>
;Vertical
: Vertical setting of the device.
<div id="VerticalRatio"></div>
;VerticalRatio
: Ratio of vertical setting for device.
<div id="Volume"></div>
;Volume
: Returns the device atmosphere volume

==Slot Variables==
In general (exceptions exist such as filtration units) slots are assigned as follows.
:Slot 0: Import
:Slot 1: Export
:Slot 2: Inside Machine
-----

<div id="Occupied"></div>
;Occupied
:<code>ls r0 d0 2 Occupied #Stores 1 in r0 if d0 has more seeds</code>
:<code>ls vOccupied dThisVictim 2 Occupied #stores 1 in vOccupied if dThisVictim has more seeds</code>
<div id="OccupantHash"></div>
;OccupantHash
<div id="Quantity"></div>
;Quantity
<div id="Damage"></div>
;Damage
<div id="Efficiency"></div>
;Efficiency
<div id="FilterType"></div>
;FilterType
Reports the type of filter installed in the slot (e.g. in a Filtration unit).
:Return Values: 1: Oxygen, 2: Nitrogen, 4: Carbon Dioxide, 8: Volatiles, 16: Pollutants, 32: Water, 64: Nitrous Oxide
:<code>ls r0 db 0 FilterType</code>
<div id="Health"></div>
;Health
<div id="Growth"></div>
;Growth
:<code>ls r0 d0 0 Growth # Store the numerical growth stage of d0 in r0</code>
<div id="Pressure"></div>
;Pressure
<div id="Temperature"></div>
;Temperature
<div id="Charge"></div>
;Charge
<div id="ChargeRatio"></div>
;ChargeRatio
<div id="Class"></div>
;Class
<div id="PressureWaste"></div>
;PressureWaste
<div id="PressureAir"></div>
;PressureAir
<div id="MaxQuantity"></div>
;MaxQuantity

<div id="Mature"></div>
;Mature
:<code>ls r0 d0 0 Mature # Store 1 in r0 if d0 has a mature crop</code>
:<code>ls vMature dThisVictim 0 Mature # Store 1 in vMature if dThisVictim has a mature crop</code>
;ReferenceId
: Unique Identifier of a Device, this value is different for every device in a save.
<div id="ReferenceId"></div>
----

=Examples=
Previous examples were obsolete due to game changes, or confusing, they have been moved into the Discussions section
----

===Harvie automation===
This script uses the batch instruction <code>sb ...</code> to control all Harvie devices on the network. But only one Harvie and one Tray will be the ''master'' and have their values read, the rest of the Harvies will repeat exactly what this unit does. Some problems with this design is that different types of crops mature at different speeds, and if seeds were manually planted and the master unit recieved the first seed, the harvesting action will be performed too early on all the other plants since they are growing a few seconds slower.

<div class="mw-collapsible mw-collapsed" data-expandtext="{{int:Expand, Automated Harvie Script}}" data-collapsetext="{{int:Collapse, Automated Harvie Script}}">
{{ICCode|
alias dHarvie d0
alias dTray d1

alias rHarvieHash r8
alias rTrayHash r9
l rHarvieHash dHarvie PrefabHash
l rTrayHash dTray PrefabHash

main:
yield
#read plant data from the Tray
ls r0 dTray 0 Mature
#harvestable plants return 1, young plants return 0
#nothing planted returns -1
beq r0 -1 plantCrop
beq r0 1 harvestCrop
ls r0 dTray 0 Seeding
#seeds available returns 1, all seeds picked returns 0
#plants too young or old for seeds returns -1
beq r0 1 harvestCrop
j main

plantCrop:
#stop the planting if no seeds available
#otherwise it will plant nothing repeatedly
ls r0 dHarvie 0 Occupied
beq r0 0 main
sb rHarvieHash Plant 1
j main

harvestCrop:
sb rHarvieHash Harvest 1
j main

### End Script ###

}}
</div>
<br>
-----

===Solar Panel 2-axis tracking===
<div class="mw-collapsible mw-collapsed" data-expandtext="{{int:Expand, Solar Panel 2-axis tracking}}" data-collapsetext="{{int:Collapse, Solar Panel 2-axis tracking}}">
{{ICCode|
#2 Axis Solar Tracking adapted from CowsAreEvil.
#Place all panels in uniform manner.
#Set one to 15 Vertical(Min value). 0 Horizontal.
#Take note direction panel faces.
#Place daylight sensor flat pointing in the direction
#the panel now faces. (Cable port facing opposite)

#Alias the sensor to d0
alias sensor d0

# define the Panel variants
define Heavy -934345724
define HeavyDual -1545574413
define Solar -2045627372
define SolarDual -539224550

start:
yield
#Check for daylight.
l r0 sensor Activate
beqz r0 reset
#Read the Horizontal data.
l r0 sensor Horizontal
#Set batch to the panels.
sb Heavy Horizontal r0
sb HeavyDual Horizontal r0
sb Solar Horizontal r0
sb SolarDual Horizontal r0
#Read the Vertical data and subtract 90
l r0 sensor Vertical
sub r0 90 r0
#Set batch to the panels.
sb Heavy Vertical r0
sb HeavyDual Vertical r0
sb Solar Vertical r0
sb SolarDual Vertical r0
j start

reset:
yield
sb Heavy Horizontal 270 #Edit this to face sunrise.
sb HeavyDual Horizontal 270 #Edit this
sb Solar Horizontal 270 #Edit this
sb SolarDual Horizontal 270 #Edit this
sb Heavy Vertical 0
sb HeavyDual Vertical 0
sb Solar Vertical 0
sb SolarDual Vertical 0
sleep 10
j start
}}
</div>
<br>
-----

===IC10 Schmitt Trigger - Sensor Range Based Device Toggle===
This script demonstrates the IC10 style Schmitt Trigger Pattern in basic examples using the <code>select</code> instruction with its ternary condition to toggle a device <code>On</code> state based on a range of sensor readings. Examples for both styles are provided below, i.e. 'cooling' or 'heating', for 'below min' or 'greater than max' style range-based toggle. A temperature based control is shown in the examples, but any sensor reading could be used to dynamically toggle a device <code>On</code> state such pressure, charge ratio, solar angle, etc.

<div class="mw-collapsible mw-collapsed" data-expandtext="{{int:Expand, IC10 Schmitt Trigger Pattern}}" data-collapsetext="{{int:Collapse, IC10 Schmitt Trigger Pattern}}">
{{ICCode|
# ---- IC10 Schmitt Trigger ----
# -- Standard - i.e. "cooling"

#When the temperature sensor device reports a value
# higher than TempMax and the valve is not On, the
# valve will turn On.

#When the valve is On, and the sensor device reports
# higher than TempMin, the valve will remain on.

#Once that sensor reports a temperature lower than
# TempMin, the valve will once again shut off and
# this cycle will continue indefinitely:

define TempMax 296.15 #23C
define TempMin 283.15 #10C

alias Valve d0
alias Sensor d1

example1:
yield
l r0 Valve On
select r0 r0 TempMin TempMax
l r1 Sensor Temperature
sgt r0 r1 r0
s Valve On r0
j example1

# ---- IC10 Schmitt Trigger ----
# -- Inverted - i.e. "heating"
#When the temperature sensor device reports a value
# lower than TempMin and the valve is not On, the
# valve will turn On.

#When the valve is On, and the sensor device reports
# lower than TempMax, the valve will remain on.

#Once that sensor reports a temperature higher than
# TempMax, the valve will once again shut off and
# this cycle will continue indefinitely:

define TempMax 296.15 #23C
define TempMin 283.15 #10C

alias Valve d0
alias Sensor d1

example2:
yield
l r0 Valve On
select r0 r0 TempMax TempMin
l r1 Sensor Temperature
slt r0 r1 r0
s Valve On r0
j example2

}}
</div>
<br>
-----

===Example experiment: how many lines of code are executed each tick?===
To determine this, a script without <code>yield</code> will be used. It should have as few lines as possible (so no labels are used, but a reset value at the top will be needed) and count the number of lines, the IC Housing will be used to display the result.
{{ICCode|
move r0 1 #the first line has number 0
add r0 r0 3
s db Setting r0
j 1
}}

Result (the numbers appears every 0.5 seconds):
<br>127
<br>256 (+129)
<br>385 (+129)
<br>511 (+126)
<br>640 (+129)
<br>769 (+129)
<br>895 (+126)
<br>1024 (+129)
<br>1153 (+129)

There is a repeating +129, +129, +126 sequence, a hint that the real value is 128. Which also happens to be the number of lines in a script, which makes sense. A variation of this experiment will show that empty rows are also counted towards this number.

===Push & Pop return address when calling multiple levels of functions===
More advanced scripts, or scripts that wish to be more generic, may want to allow calling more than one level of function. Allowing this requires pushing the current <code>ra</code> register before calling the function, then popping <code>ra</code> back afterward.

For example, imagine that the main loop of the code wants to call function <code>orientPanelsToStar</code>, which would calculate the panels' orientations, then place them in <code>r0</code> and <code>r1</code>, and then in turn itself call <code>orientPanelsTo</code>, which would set the orientations of all panels based on the precomputed values of <code>r0</code> and <code>r1</code>. Doing so requires <code>orientPanelsToStar</code> to push <code>ra</code> before calling <code>orientPanelsTo</code>, as show in the code below.

{{ICCode|
orientPanelsToStar:
# Save return address set by the 'jal' instruction
push ra

# ...Calculate panels' orientation, for example leaving the results in r0 and r1...

# Now call orientPanelsTo to actually set the panels' orientation
# based on the computed values of r0 and r1.
jal orientPanelsTo

# ...Call other functions here if desired...

# Restore the return address of orientPanelsToStar itself
pop ra
# Return to caller
j ra

##########

orientPanelsTo:
# ...Actually set panels' orientation...

# Return to caller
j ra
}}

This code would behave incorrectly if <code>push ra</code> and <code>pop ra</code> were not present: within <code>orientPanelsToStar</code>, doing <code>jal orientPanelsTo</code> would replace the current value of the <code>ra</code> register, permanently erasing where <code>orientPanelsToStar</code> itself should jump back to once done. Pushing and popping <code>ra</code> effectively saves its value until we need it again.

(A tempting but wrong approach to 'saving' <code>ra</code> would be to <code>move</code> it within a different register (e.g. <code>r15</code>) before calling <code>orientPanelsTo</code>, however that only permits two levels of functions, since if <code>orientPanelsTo</code> itself wants to call another function, it would not be able to use <code>r15</code> to save its <code>ra</code> register since <code>r15</code> already saves <code>orientPanelsToStar</code>'s return address. Just pushing/popping <code>ra</code> fixes all issues, allowing for a ginormous maximum function call depth of 512!)

As a last note, if the script will push/pop values like <code>ra</code>, starting the script by clearing the stack (which where push/pop move the data to) by running <code>clr db</code> is advisable, unless the IC10 chip is not inserted inside an IC Housing (e.g. inserted in the slot of an Air Conditioner), since <code>clr db</code> will cause an error in this case. To do so, run <code>clr db</code> before the script's main loop.

----

=Links=
----
* Stationeers online IC10 Emulators so you can develop your code without repeatedly dying in game
** [https://ic10.dev/] Stationeers Code Simulator
** [https://ic10emu.dev] Stationeers IC10 Editor & Emulator - A feature packed code editor for Stationeers IC10 code, paired with a robust debugger and emulator. Edit, test, and share code.
** [https://stationeering.com/tools/ic] Stationeering provides a simulation of the IC10 chip inside Stationeers. IDE with error checking, full visibility of stack and registers.
* [http://www.easy68k.com/] EASy68K is a 68000 Structured Assembly Language IDE.
* [https://marketplace.visualstudio.com/items?itemName=Traineratwot.stationeers-ic10] syntax highlighting for IC10 MIPS for Visual Studio Code (updated Feb 10th 2022)
* [https://pastebin.com/6Uw1KSRN] syntax highlighting for IC10 MIPS for KDE kwrite/kate text editor
* [https://drive.google.com/file/d/1yEsJ-u94OkuMQ8K6fY7Ja1HNpLcAdjo_/view] syntax highlighting for IC10 MIPS for Notepad++
* [https://drive.google.com/file/d/1Xrv5U0ZI5jDcPv7yX7EAAxaGk5hKP0xO/view?usp=sharing] syntax highlighting for IC10 MIPS for Notepad++ (updated: 11/08/2022)
* [https://pastebin.com/3kmGy0NN] syntax highlighting for IC10 MIPS for Notepad++ (updated: 23/03/2024)
* [https://github.com/SnorreSelmer/stationeers_ic10/blob/main/README.md] Repo with a lot of code examples
----

=Index=
----

{|
|+Functions
<div class="mw-collapsible mw-collapsed">
*[[#abs|abs]]
*[[#add|add]]
*[[#alias|alias]]
*[[#and|and]]
*[[#beq|beq]]
*[[#bgez|bgez]]
*[[#bgtz|bgtz]]
*[[#blez|blez]]
*[[#bltz|bltz]]
*[[#bne|bne]]
*[[#breq|breq]]
*[[#brgez|brgez]]
*[[#brgtz|brgtz]]
*[[#brlez|brlez]]
*[[#brltz|brltz]]
*[[#brne|brne]]
*[[#ceil|cell]]
*[[#div|div]]
*[[#exp|exp]]
*[[#floor|floor]]
*[[#j|j]]
*[[#jr|jr]]
*[[#l|l]]
*[[#log|log]]
*[[#ls|ls]]
*[[#max|max]]
*[[#min|min]]
*[[#mod|mod]]
*[[#move|move]]
*[[#mul|mul]]
*[[#nor|nor]]
*[[#or|or]]
*[[#rand|rand]]
*[[#round|round]]
*[[#s|s]]
*[[#slt|slt]]
*[[#sqrt|sqrt]]
*[[#sub|sub]]
*[[#trunc|trunc]]
*[[#xor|xor]]xor
*[[#yield|yield]]
*[[##|#]]
</div>

|+Device Variables
<div class="mw-collapsible mw-collapsed">
*[[#Activate|Activate]]
*[[#AirRelease|AirRelease]]
*[[#Charge|Charge]]
*[[#CLearMemory|CLearMemory]]
*[[#Color|Color]]
*[[#CompletionRatio|CompletionRatio]]
*[[#ElevatorLevel|ElevatorLevel]]
*[[#ElevatorSpeed|ElevatorSpeed]]
*[[#Error|Error]]
*[[#ExportCount|ExportCount]]
*[[#Filtration|Filtration]]
*[[#Harvest|Harvest]]
*[[#Horizontal|Horizontal]]
*[[#HorizontalRatio|HorizontalRatio]]
*[[#Idle|Idle]]
*[[#ImportCount|ImportCount]]
*[[#Lock|Lock]]
*[[#Maximum|Maximum]]
*[[#Mode|Mode]]
*[[#On|On]]
*[[#Open|Open]]
*[[#Output|Output]]
*[[#Plant|Plant]]
*[[#PositionX|PositionX]]
*[[#PositionY|PositionY]]
*[[#PositionZ|PositionZ]]
*[[#Power|Power]]
*[[#PowerActual|PowerActual]]
*[[#PowerPotential|PowerPotential]]
*[[#PowerRequired|PowerRequired]]
*[[#Pressure|Pressure]]
*[[#PressureExternal|PressureExternal]]
*[[#PressureInteral|PressureInteral]]
*[[#PressureSetting|PressureSetting]]
*[[#Quantity|Quantity]]
*[[#Ratio|Ratio]]
*[[#RatioCarbonDioxide|RatioCarbonDioxide]]
*[[#RatioNitrogen|RatioNitrogen]]
*[[#RatioOxygen|RatioOxygen]]
*[[#RatioPollutant|RatioPollutant]]
*[[#RatioVolatiles|RatioVolatiles]]
*[[#RatioWater|RatioWater]]
*[[#Reagents|Reagents]]
*[[#RecipeHash|RecipeHash]]
*[[#RequestHash|RequestHash]]
*[[#RequiredPower|RequiredPower]]
*[[#Setting|Setting]]
*[[#SolarAngle|SolarAngle]]
*[[#Temperature|Temperature]]
*[[#TemperatureSettings|TemperatureSettings]]
*[[#TotalMoles|TotalMoles]]
*[[#VelocityMagnitude|VelocityMagnitude]]
*[[#VelocityRelativeX|VelocityRelativeX]]
*[[#VelocityRelativeY|VelocityRelativeY]]
*[[#VelocityRelativeZ|VelocityRelativeZ]]
*[[#Vertical|Vertical]]
*[[#VerticalRatio|VerticalRatio]]
*[[#Volume|Volume]]

</div>

|+Slot Variables
<div class="mw-collapsible mw-collapsed">
*[[#Occupied|Occupied]]
*[[#OccupantHash|OccupantHash]]
*[[#Quantity|Quantity]]
*[[#Damage|Damage]]
*[[#Efficiency|Efficiency]]
*[[#Health|Health]]
*[[#Growth|Growth]]
*[[#Pressure|Pressure]]
*[[#Temperature|Temperature]]
*[[#Charge|Charge]]
*[[#ChargeRatio|ChargeRatio]]
*[[#Class|Class]]
*[[#PressureWaste|PressureWaste]]
*[[#PressureAir|PressureAir]]
*[[#MaxQuantity|MaxQuantity]]
*[[#Mature|Mature]]
</div>

|}

Module:IC10

2026-02-20T06:27:35Z

TK421: fixing broken strings in IC10

2026-01-21T04:36:40Z

TK421: Added new 'requires frame' to medium dish infobox

[[Category:Machines]]
[[Category:Items]]
{{Itembox
| name = Kit (Satellite Dish)
| stacks = 10
| image = [[File:ItemKitSatelliteDish.png]]
| createdwith = [[Electronics Printer]]
| cost = 5g [[Gold]], 10g [[Copper]], 20g [[Steel]], 5g [[Nickel]], 10g [[Solder]]
}}
{{Structurebox
| name = Medium Satellite Dish
| image = [[File:StructureSatelliteDish.png]]
| power_usage = 200W
| placed_with_item = [[Satellite Dish|Kit (Satellite Dish)]]
| placed_on_grid = Small Grid
| requires_frames = Yes
| decon_with_tool1 = [[Hand Drill]]
| item_rec1 = [[Satellite Dish|Kit (Satellite Dish)]]
}}

{{outdated}}
==Description==
Small Satellite Dish
{{Description|The small communications unit can be used to communicate with nearby trade vessels.}}
Medium Satellite Dish
{{Description|The medium communications unit can be used to communicate with nearby trade vessels.}}
Either the small or medium Satellite Dish, or even the [[Large Satellite Dish]] are used together with a [[Computer]] fitted with a [[Motherboard (Communications)]] to allow Interstellar Communications.

The Satellite Dish must be guided by [[Satellite Tracking]] onto a signal and communications may be established once the signal strength is greater than 94%

== Medium Satellite Dish ==
=== Data Network Properties ===
<div class="mw-customtoggle-datanetworkproperties" style="width:auto; overflow:auto; text-indent:10px; border: 2px solid #253C60; border-radius:10px;"><b>Click here to see/hide all the <span style="color:#E57125;">data network properties</span></b></div>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-datanetworkproperties"><br>{{:Kit_(Satellite_Dish)/Data_Network}}</div>

== Stack Usage ==
After "Big Changes Coming: Terrain Preview, Melting Ice, Modding, & Localization" update, Medium Satellite Dish has internal stack like Autolathe, which user can utilize it to give instructions to.
The Medium Satellite Dish currently have 256Bytes(32 Addresses) stack memory.

Pro tips:
* Everyday there will be only 3 vessels, one for each shuttle tier, in addition to special trader types.
* Everyday the 3 vessels will be refreshed, the algorithm for which type of vessel to appear is random, but strictly 1 for each tier, in addition to special trader types.
* It's best to use 500 watts if you are using medium satellite dish to scan, 500 watts is just large enough for the FAR tier to appear on the radar, but small enough for it's signal being masked by lower tier shuttles.

<pre style="color: red">
Warning:
Internally every tick the stack data will be cleared and regenerated,
so don't OVERWRITE any TraderInstruction.Write* instructions when setting the WRITE_INDEX and WRITE_COUNT.
</pre>

<div class="overflowbugx" style="overflow-x:auto;">
{| class="wikitable sortable" style="width:50%;"
! Op_code
! class="unsortable" | Name
! class="unsortable" | Description
! class="unsortable" | Valid Address
! class="unsortable" | Bits
! class="unsortable" | Bits Description
|-

! rowspan="3" | 1
| rowspan="3" | TraderInstruction.WriteTraderData
| rowspan="3" | The dish will write out metadata(24 Bytes, in continuous of 3 addresses) to the specified starting index. E.g.: if set WRITE_INDEX to 1, then the metadata will span address 1-3. See [[#Metadata_Payloads|Metadata Payload]]s.
| rowspan="3" | 0-31
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-15
| WRITE_INDEX
|-
| style="text-align:center;" | 16-63
| Unused
|-
! rowspan="3" | 2
| rowspan="3" | TraderInstruction.StrongestContactIdHash
| rowspan="3" | This OpCode indicates the data generated by TraderInstruction.WriteTraderData payload segment 1.
| rowspan="3" | 0-31
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-39
| TRADER_ID_HASH
|-
| style="text-align:center;" | 40-63
| Unused
|-
! rowspan="5" | 3
| rowspan="5" | TraderInstruction.StrongestContactMetaData
| rowspan="5" | This OpCode indicates the data generated by TraderInstruction.WriteTraderData payload segment 2.
| rowspan="5" | 0-31
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-15
| [[#Metadata_Payloads|SHUTTLE_TYPE]].
|-
| style="text-align:center;" | 16-23
| [[#Metadata_Payloads|CONTACT_TIER]].
|-
| style="text-align:center;" | 24-31
| [[#Metadata_Payloads|CONTACTED]].
|-
| style="text-align:center;" | 32-63
| Unused
|-
! rowspan="4" | 4
| rowspan="4" | TraderInstruction.StrongestContactSignalData
| rowspan="4" | This OpCode indicates the data generated by TraderInstruction.WriteTraderData payload segment 3.
| rowspan="4" | 0-31
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-23
| WATTS_TO_RESOLVE<br/>See [[Trader#Trader_Tier |WattsToResolve]].
|-
| style="text-align:center;" | 24-39
| LIFETIME<br/>See [[Trader#Trader_Tier|LifeTime]].
|-
| style="text-align:center;" | 32-63
| Unused
|-
! rowspan="4" | 5
| rowspan="4" | TraderInstruction.WriteTraderBuyData
| rowspan="4" | The dish will write out trader buy metadatas from the starting address WRITE_INDEX, and write WRITE_COUNT continuous addresses total.<br/>If an item contains child items, then it will be expaned inplace.<br/>E.g.: <BuyPayload><BuyPayload><BuyChildPayload><BuyPayload>.<br/>See [[#Buy.2FSell_Payloads|Buy/Sell Payloads]], [[#Buy.2FSell_Child_Payloads|Buy/Sell Child Payloads]].<br/>WRITE_COUNT=0 means WRITE_COUNT=1.
| rowspan="4" | 0-31
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-15
| WRITE_INDEX
|-
| style="text-align:center;" | 16-23
| WRITE_COUNT
|-
| style="text-align:center;" | 24-63
| Unused
|-
! rowspan="4" | 6
| rowspan="4" | TraderInstruction.WriteTraderSellData
| rowspan="4" | The dish will write out trader sell metadatas from the starting address WRITE_INDEX, and write WRITE_COUNT continuous addresses total.<br/>If an item contains child items, then it will be expaned inplace.<br/>E.g.: <SellPayload><SellPayload><SellChildPayload><SellPayload>.<br/>See [[#Buy.2FSell_Payloads |Buy/Sell Payloads]], [[#Buy.2FSell_Child_Payloads|Buy/Sell Child Payloads]].<br/>WRITE_COUNT=0 means WRITE_COUNT=1.
| rowspan="4" | 0-31
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-15
| WRITE_INDEX
|-
| style="text-align:center;" | 16-23
| WRITE_COUNT
|-
| style="text-align:center;" | 24-63
| Unused
|-
! rowspan="4" | 7
| rowspan="4" | TraderInstruction.TraderBuyThingData
| rowspan="4" | This OpCode indicates the data generated by TraderInstruction.WriteTraderBuyData.
| rowspan="4" | 0-31
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-15
| QUANTITY
|-
| style="text-align:center;" | 16-47
| PREFAB_HASH
|-
| style="text-align:center;" | 48-63
| Unused
|-
! rowspan="4" | 8
| rowspan="4" | TraderInstruction.TraderBuyThingChildData
| rowspan="4" | This OpCode indicates the data generated by TraderInstruction.WriteTraderBuyData.
| rowspan="4" | 0-31
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-15
| QUANTITY
|-
| style="text-align:center;" | 16-47
| PREFAB_HASH
|-
| style="text-align:center;" | 48-63
| Unused
|-
! rowspan="4" | 9
| rowspan="4" | TraderInstruction.TraderBuyGasData
| rowspan="4" | This OpCode indicates the data generated by TraderInstruction.WriteTraderBuyData.
| rowspan="4" | 0-31
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-15
| QUANTITY
|-
| style="text-align:center;" | 16-47
| GAS_TYPES_BITFLAG<br/>See [[#Gas_Type_BitFlags|Gas_Type_BitFlags]].
|-
| style="text-align:center;" | 48-63
| Unused
|-
! rowspan="4" | 10
| rowspan="4" | TraderInstruction.TraderSellThingData
| rowspan="4" | This OpCode indicates the data generated by TraderInstruction.WriteTraderSellData.
| rowspan="4" | 0-31
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-15
| QUANTITY
|-
| style="text-align:center;" | 16-47
| PREFAB_HASH
|-
| style="text-align:center;" | 48-63
| Unused
|-
! rowspan="4" | 11
| rowspan="4" | TraderInstruction.TraderSellGasData
| rowspan="4" | This OpCode indicates the data generated by TraderInstruction.WriteTraderSellData.
| rowspan="4" | 0-31
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-15
| QUANTITY
|-
| style="text-align:center;" | 16-47
| GAS_TYPES_BIGFLAG<br/>See [[#Gas_Type_BitFlags|Gas_Type_BitFlags]].
|-
| style="text-align:center;" | 48-63
| Unused
|-
! rowspan="4" | 12
| rowspan="4" | TraderInstruction.TraderSellThingChildData
| rowspan="4" | This OpCode indicates the data generated by TraderInstruction.WriteTraderSellData.
| rowspan="4" | 0-31
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-15
| QUANTITY
|-
| style="text-align:center;" | 16-47
| PREFAB_HASH
|-
| style="text-align:center;" | 48-63
| Unused
|-
! rowspan="3" | 13
| rowspan="3" | TraderInstruction.FilterPrefabHashEquals
| rowspan="3" | Filter Operation.<br/>User can prepend this OP before any TraderInstruction.Write* OP to filter writer's output.<br/>Multple filter OP can be written to the addresses before a Write* OP to group as a "AND" condition.<br/>This Filter narrows Write* OP's output to only matching PrefabHash.
| rowspan="3" | 1-30
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-39
| PREFAB_HASH
|-
| style="text-align:center;" | 40-63
| Unused
|-
! rowspan="3" | 14
| rowspan="3" | TraderInstruction.FilterPrefabHashNotEquals
| rowspan="3" | Filter Operation.<br/>User can prepend this OP before any TraderInstruction.Write* OP to filter writer's output.<br/>Multple filter OP can be written to the addresses before a Write* OP to group as a "AND" condition.<br/>This Filter narrows Write* OP's output to only not matching PrefabHash.
| rowspan="3" | 1-30
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-39
| PREFAB_HASH
|-
| style="text-align:center;" | 40-63
| Unused
|-
! rowspan="4" | 15
| rowspan="4" | TraderInstruction.FilterSortingClassCompare
| rowspan="4" | Filter Operation.<br/>User can prepend this OP before any TraderInstruction.Write* OP to filter writer's output.<br/>Multple filter OP can be written to the addresses before a Write* OP to group as a "AND" condition.<br/>This Filter narrows Write* OP's output to only matching SortingClass.
| rowspan="4" | 1-30
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-15
| CONDITION_OPERATION<br/>0: Equals<br/>1: Greater<br/>2: Less<br/>3: Not Equals
|-
| style="text-align:center;" | 16-31
| SORTING_CLASS<br/>See [[Sorting_Class]].
|-
| style="text-align:center;" | 32-63
| Unused
|-
! rowspan="4" | 16
| rowspan="4" | TraderInstruction.FilterQuantityCompare
| rowspan="4" | Filter Operation.<br/>User can prepend this OP before any TraderInstruction.Write* OP to filter writer's output.<br/>Multple filter OP can be written to the addresses before a Write* OP to group as a "AND" condition.<br/>This Filter narrows Write* OP's output to only matching Quantity Condition.
| rowspan="4" | 1-30
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-15
| CONDITION_OPERATION<br/>0: Equals<br/>1: Greater<br/>2: Less<br/>3: Not Equals
|-
| style="text-align:center;" | 16-31
| QUANTITY
|-
| style="text-align:center;" | 32-63
| Unused
|-
! rowspan="3" | 17
| rowspan="3" | TraderInstruction.FilterGasContains
| rowspan="3" | Filter Operation.<br/>User can prepend this OP before any TraderInstruction.Write* OP to filter writer's output.<br/>Multple filter OP can be written to the addresses before a Write* OP to group as a "AND" condition.<br/>This Filter narrows Write* OP's output to only matching Gases.
| rowspan="3" | 1-30
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-39
| GAS_TYPES_BITFLAG<br/>See [[#Gas_Type_BitFlags|Gas_Type_BitFlags]].
|-
| style="text-align:center;" | 40-63
| Unused
|-
! rowspan="3" | 18
| rowspan="3" | TraderInstruction.FilterGasNotContains
| rowspan="3" | Filter Operation.<br/>User can prepend this OP before any TraderInstruction.Write* OP to filter writer's output.<br/>Multple filter OP can be written to the addresses before a Write* OP to group as a "AND" condition.<br/>This Filter narrows Write* OP's output to only not matching Gases.
| rowspan="3" | 1-30
| style="text-align:center;" | 0-7
| Op_code
|-
| style="text-align:center;" | 8-39
| GAS_TYPES_BITFLAG<br/>See [[#Gas_Type_BitFlags|Gas_Type_BitFlags]].
|-
| style="text-align:center;" | 40-63
| Unused
|}
</div>

=== Metadata Payloads ===

Since Metadata has 3 addresses, so it's referenced here as a 24 bytes(192 bits) payload.

<div class="overflowbugx" style="overflow-x:auto;">
{| class="wikitable" style="width:80%;"
! BitsOffset
| 63-40
| 39-8
| 7-0
|-
! Segment 1
| All bits value in this section is the deplicate of bit 39.
| TraderIdHash
| OpCode of TraderInstruction.StrongestContactIdHash.
|-
! BitsOffset
| 63-32
| 31-24
| 23-16
| 15-8
| 7-0
|-
! Segment 2
| All bits 0.
| Contacted<br/>0: false<br/> 1: true
| Contact Tier: <br/>0: Close<br/>1: Medium<br/>2: Far
| Shuttle Type: <br/>0:None<br/>1: Small(3x3)<br/>2: SmallGas(3x3)<br/>3: Medium(5x5)<br/>4: MediumGas(5x5)<br/>5: Large(6x6)<br/>6: LargeGas(6x6)<br/>7: MediumPlane(7x7, runway:15)<br/>8: LargePlane(9x9, runway:20)
| OpCode of TraderInstruction.StrongestContactMetaData.
|-
! BitsOffset
| 63-40
| 39-24
| 23-8
| 7-0
|-
! Segment 3
| ALl bits 0.
| [[Trader#Trader_Tier|LifeTime]]
| [[Trader#Trader_Tier|WattsToResolve]]
| OpCode of TraderInstruction.StrongestContactSignalData.
|}
</div>

=== Buy/Sell Payloads ===

Buy/Sell Payloads are 1 address each, so it's referenced here as a 8 bytes(64 bit) payload.

<div class="overflowbugx" style="overflow-x:auto;">
{| class="wikitable" style="width:60%;"
! BitsOffset
| 63-48
| 47-16
| 15-8
| 7-0
|-
! Contents
| Every bit's value is the same as bit 47.
| PrefabHash/GasTypeBitFlag
| Quantity<br/>This value is truncated so it won't be greater than 255 although the trader's Request/Stock is more than 255.
| OpCode<br/>Data type represented as OpCode, one of the OpCode 7, 9, 10, 11.
|}
</div>

=== Buy/Sell Child Payloads ===

Buy/Sell Payloads are 1 address each, so it's referenced here as a 8 bytes(64 bit) payload.

<div class="overflowbugx" style="overflow-x:auto;">
{| class="wikitable" style="width:60%;"
! BitsOffset
| 63-48
| 47-16
| 15-8
| 7-0
|-
! Contents
| Every bit's value is the same as bit 47.
| PrefabHash/GasTypeBitFlag
| ChildCount<br/>Counts how many instances of this item appeared as a child item.<br/>Beware it's not quantity, it's just a prefab type count.
| OpCode<br/>If this data is requested by TraderInstruction.WriteTraderBuyData, then it's value is the OpCode of TraderInstruction.TraderBuyThingChildData.<br/>If this data is requested by TraderInstruction.WriteTraderSellData, then it's value is the OpCode of TraderInstruction.TraderSellThingChildData.
|}
</div>

=== Gas Type BitFlags ===

If the BitFlag equals 0, it's undefined. If the bit at specific offset is 1, it means the gas contains that component.

<div class="overflowbugx" style="overflow-x:auto;">
{| class="wikitable" style="width:60%;"
! BitsOffset
| 16
| 15
| 14
| 13
| 12
| 11
| 10
| 9
| 8
| 7
| 6
| 5
| 4
| 3
| 2
| 1
| 0
|-
! Contents
| PollutedWater
| LiquidHydrogen
| Hydrogen
| LiquidNitrousOxide
| LiquidPollutant
| LiquidCarbonDioxide
| Steam
| LiquidVolatiles
| LiquidOxygen
| LiquidNitrogen
| NitrousOxide
| Water
| Pollutant
| Volatiles
| CarbonDioxide
| Nitrogen
| Oxygen
|}
</div>

Special Gas:
# Bit 0,1 both set to 1, which is Air.
# Bit 0,3 both set to 1, which is Fuel.

==Stack Programming Reference Implementation==

<pre style="color: red">
Warning:
The following code is a reference implementation, it only serve the purpose to
assist you to observe the possibility and help you write your own code.
You must write your own code to fully enjoy the game.
</pre>

=== Shuttle Cargoes Looking Glasses ===

The Looking Glasses are purely for cargo inspection, no filter, no auto negotiate and call-down.

Materials to prepare:
* A Medium Satellite Dish.
* Any number of [[Kit_(Logic_Memory)|Logic Memories]] for '''Prefab''' [[Console|Console]] display (if there are more Prefabs to display than your number of [[Kit_(Logic_Memory)|Logic Memories]], they will be ignored).
* Corresponding number of [[Circuitboard|Hash Displays]] and [[Console|Consoles]].
* Any number of [[Kit_(Logic_Memory)|Logic Memories]] for '''Gas''' [[Console|Console]] display, (if there are more GasLiquid to display than your number of [[Kit_(Logic_Memory)|Logic Memories]], they will be ignored).
* Corresponding number of [[Circuitboard|Hash Displays]] and [[Console|Consoles]].
* 1 [[Kit_(Switch)#Switch|Logic Switch]] for switch trader's sell/buy data.
* 6 [[Console|Console]] for Small LED installation (all will show metadata).
* 1 [[Kit_(IC_Housing)|Kit (IC Housing)]] and 1 [[Integrated_Circuit_(IC10)|Integrated Circuit (IC10)]].

Installation:
* Install all of the [[Kit_(Logic_Memory)|Logic Memories]].
* Install corresponding '''Prefab''' [[Console|Consoles]], insert [[Circuitboard|Hash Displays]], and make sure the [[Circuitboard|Hash Displays]] are set to '''Prefab''' display mode: <code>Mode=0</code>
* Install corresponding '''Gas''' [[Console|Consoles]], insert [[Circuitboard|Hash Displays]], and make sure the [[Circuitboard|Hash Displays]] are set to '''GasLiquid''' display mode: <code>Mode=1</code>
{{ICCode|
# example for setup GasLiquid mode
ss d0 0 Mode 1 # d0 is console pin
# or configure all the Consoles in the IcHousing's subnetwork
sbs StructureConsole 0 Mode 1
}}
* Naming each [[Kit_(Logic_Memory)|Logic Memory]] sequentially for two display types, for example: <code>SLMP1</code>, <code>SLMP2</code> for '''Prefab''' display, and <code>SLMG1</code>, <code>SLMG2</code> for '''GasLiquid''' display.
* Manually configure all [[Console|Consoles]] to link to their corresponding [[Kit_(Logic_Memory)|Logic Memories]] with [[Data_Disk|Data Disk]].
* Install 1 [[Kit_(Switch)#Switch|Logic Switch]] for switch trader's sell/buy data, <code>Open</code> shows trader's Buy data, <code>Close</code> shows trader's Sell data. Label it <code>TRADER_SELL_BUY_SWITCH</code>.
* Install 1 [[Kit_(IC_Housing)|Kit (IC Housing)]] in the same subnetwork and label it <code>Cargo LG IC Housing</code>, insert a [[Integrated_Circuit_(IC10)|Integrated Circuit (IC10)]].
* Install 6 LED and labeling them: <code>LED_SIGID</code>, <code>LED_CON_TYPE_ID</code>, <code>LED_TIER</code>, <code>LED_SHUTTLE_TYPE</code>, <code>LED_WATT_TO_RESOLVE</code>, <code>LED_CONTACTED</code>.

Reference Implementation:

Next are the code snippets for a setup of 20 '''Prefab''' Console and 11 '''GasLiquid''' Console looking glass.

First snippet is the initialization/configuration code, which should be write to the [[Integrated_Circuit_(IC10)|Integrated Circuit (IC10)]] for the first time, add/remove the [[Kit_(Logic_Memory)|Logic Memories]] stack entries that you actually used in your setup, then install the chip to housing.
{{ICCode|
# Shuttle Cargoes Looking Glasses IC Stack Initializer

clr db
move sp 0
# Prefab display Logic Memories, add/remove according to your setup.
push HASH("SLMP1")
push HASH("SLMP2")
push HASH("SLMP3")
push HASH("SLMP4")
push HASH("SLMP5")
push HASH("SLMP6")
push HASH("SLMP7")
push HASH("SLMP8")
push HASH("SLMP9")
push HASH("SLMP10")
push HASH("SLMP11")
push HASH("SLMP12")
push HASH("SLMP13")
push HASH("SLMP14")
push HASH("SLMP15")
push HASH("SLMP16")
push HASH("SLMP17")
push HASH("SLMP18")
push HASH("SLMP19")
push HASH("SLMP20")
move r13 sp

# GasLiquid display Logic Memories, add/remove according to your setup.
push HASH("SLMG1")
push HASH("SLMG2")
push HASH("SLMG3")
push HASH("SLMG4")
push HASH("SLMG5")
push HASH("SLMG6")
push HASH("SLMG7")
push HASH("SLMG8")
push HASH("SLMG9")
push HASH("SLMG10")
push HASH("SLMG11")
move r12 sp
}}

Second snippet is for the same [[Integrated_Circuit_(IC10)|Integrated Circuit (IC10)]], take your IC10 chip out re-put it into the laptop, clear and paste in the new second code snippet.

There are a few user variables need to modify, please check the in-line comments. Mostly that's for LEDs to display metadata. Change the variables accordingly then insert the IC10 chip into the housing.

{{ICCode|
# Shuttle Cargoes Looking Glasses Runtime IC10
#
# User variable:
#
# DishM: The Medium Dish hash.
# LED_SIGID: The LED name, show SignalID.
# LED_CON_TYPE_ID: The LED name, show ContactTypeID.
# LED_TIER: The LED name, show Tier.
# LED_SHUTTLE_TYPE: The LED name, show Shuttle Type.
# LED_CONTACTED: The LED name, show if the shuttle has been contacted already.
define DishM HASH("Medium Satellite Dish 1")
define LED_SIGID HASH("LED_SIGID")
define LED_CON_TYPE_ID HASH("LED_CON_TYPE_ID")
define LED_TIER HASH("LED_TIER")
define LED_SHUTTLE_TYPE HASH("LED_SHUTTLE_TYPE")
define LED_WATT_TO_RESOLVE HASH("LED_WATT_TO_RESOLVE")
define LED_CONTACTED HASH("LED_CONTACTED")
define TRADER_BUY_SEEL_SWITCH HASH("TRADER_SELL_BUY_SWITCH")
###############################################################################
define SSD HASH("StructureSatelliteDish")
define SLM HASH("StructureLogicMemory")
define OpcodeMask %11111111
alias dishMID r15
alias dishEntryCount r14
alias prefabMemCount r13
alias totalMemCount r12
alias prefabMemCursor r11
alias gasMemCursor r10
alias sellOrBuy r9

mainloop:
jal WriteStack
jal Display
jal ClearPrefabMem
jal ClearGasMem
sleep 1
j mainloop
WriteStack:
lbn dishMID SSD DishM ReferenceId Average
bnan dishMID ra
lbn r0 HASH("StructureLogicSwitch2") TRADER_BUY_SEEL_SWITCH Open Average
brgtz r0 3
move sellOrBuy TraderInstruction.WriteTraderSellData
jr 2
move sellOrBuy TraderInstruction.WriteTraderBuyData
clrd dishMID
sll r0 1 8
or r0 r0 TraderInstruction.WriteTraderData
putd dishMID 0 r0
sll r0 30 16
sll r1 5 8
or r0 r0 r1
or r0 r0 sellOrBuy
putd dishMID 4 r0
sleep 1
j ra
Display:
lbn r1 SSD DishM SignalID Average
sbn HASH("StructureConsoleLED5") LED_SIGID Setting r1
move dishEntryCount 0
move prefabMemCursor 0
move gasMemCursor prefabMemCount
DisplayLoop:
beq dishEntryCount 31 ra
add dishEntryCount dishEntryCount 1
getd r0 dishMID dishEntryCount
and r1 r0 OpcodeMask
beq r1 2 MetaData1
beq r1 3 MetaData2
beq r1 4 MetaData3
beq r1 7 ThingData
beq r1 8 ThingData
beq r1 9 GasData
beq r1 10 ThingData
beq r1 11 GasData
beq r1 12 ThingData
j DisplayLoop
MetaData1:
sra r2 r0 8 # trader contact type id
sbn HASH("StructureConsoleLED5") LED_CON_TYPE_ID Setting r2
j DisplayLoop
MetaData2:
and r2 r0 %11111111_00000000_00000000_00000000
sra r2 r2 24 # contacted
sbn HASH("StructureConsoleLED5") LED_CONTACTED Setting r2
and r2 r0 %11111111_00000000_00000000
sra r2 r2 16 # tier
sbn HASH("StructureConsoleLED5") LED_TIER Setting r2
and r2 r0 %11111111_00000000
sra r2 r2 8 # shuttle type
sbn HASH("StructureConsoleLED5") LED_SHUTTLE_TYPE Setting r2
j DisplayLoop
MetaData3:
and r2 r0 %11111111_11111111_00000000
sra r2 r2 8 # watts to resolve
sbn HASH("StructureConsoleLED5") LED_WATT_TO_RESOLVE Setting r2
j DisplayLoop
ThingData:
get r2 db prefabMemCursor # memory chip
sra r3 r0 16 # prefab hash
sbn SLM r2 Setting r3
add prefabMemCursor prefabMemCursor 1
j DisplayLoop
GasData:
get r2 db gasMemCursor # memory chip
sra r3 r0 16
sbn SLM r2 Setting r3
add gasMemCursor gasMemCursor 1
j DisplayLoop
ClearPrefabMem:
move sp prefabMemCursor
ClearPrefabMemLoop:
bge sp prefabMemCount ra
add sp sp 1
peek r0 # memory chip
sbn SLM r0 Setting -1
j ClearPrefabMemLoop
ClearGasMem:
move sp gasMemCursor
ClearGasMemLoop:
bge sp totalMemCount ra
add sp sp 1
peek r0 # memory chip
sbn SLM r0 Setting -1
j ClearGasMemLoop
}}

Final: Now enable the Medium Satellite Dish, enable the Cargo LG IC Housing(the 2nd script should be running), add some power to the dish and rotate it somehow, then check the monitors and LEDs, you will see the items you can shop(trader will sell) from this trader if the logic switch is <code>closed</code>, and you will see the items you can sell(trader will buy) from the best trader if the logic switch is <code>open</code>.

The total setup feels like this
[[File:2025-04-18-1049x333-scrot.png|Overview of Looking Glass Setup]]

=== Shuttle Cargoes Auto Filtration/Interrogation and Call Down ===

To add Auto Filtration/Interrogation ability, prepare following materials in advance. It's build on top of Looking Glass structure of the previous section, take caution.

* Repurpose the IC Housing of the Looking Glass section, label it <code>Trader Filtration IC Housing</code> or a name you like.
* 1 [[Kit_(Logic_Memory)|Logic Memory]], install it and label it <code>SLM_ITEM_FILTER</code>.
* 1 [[Kit_(Switch)#Switch|Logic Switch]] for switching filter prefab/gas data, label it <code>FILTER_GAS_SWITCH</code>.
* 1 [[Console|Console]], install it as Small LED and label it <code>LED_LOCKED_SIGID</code>.
* 1 [[Kit_(IC_Housing)|Kit (IC Housing)]], install it and label it <code>Dish Control IC Housing</code> or a name you like.
* 1 [[Integrated_Circuit_(IC10)|Integrated Circuit (IC10)]] ready for use.
* 1 [[Kit_(Logic_Transmitter)|Logic Transmitter]] for sending audio message to your Hardsuit when trader is landing, label it <code>Hardsuit LT 1</code>, pair it with your [[Hardsuit|hardsuit]] in passive mode.
* 1 Small Satellite Dish for faster Close/Medium shuttle scanning, optional. If you set it up, the power port must face the same direction as the Medium Dish. If you don't, it just take a few more time to scan with the default Medium Satellite Dish for Close/Medium tier shuttles.
* 1 Large Satellite Dish for faster Far tier shuttle interrogation, optional. If you set it up, the power port must face the same direction as the Medium Dish. If you don't, it just take a few more time to interrogate with the default Medium Satellite Dish for Far tier shuttles.

Installation:

Install all things above and power on. For the repurposed <code>Trader Filtration IC Housing</code> code, paste in following code, replacing Looking Glass code(the Lookging Glass's function is still in the code, plus the filtration function), change the <code>DishM</code>'s name as you like.

<pre style="color: red">
Warning:
If you use a brand new IC10 chip for the Trader Filtration IC Housing,
you still need to initialize the IC10 chip with the code of Shuttle Cargoes Looking Glasses IC Stack Initializer,
or the stack will be empty as a stack is an IC10 CHIP property.
</pre>

{{ICCode|
define DishM HASH("Medium Satellite Dish 1")
alias dishMID r15
alias filterGas r14
alias prefabMemCount r13
alias totalMemCount r12
alias prefabMemCursor r11
alias gasMemCursor r10
alias sellOrBuy r9
alias filterItem r7
alias signalID r6
move r5 0 # lastSignalID
mainloop:
move r8 0 # nextAddress
WriteStack:
lbn dishMID HASH("StructureSatelliteDish") DishM ReferenceId Average
bnan dishMID mainloop
lbn r0 HASH("StructureLogicSwitch2") HASH("TRADER_SELL_BUY_SWITCH") Open Average
brgtz r0 3
move sellOrBuy TraderInstruction.WriteTraderSellData
jr 2
move sellOrBuy TraderInstruction.WriteTraderBuyData
clrd dishMID
sll r0 1 8
or r0 r0 TraderInstruction.WriteTraderData
putd dishMID r8 r0
add r8 r8 4
lbn filterGas HASH("StructureLogicSwitch2") HASH("FILTER_GAS_SWITCH") Setting Average
lbn filterItem HASH("StructureLogicMemory") HASH("SLM_ITEM_FILTER") Setting Average
breqz filterItem 8 # skip if filter value is 0
sll r0 filterItem 8
breqz filterGas 3
or r0 r0 TraderInstruction.FilterGasContains
jr 2
or r0 r0 TraderInstruction.FilterPrefabHashEquals
putd dishMID r8 r0
add r8 r8 1
sll r0 30 16
add r1 r8 1
sll r1 r1 8
or r0 r0 r1
or r0 r0 sellOrBuy
putd dishMID r8 r0
yield
Display:
lbn signalID HASH("StructureSatelliteDish") DishM SignalID Average
sbn HASH("StructureConsoleLED5") HASH("LED_SIGID") Setting signalID
move r0 0
move prefabMemCursor 0
move gasMemCursor prefabMemCount
DisplayLoop:
beq r0 31 ClearMem
add r0 r0 1
getd r1 dishMID r0
and r2 r1 %11111111
beq r2 2 MetaData1
beq r2 3 MetaData2
beq r2 4 MetaData3
beq r2 7 ThingData
beq r2 8 ThingData
beq r2 9 GasData
beq r2 10 ThingData
beq r2 11 GasData
beq r2 12 ThingData
j DisplayLoop
MetaData1:
sra r2 r1 8 # trader contact type id
sbn HASH("StructureConsoleLED5") HASH("LED_CON_TYPE_ID") Setting r2
j DisplayLoop
MetaData2:
and r2 r1 %11111111_00000000_00000000_00000000
sra r2 r2 24 # contacted
sbn HASH("StructureConsoleLED5") HASH("LED_CONTACTED") Setting r2
and r2 r1 %11111111_00000000_00000000
sra r2 r2 16 # tier
sbn HASH("StructureConsoleLED5") HASH("LED_TIER") Setting r2
and r2 r1 %11111111_00000000
sra r2 r2 8 # shuttle type
sbn HASH("StructureConsoleLED5") HASH("LED_SHUTTLE_TYPE") Setting r2
j DisplayLoop
MetaData3:
and r2 r1 %11111111_11111111_00000000
sra r2 r2 8 # watts to resolve
sbn HASH("StructureConsoleLED5") HASH("LED_WATT_TO_RESOLVE") Setting r2
and r2 r1 $FFFF_000000
sra r2 r2 24 # lifetime
sbn HASH("StructureConsoleLED5") HASH("LED_LIFETIME") Setting r2
j DisplayLoop
ThingData:
get r2 db prefabMemCursor # memory chip
sra r3 r1 16 # prefab hash
breqz filterItem 3
bne filterItem r3 DisplayLoop
jal LockSignalID
sbn HASH("StructureLogicMemory") r2 Setting r3
add prefabMemCursor prefabMemCursor 1
j DisplayLoop
GasData:
get r2 db gasMemCursor # memory chip
sra r3 r1 16
sgtz r4 filterItem
and r4 r4 filterGas
breqz r4 4
and r4 filterItem r3
beqz r4 DisplayLoop
jal LockSignalID
sbn HASH("StructureLogicMemory") r2 Setting r3
add gasMemCursor gasMemCursor 1
j DisplayLoop
LockSignalID:
lbn r4 HASH("StructureConsoleLED5") HASH("LED_LOCKED_SIGID") Setting Average
bgtz r4 ra
beq signalID r5 ra
sbn HASH("StructureConsoleLED5") HASH("LED_LOCKED_SIGID") Setting signalID
move r5 signalID
j ra
ClearMem:
move sp prefabMemCursor
brge sp prefabMemCount 5
add sp sp 1
peek r0 # memory chip
sbn HASH("StructureLogicMemory") r0 Setting -1
jr -4
move sp gasMemCursor
bge sp totalMemCount mainloop
add sp sp 1
peek r0 # memory chip
sbn HASH("StructureLogicMemory") r0 Setting -1
jr -4
}}

For the <code>Dish Control IC Housing</code> code, paste in following code, change the hash of <code>DishS</code> and <code>DishL</code> names as you have then setted up or not. Search and change the name of <code>Hardsuit LT 1</code> line if you want to send notification to other devices.

{{ICCode|
define DishM HASH("Medium Satellite Dish 1")
define DishS 0 # if you have small dish, set hash to HASH("NAME")
define DishL 0 # if you have large dish, set hash to HASH("NAME")
move r0 0
reset:
move r15 r0 # lockedSigID
move r14 0 # horizontal
move r13 0 # vertical
move r12 0 # horizontalEdge1
move r11 0 # horizontalEdge2
move r10 0 # verticalEdge1
move r9 0 # verticalEdge2
move r8 DishM # commDish
move r7 HASH("StructureSatelliteDish") # commDishType
move r6 DishM # scanDish
move r5 r7 # scanDishType
sbn r5 r6 Vertical 60
sbn r5 r6 BestContactFilter -1
sbn r5 r6 Setting 500
mainloop:
yield
lbn r0 HASH("StructureConsoleLED5") HASH("LED_LOCKED_SIGID") Setting Average
lbn r1 r5 r6 SignalID Average
lbn r2 r5 r6 Horizontal Average
lbn r3 r5 r6 Vertical Average
breqz r0 34
bne r0 r15 reset
lbn r4 HASH("StructureConsoleLED5") HASH("LED_TIER") Setting Average
brnez r14 10
brge r4 2 5
breqz DishS 4
move r6 DishS
move r5 HASH("StructureSmallSatelliteDish")
sbn r5 r6 Setting 200
breqz DishL 3
move r8 DishL
move r7 HASH("StructureLargeSatelliteDish")
sbn r5 r6 BestContactFilter r15
sbn r5 r6 On 1
beqz r12 ScanHorizontal
beqz r11 ScanReverseHorizontal
beqz r10 ScanVertical
beqz r9 ScanReverseVertical
brne r1 -1 3
sbn HASH("StructureConsoleLED5") HASH("LED_LOCKED_SIGID") Setting 0
j reset
yield
lbn r0 r7 r8 Idle Average
breqz r0 -2
sbn r7 r8 BestContactFilter r15
sbn r7 r8 Setting 50000
sbn r7 r8 Activate 1
lbn r0 r7 r8 InterrogationProgress Average
brlt r0 1 4
sleep 2
sbn HASH("StructureLogicTransmitter") HASH("Hardsuit LT 1") SoundAlert 37
sbn HASH("StructureConsoleLED5") HASH("LED_LOCKED_SIGID") Setting 0
j mainloop
bnez r15 reset
breq r6 DishM 2 # enter roaming mode
sbn r5 r6 On 0
breq r8 DishM 2
sbn r7 r8 On 0
sbn HASH("StructureSatelliteDish") DishM On 1
add r2 r2 2
mod r2 r2 360
sbn HASH("StructureSatelliteDish") DishM Horizontal r2
j mainloop
ScanHorizontal:
brne r1 -1 4
move r12 r14
sbn r5 r6 Horizontal r14
j mainloop
move r14 r2
sub r4 r2 5
mod r4 r4 360
sbn r5 r6 Horizontal r4
j mainloop
ScanReverseHorizontal:
brne r1 -1 14
beq r14 r12 13
move r11 r14
slt r4 r11 r12
breqz r4 2
add r11 r11 360
add r4 r11 r12
div r4 r4 2
mod r4 r4 360
sbn r5 r6 Horizontal r4
sbn r7 r8 On 1
sbn r7 r8 Horizontal r4
jal 124
j mainloop
move r14 r2
add r4 r2 5
mod r4 r4 360
sbn r5 r6 Horizontal r4
j mainloop
ScanVertical:
brne r1 -1 4
move r10 r13
sbn r5 r6 Vertical r13
j mainloop
move r13 r3
brge r3 89.9 -4
add r4 r3 5
sbn r5 r6 Vertical r4
j mainloop
ScanReverseVertical:
brne r1 -1 10
beq r13 r10 9
move r9 r13
select r9 r9 r9 0.01
add r4 r9 r10
div r4 r4 2
sbn r5 r6 Vertical r4
sbn r7 r8 Vertical r4
jal 124
j mainloop
move r13 r3
brle r3 0.1 -8
sub r4 r3 5
sbn r5 r6 Vertical r4
j mainloop
yield
lbn r0 r5 r6 Idle Average
breqz r0 -2
j ra
}}

The last step is to set the item prefab hash you want. First set the <code>FILTER_GAS_SWITCH</code> to indicate the type of the filter(<code>Open</code> is filtering Gas, <code>Close</code> is filtering Prefab), then set the content of [[Kit_(Logic_Memory)|Logic Memory]] named <code>SLM_ITEM_FILTER</code> using labeler or any other means, then power both IC Housing on. Then wait for the trader to arrive, there will be a notification send to your Hardsuit or your custom device. The codes will auto locate the shuttle and filter shuttle cargoes and interrogate with it and call it down to your default landing pad.

Don't forget to reset the content of <code>SLM_ITEM_FILTER</code> to <code>0</code> or something else after trading.

The logic behind the Dish Control is that it scan the signal edge of the filtered out SignalID, instead of inspecting signal strength, so it kind of fast and non-stop rotating. When no filter is specified, it enters roaming mode which rotate clock-wise until filter is specficied and matching shuttle is found.