Stationeers Community Wiki - User contributions [en]

IC10

2024-02-01T16:40:14Z

Z0:

[[Category:MIPS Programming]]
=MIPS scripting language for IC10 housings / chips=
MIPS is [[Stationeers]]' in-game scripting language. 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 opn 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 screq.

* 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.
* <code>lb r? deviceHash logicType batchMode</code>
* <code>sb deviceHash logicType r?</code>
Additionally, using the following batch commands, a '''nameHash''' can be provided to only modify devices with a certain name.
* <code>lbn r? deviceHash nameHash logicType batchMode </code>
* <code>sbn deviceHash nameHash logicType r?</code>

'''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:

<code>lbn r0 HASH("StructureGasSensor") HASH("Sensor 1") Temperature Average</code>

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

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 [[MIPS#Device_Variables|Device Variables]].

It's recommended to use labels (like: ''someVariable'') instead of a direct reference to the register. See '''alias''' in section [[MIPS#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''' or '''sp''' is protected, their values can be changed by instructions like any other register.

==Stack Memory==
;push r?: adds the value of register '''r?''' to the stack memory at index '''sp''' 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?'''.

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:
<blockquote>
<nowiki />#this will traverse indices {min value} through {max value} - 1

move sp {min value}

loop:

add sp sp 1

peek r0
<nowiki />#do something here with your stack values (loaded into r0)

blt sp {max value} loop

<nowiki />#continue on

</blockquote>

Alternatively, you can use the pop function's decrementing to make a more efficient loop:

<blockquote>
move sp {max value}

add sp sp 1

loop:

pop r0

<nowiki />#do something here with your stack values (loaded into r0)

bgt sp {min value} loop

<nowiki />#continue on

</blockquote>

==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, is 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:

<code>l r0 d0 Temperature</code> #Reads the '''Temperature''' from an atmosphere sensor at device port '''d0''' into register '''r0'''.

<code>s d1 Setting r0 </code> # Writes the value of the register '''r0''' to the device on port '''d1''' into the variable '''Setting'''.

==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.

<br><code>main:</code> # define a jump mark with label '''main'''
<br><code>j main</code> # 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.
<br><code>define pi 3.14159</code> # defines a Constant with name '''pi''' and set it's value to 3.14159

You can use these constants like any other variables (see: alias in section [[MIPS#Instructions|Instructions]]). Example:
<br><code>move r0 pi</code> # set the value of register '''r0''' to the value of constant named '''pi'''.

==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.

<code>move r0 5</code> stores the value 5 in r0
<br><code>move rr0 10</code> is now the same as <code>move r5 10</code> 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.
<br><code>move r1 2</code>
<br><code>move r2 3</code>
<br><code>move rrr1 4</code> is now the same as <code>move r3 4</code> since r1 points at r2 which points at r3

This also works with devices
<br><code>move r0 2</code> stores the value 2 in r0
<br><code>s dr0 On 1</code> is now the same as <code>s d2 On 1</code>, r0 has the value 2 so dr0 points at d2

==Network Referencing==

You can load and store to a device's cable network via a provided connection reference. Connections for each supported device are listed in the stationpedia. All 'connections' a device can make are a connection (pipe, chute, cable).

There are 8 channels (Channel0 to Channel7) on a cable network. They are however volatile, in that they might be destroyed and/or replaced at any time. 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.

<br><code>l r0 d0:0 Channel0</code> d0 is device zero, and the :0 refers to that device's 0 connection

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>

==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.

<code> alias MyAlias r0 # Text after the hash tag will be ignored to the end of the line. </code> <br>
<code> # You can also write comments on their own lines, like this. </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. 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 MIPS 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 MIPS==
MIPS 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 MIPS 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)

----

=Instructions=
----

<div id="alias"></div>
;alias
:alias str r? d? # labels register or device reference with name. When alias is applied to a device, it will affect what shows on the screws in the IC base. (housing)
<code>alias vTemperature r0</code>
<br>
<code>alias dAutoHydro1 d0</code>

<div id="move"></div>
;move
:d s # stores the value of s in d
<code>move r0 42 # Store 42 in register 0</code>

<div id="l"></div>
<div id="load"></div>
;l (load)
:l r# d# parameter
Reads from a device (d#) and stores the value in a register (r#)

<code>l r0 d0 Setting</code><br>Read from the device on d0 into register 0

<code>l r1 d5 Pressure</code><br>Read the pressure from a sensor

This also works with aliases. For example:<br/>
<code>
alias Sensor d0 <br/>
l r0 Sensor Temperature
</code>

<div id="ls"></div>
<div id="load slot"></div>
;ls (load slot)
:ls r# d# slotNum parameter
Reads from a slot (slotNum) of a device (d#) and stores the value in a register (r#)

<code>ls r0 d0 2 Occupied</code><br>Read from the second slot of device on d0, stores 1 in r0 if it's occupied, 0 otherwise.

And here is the code to read the charge of an AIMeE:<br/>
<code>
alias robot d0 <br/>
alias charge r0 <br/>
ls charge robot 0 Charge
</code>

<div id="s"></div>
<div id="set"></div>
;s (set)
:s d# parameter r#
Writes a setting to a device.

<code>s d0 Setting r0</code>

<div id="add"></div>
;add
:d s t # calculates s + t and stores the result in d
<code>add r0 r1 1 # add 1 to r1 and store the result as r0</code>
<br>
<code>add r0 r0 1 # increment r0 by one</code>
<div id="sub"></div>
;sub
:d s t # calculates s - t and stores the result in d
<div id="mul"></div>
;mul
:d s t # calculates s * t and stores the result in d
<div id="div"></div>
;div
:d s t # calculates s / t and stores the result in d
<div id="mod"></div>
;mod
:d s t
::# calculates s mod t and stores the result in d. Note this
::# doesn't behave like the % operator - the result will be
::# positive even if the either of the operands are negative

<div id="slt"></div>
;slt
:d s t # stores 1 in d if s < t, 0 otherwise

<div id="sqrt"></div>
;sqrt
:d s # calculates sqrt(s) and stores the result in d
<div id="round"></div>
;round
:d s # finds the rounded value of s and stores the result in d
<div id="trunc"></div>
;trunc
:d s # finds the truncated value of s and stores the result in d
<div id="ceil"></div>
;ceil
: d s # calculates the ceiling of s and stores the result in d
<div id="floor"></div>
;floor
: d s # calculates the floor of s and stores the result in d

<div id="max"></div>
;max
: d s t # calculates the maximum of s and t and stores the result in d
<div id="min"></div>
;min
: d s t # calculates the minimum of s and t and stores the result in d
<div id="abs"></div>
;abs
: d s # calculates the absolute value of s and stores the result in d
<div id="log"></div>
;log
: d s # calculates the natural logarithm of s and stores the result
::# in d
<div id="exp"></div>
;exp
: d s # calculates the exponential of s and stores the result in d
<div id="rand"></div>
;rand
: d # selects a random number uniformly at random between 0 and 1
::# inclusive and stores the result in d

::# boolean arithmetic uses the C convention that 0 is false and any non-zero
::# value is true.
<div id="and"></div>
;and
: d s t # stores 1 in d if both s and t have non-zero values,
::# 0 otherwise
<div id="or"></div>
;or
: d s t # stores 1 in d if either s or t have non-zero values,
::# 0 otherwise
<div id="xor"></div>
;xor
: d s t # stores 1 in d if exactly one of s and t are non-zero,
::# 0 otherwise
<div id="nor"></div>
;nor
: d s t # stores 1 in d if both s and t equal zero, 0 otherwise
::# Lines are numbered starting at zero
<div id="j"></div>
;j
: a # jumps to line a.
<div id="bltz"></div>
;bltz
: s a # jumps to line a if s < 0
<div id="blez"></div>
;blez
: s a # jumps to line a if s <= 0

<div id="bgez"></div>
;bgez
: s a # jumps to line a if s >= 0
<div id="bgtz"></div>
;bgtz
: s a # jumps to line a if s > 0
<div id="beq"></div>
;beq
: s t a # jumps to line a if s == t
<div id="bne"></div>
;bne
: s t a # jumps to line a if s != t
<div id="bdseal"></div>
;bdseal
: d? a(r?|num) # Jump execution to line a and store current line number if device d? is set.
<code>bdseal d0 32 #Store line number and jump to line 32 if d0 is assigned.</code>
<BR>
<code>bdseal dThisVictim HarvestCrop #Store line in ra and jump to sub HarvestCrop if device dThisVictim is assigned.</code>

<div id="yield"></div>
;yield
: # ceases code execution for this power tick

<div id="lb"></div>
;lb
: r? deviceHash logicType batchMode # Loads LogicType from all output network devices with the provided type hash using the provided batch mode. Average (0), Sum (1), Minimum (2), Maximum (3). Can use either the word, or the number. The result is stored into r?.

<div id="sb"></div>
;sb
: deviceHash logicType r? # Stores the register value to LogicType on all output network devices with the provided type hash.

<div id="lbn"></div>
;lbn
: r? deviceHash nameHash logicType batchMode # Loads LogicType from all output network devices with the provided type and name hashes using provided batch mode. Average(0), Sum (1), Minimum (2), Maximum (3). Can use either the word, or the number. The result is stored into r?.

<div id="sbn"></div>
;sbn
: deviceHash nameHash logicType r? # Stores the register value to LogicType on all output network devices with the provided type and name hashes.

<div id="#"></div>
; #
: # The following text will be ignored during compiling; use this to create comments.

[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
|-
| -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/>
if 1 <= max(1.01, FLT_EPSILON * 8)
if 1 <= max(1.01, DBL_EPSILON * 8)
<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
: <span style="color:blue;">▇▇▇</span>  0 (or lower) = Blue
: <span style="color:grey;">▇▇▇</span> 1 = Grey
: <span style="color:green;">▇▇▇</span> 2 = Green
: <span style="color:orange;">▇▇▇</span> 3 = Orange
: <span style="color:red;">▇▇▇</span> 4 = Red
: <span style="color:yellow;">▇▇▇</span> 5 = Yellow
: <span style="color:white;">▇▇▇</span> 6 = White
: <span style="color:black;">▇▇▇</span> 7 = Black
: <span style="color:brown;">▇▇▇</span> 8 = Brown
: <span style="color:khaki;">▇▇▇</span> 9 = Khaki
: <span style="color:pink;">▇▇▇</span> 10 = Pink
: <span style="color:purple;">▇▇▇</span> 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 (always?) 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="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}}">
<pre>
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 ###

</pre>
</div>
<br>
-----

===Solar Panel 2-axis tracking===
This script was copied from the [[Solar_Logic_Circuits_Guide]] (code provided by bti, comments and readability changes by Fudd79)
<div class="mw-collapsible mw-collapsed" data-expandtext="{{int:Expand, Solar Panel 2-axis tracking}}" data-collapsetext="{{int:Collapse, Solar Panel 2-axis tracking}}">
<pre>
# This code assumes the following:
# Daylight Sensor data-port points north
# Solar Panel data-port points east

alias sensor d0
alias v_angle r0
alias h_angle r1
alias sun_up r2

define solar_panel_hash -539224550
define heavy_solar_panel_hash -1545574413

start:
# Check to see if sun is up
l sun_up sensor Activate
# Go to reset if it's not
beqz sun_up reset

# Calculate vertical angle
l v_angle sensor Vertical
div v_angle v_angle 1.5
sub v_angle 50 v_angle

# Write vertical angle to all solar panels
sb solar_panel_hash Vertical v_angle
sb heavy_solar_panel_hash Vertical v_angle

# Obtain horizontal angle
l h_angle sensor Horizontal

# Write horizontal angle to all solar panels
sb solar_panel_hash Horizontal h_angle
sb heavy_solar_panel_hash Horizontal h_angle

# Go to start again
yield
j start

reset:
# Park solar panels vertically facing sunrise
sb solar_panel_hash Vertical 0
sb heavy_solar_panel_hash Vertical 0
# Park solar panels horizontally facing sunrise
sb solar_panel_hash Horizontal -90
sb heavy_solar_panel_hash Horizontal -90
# Wait 10 seconds
sleep 10
# Go to start again
j start

### End Script ###

</pre>
</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.

<pre>
move r0 1 #the first line has number 0
add r0 r0 3
s db Setting r0
j 1
</pre>

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.

----
=Links=
----
* [https://stationeering.com/tools/ic] Stationeering.com offers a programmable circuits simulator so you can develop your code without repeatedly dying in game!
* [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://pastebin.com/3kmGy0NN] syntax highlighting for IC10 MIPS for Notepad++ (updated: 05/05/2021)
* [https://drive.google.com/file/d/1Xrv5U0ZI5jDcPv7yX7EAAxaGk5hKP0xO/view?usp=sharing] syntax highlighting for IC10 MIPS for Notepad++ (updated: 11/08/2022)

----

=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>

|}

Transformer

2024-01-24T21:31:18Z

Z0: /* Notes */

{{Itembox
| name = Kit (Transformer)
| image = [[File:{{#setmainimage:ItemKitTransformerSmall.png}}]]
| stacks = No
| createdwith = [[Electronics Printer]], [[Fabricator]]
| cost = 10x [[Iron]], 1x [[Gold]] , 3x [[Copper]]
}}
{{Itembox
| name = Kit Transformer (Large)
| image = [[File:{{#setmainimage:ItemKitTransformer.png}}]]
| stacks = No
| createdwith = [[Electronics Printer]], [[Fabricator]]
| cost = 10x [[Steel]], 5x [[Electrum]]
}}

==Description==
The transformer is used to control the maximum amount of power that will flow on a cable, preventing the cables from overloading on high power draw.
There are three variants of the transformer:

The Transformer (Small) requires 1x Kit (Transformer) to place and is limited to 5,000 W of output. It can be placed in any orientation on a supporting surface (floor, wall, or ceiling) and is available as Transformer Reversed (Small).

The Transformer (Medium) requires 3x Kit (Transformer) to place and is limited to 25,000 W of output. Similarly, it can be placed on any floor, wall, or ceiling and is available as a Transformer Reversed (Medium).

The Transformer (Large) requires 1x Kit Transformer (Large) to place and is limited to 50,000 W of output. It can only be placed in one orientation, ideally the floor, but it can be stacked above floor level by placing it partway into a frame.

==Usage==
Given that the transformer can limit power very specifically (with large 100 W increments or small 10 W increments), you can control or stop the output line from drawing more than the transformer gives out. This can be used to control many items that don't have a changing power usage, such as lights, volume pumps, pipe regulators, active vents, and more. This is similar to the [[Area Power Controller]] but does not have a battery buffer.

==Notes==
Data will not flow through a transformer, isolating the circuit behind their input. <br>
The transformers seem to generate a large amount of heat. 

The Transformer will use 10W itself(all sizes), so setting a small transformer to 5000 and feeding with a regular cable will cause the supply cable to blow as it can draw 5010W at max load

===Data Network Properties===
These are all Data Network properties of this device. This list is not tested at all for the Transformer Small and not complete for Transformer (kit/large variant).

==Data Parameters==
These are all parameters, that can be written to with a Logic Writer, Batch Writer, or Integrated Circuit (IC10). The outputs are listed in the order a Logic Writer's "VAR" setting cycles through them.
{| class="wikitable"
|-
! Header text !! Header text !! Header text
|-
| On || Boolean || Turns the Transformer on when set to 1. Turns it off when set to 0.
|-
| Lock || Boolean || Locks the Transformer when set to 1. Unlocks it when set to 0
|-
| Setting || Integer || Sets the Transformer's power (in Watts) limit.
|}

==Data Outputs==
These are all parameters, that can be read with a Logic Reader or a Slot Reader. The outputs are listed in the order a Logic Reader's "VAR" setting cycles through them. You cannot read ratios in IC2 chip (so far)
{| class="wikitable"
|-
! Parameter Name !! Data Type !! Description
|-
| On|| Boolean|| Returns whether the Transformer is turned on. (0 for no, 1 for yes)
|-
| Maximum || Integer|| Maximum setting of this device. (How high the device can be set, see description for specific numbers.)
|-
| Lock || Boolean|| Returns whether the Transformer is locked. (0 for no, 1 for yes)
|-
| Error || Boolean|| 1 if device is in error state, otherwise 0.
|-
| Setting || Integer || Returns the current power limit (in Watts) of the Transformer.
|-
| RequiredPower || Integer || Idle operating power quantity. (how much power, in watts, the device itself is using, rather than how much power it is passing through.)
|-
| Ratio || Float || Ratio of the current power limit to the maximum power limit of the device
|-
| PrefabHash|| Integer || The hash of the device. (Can be found in the Stationpedia.)
|-
| Power|| Boolean || Returns 1 if the device is powered and on, otherwise 0.
|}

Transformer

2024-01-24T21:30:40Z

Z0: /* Notes */

{{Itembox
| name = Kit (Transformer)
| image = [[File:{{#setmainimage:ItemKitTransformerSmall.png}}]]
| stacks = No
| createdwith = [[Electronics Printer]], [[Fabricator]]
| cost = 10x [[Iron]], 1x [[Gold]] , 3x [[Copper]]
}}
{{Itembox
| name = Kit Transformer (Large)
| image = [[File:{{#setmainimage:ItemKitTransformer.png}}]]
| stacks = No
| createdwith = [[Electronics Printer]], [[Fabricator]]
| cost = 10x [[Steel]], 5x [[Electrum]]
}}

==Description==
The transformer is used to control the maximum amount of power that will flow on a cable, preventing the cables from overloading on high power draw.
There are three variants of the transformer:

The Transformer (Small) requires 1x Kit (Transformer) to place and is limited to 5,000 W of output. It can be placed in any orientation on a supporting surface (floor, wall, or ceiling) and is available as Transformer Reversed (Small).

The Transformer (Medium) requires 3x Kit (Transformer) to place and is limited to 25,000 W of output. Similarly, it can be placed on any floor, wall, or ceiling and is available as a Transformer Reversed (Medium).

The Transformer (Large) requires 1x Kit Transformer (Large) to place and is limited to 50,000 W of output. It can only be placed in one orientation, ideally the floor, but it can be stacked above floor level by placing it partway into a frame.

==Usage==
Given that the transformer can limit power very specifically (with large 100 W increments or small 10 W increments), you can control or stop the output line from drawing more than the transformer gives out. This can be used to control many items that don't have a changing power usage, such as lights, volume pumps, pipe regulators, active vents, and more. This is similar to the [[Area Power Controller]] but does not have a battery buffer.

==Notes==
Data will not flow through a transformer, isolating the circuit behind their input. <br>
The transformers seem to generate a large amount of heat. 
The Transformer will use 10W itself(all sizes), so setting a small transformer to 5000 and feeding with a regular cable will cause the supply cable to blow as it can draw 5010W at max load

===Data Network Properties===
These are all Data Network properties of this device. This list is not tested at all for the Transformer Small and not complete for Transformer (kit/large variant).

==Data Parameters==
These are all parameters, that can be written to with a Logic Writer, Batch Writer, or Integrated Circuit (IC10). The outputs are listed in the order a Logic Writer's "VAR" setting cycles through them.
{| class="wikitable"
|-
! Header text !! Header text !! Header text
|-
| On || Boolean || Turns the Transformer on when set to 1. Turns it off when set to 0.
|-
| Lock || Boolean || Locks the Transformer when set to 1. Unlocks it when set to 0
|-
| Setting || Integer || Sets the Transformer's power (in Watts) limit.
|}

==Data Outputs==
These are all parameters, that can be read with a Logic Reader or a Slot Reader. The outputs are listed in the order a Logic Reader's "VAR" setting cycles through them. You cannot read ratios in IC2 chip (so far)
{| class="wikitable"
|-
! Parameter Name !! Data Type !! Description
|-
| On|| Boolean|| Returns whether the Transformer is turned on. (0 for no, 1 for yes)
|-
| Maximum || Integer|| Maximum setting of this device. (How high the device can be set, see description for specific numbers.)
|-
| Lock || Boolean|| Returns whether the Transformer is locked. (0 for no, 1 for yes)
|-
| Error || Boolean|| 1 if device is in error state, otherwise 0.
|-
| Setting || Integer || Returns the current power limit (in Watts) of the Transformer.
|-
| RequiredPower || Integer || Idle operating power quantity. (how much power, in watts, the device itself is using, rather than how much power it is passing through.)
|-
| Ratio || Float || Ratio of the current power limit to the maximum power limit of the device
|-
| PrefabHash|| Integer || The hash of the device. (Can be found in the Stationpedia.)
|-
| Power|| Boolean || Returns 1 if the device is powered and on, otherwise 0.
|}

Furnace

2024-01-10T03:27:15Z

Z0:

<languages/>
<translate>

[[Category:Machines]]
{{Itembox
| name = Kit (Furnace)
| image = [[File:ItemKitFurnace.png]]
| createdwith = [[Special:MyLanguage/Autolathe|Autolathe]], [[Special:MyLanguage/Fabricator|Fabricator]]
| cost = 30g [[Special:MyLanguage/Iron|Iron]], 10g [[Special:MyLanguage/Copper|Copper]]
| volume = 1000 L
| logic =
* Open
* Pressure
* Temperature
* Lock
* Setting
* Reagents
* RatioOxygen
* RatioCarbonDioxide
* RatioNitrogen
* RatioPollutant
* RatioVolatile
* RatioWater
* Maximum
* Ratio
* ImportQuantity
* ImportSlotOccupant
* ExportQuantity
* ExportSlotOccupant


}}
{{Structurebox
| name = Furnace
| image = [[File:Furnace.jpg]]
| 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 == 
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 the ice.


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.

== Recipes == 


While smelting steel is easily achieved with ice, other recipes usually require a working piping setup (a valve and passive vent at bare minimum to vent the internal gasses). This can be done by separating gases into tanks using atmospheric units and piping 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. Output should also be extracted and vented/recycled through a backpressure regulator to keep furnace pressure in check. The optimal gas mix that burns completely is 1 part (33.3%) oxygen to 2 parts (66.6%) volatiles, other mixes would also work but leave you with leftover oxygen or volatiles depending on the percentages used. It could also 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.
{{:Furnace/Recipes}}

=== 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.

===Some example 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>


{{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 || (Unknown).
|-
| 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 || (Unknown).
|-
| 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>

Game Settings

2023-12-29T15:46:52Z

Z0: /* Changing difficulty mid-game */

= Gameplay Difficulty =

This setting mostly determines what you will re-spawn with when you die:

* On Easy difficulty, you will start with a full suit again, just like at the beginning of a new world.
* On Normal difficulty you will be given an emergency suit and a full set of emergency tools and are expected to retrieve or create a proper suit again. In this mode you need to open your helmet in order to eat or drink.
* On Stationeer difficulty, you will spawn with no suit at all, which is very dangerous if you have not set your spawn point yet. In this mode you need to open your helmet in order to eat or drink.

'''Note:''' At the time of writing (version 0.2.4258.19848), you can only find this setting on the [[New World]] menu and there is no interface to change this setting mid-game

== Changing difficulty mid-game ==

If you want to change the difficulty of an existing world you should:

# Load the existing world
# Open the in-game developer console (F3)
# Write 'difficulty Easy' and press enter
## Replace "Easy" with your desired difficulty name
Note: the difficulty name needs to start with capital letter or it will not be recognized
# Close the in-game developer console (F3 again)
# Save the world

= Sun Orbit Period (Day cycle time) =

== Summary ==
This setting determines how long the day cycle time is, as a percentage of a base value, represented as a decimal number.

The allowed value range goes from 0.1 to 2.0 and the base value is 20 minutes.
The base value is measured in IRL minutes.

== Examples ==

* If set to 1.0, the day cycle time is 20 minutes.
* If set to 0.1, the day cycle time is 2 minutes.
* If set to 2.0, the day cycle time is 40 minutes.

== Day time and Night time ==
The amount of day time and night time depends on the day cycle time and the [[Solar Angle]] on the planet you're at.

For the [[Moon]] and [[Venus]], because their solar angle is 0°, the day time is exactly half the day cycle time.<br>
This means, for a day cycle time of 20 minutes, you'll get 10 minutes of daytime and 10 minutes of night time every game day.

= Hunger / Hydration Rate =

{{Warning|These settings are currently part of each difficulty configuration and cannot be changed in-game by the user}}
This setting controls how rapidly your hunger and hydration levels will deplete. Increasing the value will make them go down more quickly. A higher value on this bar will reduce the time you have early on to set up food and water supply. On Stationeers and Normal difficulties, a high value on this setting will mean you need to quickly build a breathable atmosphere as these difficulties require you to open your helmet to eat and drink.

Kit (Lights)

2023-12-08T21:32:10Z

Z0: /* LED */

<languages />
<translate>
{{Itembox
| name = Kit (Lights)
| image = [[File:{{#setmainimage:ItemWallLight.png}}]]
| stacks = Yes
| constructs = Wall Light, LED
| createdwith = [[Autolathe]], [[Electronics Printer]], [[Fabricator]]
| cost = 1g [[Iron]], 2g [[Copper]], 1g [[silicon_Ingot|Silicon]]* <small>*autolathe only</small>
}}
{{Structurebox
| name = Wall Lights
| prefab_hash = See table in description
| power_usage = 50W
| placed_with_item = [[Kit (Lights)]]
| placed_on_grid = Small Grid, On Frames
| decon_with_tool1 = [[Hand Drill]]
| item_rec1 = [[Kit (Lights)]]
}}
{{Structurebox
| name = LED
| image = [[File:LED.png]]
| prefab_hash = 1944485013
| power_usage = 25W
| placed_with_item = [[Kit (Lights)]]
| placed_on_grid = Small Grid, On Frames
| decon_with_tool1 = [[Hand Drill]]
| item_rec1 = [[Kit (Lights)]]
}}
{{Structurebox
| name = Diode Slide
| prefab_hash = 576516101
| power_usage = 25W
| placed_with_item = [[Kit (Lights)]]
| placed_on_grid = Small Grid, On Frames
| decon_with_tool1 = [[Hand Drill]]
| item_rec1 = [[Kit (Lights)]]
}}
__TOC__

= <big>Description</big> = 
Light kits are used for illuminating your base. The LED variant consumes half the power of the default larger wall light though is not as bright. It's color can also be changed with logic, making for a great status indicator within logic circuits.

= <big>Wall Light</big> (Regular, Long, Long Wide, Long Angled, Battery, Round, Round Angled, Small Round) =
= PrefabHash Values =
{| class="wikitable"
|-
! Light Type !! PrefabHash
|-
| Regular || -1860064656
|-
| Long || 797794350
|-
| Long Wide || 555215790
|-
| Long Angled || 1847265835
|-
| Battery Powered || -1306415132
|-
| Round || 1514476632
|-
| Round Angled || 1592905386
|-
| Small Round || 1436121888
|}

{{Data Network Header}}
{{Data Parameters}}
{| class="wikitable"
|-
! Parameter Name !! Data Type !! Description
|-
| On || Boolean || Turns the Light on, when set to 1. Turns it off, when set to 0.
|-
| Lock || Boolean || Locks the Light when set to 1. Unlocks it, when set to 0. When locked, Light cannot be turned on\off by player.
|}

{{Data Outputs}}
{| class="wikitable"
|-
! Output Name !! Data Type !! Description
|-
| On || Boolean || Returns whether the Light is turned on. (0 for no, 1 for yes)
|-
| Lock || Boolean || Returns whether the Light is locked. (0 for no, 1 for yes)
|-
| RequiredPower || Integer || Returns the current amount of power required by the Light, in watts.
|-
| PrefabHash || Integer || Returns the Hash value for the selected light type. (See info panels on the right)
|-
| Power || Boolean || Returns whether the Light is turned on and receives power. (0 for no, 1 for yes)
|}

= <big>LED</big> =
{{Data Network Header}}
{{Data Parameters}}
{| class="wikitable"
|-
! Parameter Name !! Data Type !! Description
|-
| On || Boolean || Turns the Light on, when set to 1. Turns it off, when set to 0.
|-
| Lock || Boolean || Locks the Light when set to 1. Unlocks it, when set to 0. When locked, Light cannot be turned on\off by player.
|-
| Color || Integer || Sets the color of the LED Light. (See [[Data Network Colors]])
|}

{{Data Outputs}}
{| class="wikitable"
|-
! Output Name !! Data Type !! Description
|-
| On || Boolean || Returns whether the Light is turned on. (0 for no, 1 for yes)
|-
| Lock || Boolean || Returns whether the Light is locked. (0 for no, 1 for yes)
|-
| Color || Integer || Returns the color setting of the LED Light. (See [[Data Network Colors]])
|-
| RequiredPower || Integer || Returns the current amount of power required by the Light, in watts.
|-
| PrefabHash || Boolean ||
|-
| Power || Boolean || Returns whether the Light is turned on and receives power. (0 for no, 1 for yes)
|}

= <big>Diode Slide</big> =
{{Data Network Header}}
{{Data Parameters}}
{| class="wikitable"
|-
! Parameter Name !! Data Type !! Description
|-
| On || Boolean || Turns the Diode Slide on, when set to 1. Turns it off, when set to 0.
|-
| Lock || Boolean || Locks the Diode Slide when set to 1. Unlocks it, when set to 0. When locked, Light cannot be turned on\off by player.
|-
| Setting || Boolean || Sets the color of the Diode Slide. (0 - red, 1 - green)
|}

{{Data Outputs}}
{| class="wikitable"
|-
! Output Name !! Data Type !! Description
|-
| On || Boolean || Returns whether the Diode Slide is turned on. (0 for no, 1 for yes)
|-
| Lock || Boolean || Returns whether the Diode Slide is locked. (0 for no, 1 for yes)
|-
| Setting || Boolean || Returns the "Setting" value of the Diode Slide.
|-
| RequiredPower || Integer || Returns the current amount of power required by the Diode Slide , in watts.
|-
| PrefabHash || Boolean ||
|-
| Power || Boolean || Returns whether the Diode Slide is turned on and receives power. (0 for no, 1 for yes)
|}

= Builds =

* [[Auto Night Lights]]

</translate>

Logic Transmitter

2023-12-07T15:40:31Z

Z0:

<languages/>
<translate>


[[Category:Circuits]]
{{Itembox
| name = Kit (Logic Transmitter)
| image = [[File:ItemKitLogicTransmitter.png|Kit (Logic Transmitter)]]
| prefab_hash = 1005397063
| placed_on_grid = Small Grid, On Frames
| stacks = 5
| cost = 2g [[Special:MyLanguage/Gold|Gold]], 1g [[Special:MyLanguage/Copper|Copper]], 3g [[Special:MyLanguage/Electrum|Electrum]], 5g [[Special:MyLanguage/Silicon|Silicon]]
}}
{{Structurebox
| name = Logic Transmitter
| image = [[File:LogicTransmitter.png|thumb|Mounted Logic Transmitter]]
| prefab_hash = -693235651
| power_usage = 50W
| placed_with_item = [[Kit (Logic Transmitter)]]
| placed_on_grid = Small Grid, On Frames
| decon_with_tool1 = [[Special:MyLanguage/Hand Drill|Hand Drill]]
| item_rec1 = [[Special:MyLanguage/Kit (Logic Transmitter)|Kit (Logic Transmitter)]]
}}

== Description == 
The Logic Transmitter are used to transmit values in a logic network wirelessly.

The Logic Transmitter starts in '''Passive''' mode and can be tied to '''Active''' transmitters, [[AIMEe]], [[Hardsuit]] and <s>[[Rover]]</s>.
While tied to anything but another Logic Transmitter is basically acts like a [[Kit_(Logic_I/O)#Logic_Mirror|Logic Mirror]],
except from far distance.

If you set a Logic Transmitter to active, you can write to the Setting variable on it to transmit that value to one or multiple Logic Transmitter that are tied to it in passive mode.
You tie a passive Logic Transmitter to an active Logic Transmitter by adjusting the screw on the passive Logic Transmitter until it matches the name of the active Logic Transmitter. NOTE: The active Logic transmitter must be on and active to show up as an option in the screw of the passive Logic Transmitter. You can then read the Setting variable from the passive Logic Transmitter.

This is the toggle button that can be manually used to change the Logic Transmitter '''Mode''':
[[File:LogicTransmitterActiveButton.png|400x300px|Example of where find the toggle button for the mode of the Logic Transmitter]]

The Logic Transmitter can also be tied to an [[Advanced Tablet]] which it then locally represents (mirrors) in the network. This allows playing of sounds on the tablet or to read out the tablet's values: The off/on state can be read as well as the current mode (representing which [[Cartridge]] is selected). Therefore, the tablet can now be used as a remote control.

== Note == 

* There seems to be no limit to the distance at which two devices can connect.
* The Logic Transmitter have three data input ports and one for power. Due the fact that when the Logic Transmitter is in '''Active''' is used to mirror a signal from another Logic Transmitter, seems that all of the three input ports are not necessary on the same network (because they are all or output or input), but can be used for sharing the same value in different networks without mixing logic networks and/or having to build many Logic Transmitter for recieving the same value.
* The placed object prefabhash is -693235651.


{{Data Network Header}}


{{Data Parameters}}
{| class="wikitable"
|-
! Parameter Name !! Data Type !! Description
|-
| On || Boolean ||
|-
| Mode || Boolean || 0 for '''Passive''', 1 for '''Active'''
|-
| Setting || Any || Any setted o mirrored value from another device
|}


{{Data Outputs}}
{| class="wikitable"
|-
! Output Name !! Data Type !! Description
|-
| On || Boolean || If is enabled
|-
| Mode || Boolean || 0 for *Passive*, 1 for *Active*
|-
| Power || Boolean || If is taking power
|-
| PrefabHash || Integer || -693235651
|-
| RequiredPower || Integer || Power required to work (50W)
|-
| Setting || Any || Any setted o mirrored value from another device
|}

</translate>