Stationeers Community Wiki - User contributions [en]

Integrated Circuit (IC10)

2024-04-04T07:07:54Z

Traineratwot: /* See also */

<languages/>
<translate>

[[Category:Circuits]]
[[Category:MIPS Programming]]
</translate>
{{Itembox
| name = Integrated Circuit (IC10)
| image = [[File:IC 10.png|thumb|IC Housing and IC10 disassembled]]
| createdwith = [[Electronics Printer]]
| cost = 10 [[Gold]], 4 [[Steel]], 5 [[Electrum]], 2 [[Solder]]
| stacks = No
}}

<translate>

A chip that is programmed with a [[computer]]. Place the circuit in a [[Kit (IC Housing)|IC Housing]] or directly into the programmable slot of certain devices, e.g. [[Kit (Atmospherics)|Atmospherics]]. The [[MIPS]] language is used.
</translate>

= Where to get programs =
* Write one by yourself using the [[computer]] or [[Laptop]].
* Paste whatever you have found on the internet into your [[computer]].
* Load from your private library program you have saved previously (even from different savegame).
* Get one from Steam Workshop (first subscribe in steam, then in game it will be available in "library" on computer).

= How to create programs =
== You'll need ==
# Basic knowledge about math and logic
# Whatever you're intending to program (e.g.: cycling airlock) you must be learnt to do manually (e.g.: close doors, turn on vents, etc)
# Learn the MIPS programming language. MIPS is real world low-level (i.e. close to hardware) programming language. IC10 is MIPS with some Stationeers flavor added. It is fairly simple and compact. Due to its simplicity MIPS is not suitable for big programs but you re not going to develop those in the game anyways.

== How to start getting in the MIPS programing ==
Get some simple program (even 10 lines will do), run it in Stationeers to see what it does and then read the text. Look into ingame editor help pages to decrypt keywords. MIPS keywords are abbreviations of English words and mostly make sense, eg. <code>beqz r0 foobar</code> means "'''B'''ranch (jump) to line labeled foobar if r0 '''EQ'''uals to '''Z'''ero".

= How to flash program onto the IC chip =
# Setup a [[Computer]], wire it to power.
# Insert a [[Motherboard (IC Editor)]] in it.
# Place [[Kit (IC Housing)|IC Housing]].
# Wire DATA (green, right) port of the computer to DATA (green, bottom) port on the IC Housing.
## Unless you're going to actually use/test your program in this particular IC Housing you do not need to power it.
# Insert [[Integrated Circuit (IC10)]] into [[Kit (IC Housing)|IC Housing]].
# Turn on the Computer, look at its screen and see if your IC Housing is listed and selected in the drop-down selector. You can have several IC Housings on the same data network, in that case better be renaming them using [[Labeller]]. The IC10 Integrated Circuit itself can also be labeled (and painted).
## Optional: click "Import" to retrieve a program from the [[Integrated Circuit (IC10)]] into the computer.
# Click "Edit" to open the code editor. Write/load from "Library"/paste your program, click "Confirm".
# Now Computer contains the new program and Integrated Circuit still contains old one (or empty program). Click "Export" on the computer to copy the program into the Circuit. If the IC housing is powered the program will immediately run. You can repeat "Export" as many times as you want and reuse old Circuits.
# When Circuit is picked up size of the stored program in bytes is shown.

Note: Steps 1-6 can be used with a [[Laptop]] now as well. The laptop includes an IC housing so you don't have to place your own and wire it to edit chips. This is limited to editing chips that are in the laptop (1 at a time) and cannot be used to edit chips already on the network.

= How to make use of programmed IC Integrated Circuit =
# Place [[Kit (IC Housing)|IC Housing]], wire it to power, insert the Circuit
# Connect DATA (green, bottom) port on the IC Housing to machines you want to control. Some machines like an [[Autolathe]] have a DATA port, you need to use it (or both DATA and POWER). Some machines like a [[Stacker]] only have "universal" port.
# Unless you're going to modify/debug your program on place you do not require a [[Computer]] here.
# Using [[Screwdriver]] adjust six (or less) screws according to program description/purpose. Many programs do assign labels to screws using <code>alias</code> command (that's considered good style), to take benefit of it you can turn on IC Housing for a short time (that way it will blink yellow, it's okay). If all screws are set to "None" a misconfigured program can do no harm.
# Turn on the IC Housing.

= How large a program can be =
There are 128 lines each being 52 characters long. Each character (incl. line break) takes 2 bytes. Maximum size IC chip will show is 13566.

= See also =
* [[WebEditor]] — https://ic10.dev/
* [[MIPS]] — basic info and command reference
* [[Advanced IC10 Programming]]
* [https://stationeering.com/tools/ic Stationeering.com] by Melair — online emulator and command reference.
<references />

Advanced IC10 Programming

2024-04-04T07:07:13Z

Traineratwot: /* VS code extension */

[[Category:MIPS 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 ==

You can use a register to access the device based on pin number.

<div style="background: #000000;>

move r0 0
next:
s dr0 Horizontal 0
s dr0 Vertical 0
s dr0 On 0
add r0 r0 1
blt r0 6 next


</div>

== Functions ==

<div style="background: #000000;>
main:
jal MyFunction
j main

MyFunction:
...
j ra



</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">
main:
jal _MyFunction
j main

_MyFunction:
push ra
jal _MySecondFunction
pop ra
j ra

_MySecondFunction:
...
j ra



</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">
alias rIterator r0
main:
move rIterator 0
Loop:
...
add rIterator rIterator 1
bgt rIterator 3 Loop_End
j Loop
Loop_End:

j main



</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 and adding lines might break them if you overlook them. If code length is not an issue, stick to labels where possible.

== Indexing With Relative Jump ==

<div style="background: #000000; float: none">
alias rIndex r0
alias rTemp r1
alias rValue r2

main:
move rIndex 1
mul rTemp rIndex 2
add rTemp rTemp 1
jr rTemp
move rValue 123 #Index 0
j Select_end
move rValue 456 #Index 1
j Select_end
move rValue 789 #Index 2
j Select_end
...
Select_end:
j main



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

== 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">
main:
alias dCurrent d0
jal _MyFunction
alias dCurrent d1
jal _MyFunction
j main



</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">
alias rIterator r0
alias rTemp r1
main:
move rIterator 0
Loop:
jal _UpdateReference
jal _FunctionForDevice
add rIterator rIterator 1
bgt rIterator 3 Loop_End
j Loop
Loop_End:
j main

_UpdateReference:
mul rTemp rIterator 2
add rTemp rTemp 1
jr rTemp
alias dCurrentDevice d0 #Index 0
j Select_end
alias dCurrentDevice d1 #Index 1
j Select_end
alias dCurrentDevice d2 #Index 2
j Select_end
alias dCurrentDevice d3 #Index 3
j Select_end
Select_end:
j ra

_FunctionForDevice:
#Manipulate dCurrentDevice
j ra



</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.
<div style="background: #000000; float: none">
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


</div>

'''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)
= Sample Projects =

== Vending Machine Exporter ==

[[Vending_Machine_Export_IC10]]

IC10

2022-07-04T16:37:34Z

Traineratwot: fix

[[Category:MIPS Programming]]
=MIPS scripting language for IC10 housings / chips=

<pre>
# Text after a # will be ignored to the end of the line. The amount of white
# space between arguments isn't important, but new lines start a new command.
</pre>

==Registers==
The IC contains 16 registers, numbered r0-r15. Think of these as variables in other programming languages. In fact, you can name them with the alias command (see below).

To set a register directly (such as r0=2), use the move command. To read a value from a device, use l (load). To write a value back to a device, use s (set). Note that
like most machine languages, the destination goes first, so instructions always look like: action destination source.

Here are some examples set a register, reading a value from a device and writing a value to device:

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

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

<code>l r0 d0 Temperature</code> 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> 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]].

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.

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

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.

 <code>main:</code> # define a jump mark with label '''main'''
 <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.
 <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:
 <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 infront 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
 <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.
 <code>move r1 2</code>
 <code>move r2 3</code>
 <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
 <code>move r0 2</code> stores the value 2 in r0
 <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

==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. 
<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. This example will display the number 137 on the IC housing. 
<code>s db Setting 137</code> # sets/writes the number 137 into the parameter '''Setting''' of the IC Housing('''db''')

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:
* alias (make the script easier to read by assigning a name to a register or device, example: <code>alias rTemperature r15</code>)
* label: (where "label" can be replaced with almost any word, jump and branch instructions will go to these, 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)

 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)

 Branching (jump-if):
<pre>
beq (branch if equal)
bne (branch if not-equal)
bgt (branch if greater than)
blt (branch if less than)
The suffix -al can be added to each of these (example: beqal) to save the next line number into the "return address" register
</pre>

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

 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>

 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>

 Notes:
 -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.
 -The stationpedia is the best source to see which variables are available to each device.
 -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:
 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.
 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 minumum 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>
 
<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> Read from the device on d0 into register 0

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

This also works with aliases. For example: 
<code>
alias Sensor d0 
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> 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: 
<code>
alias robot d0 
alias charge r0 
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>
 
<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>
 
<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? typeHash var batchMode # Loads var from all output network devices with provided typeHash using provided batchMode: Average(0), Sum (1), Minimum (2), Maximum (3). Can be used word or number. Result store into r?

<div id="sb"></div>
;sb
: typeHash var r? # Store register r? to var on all output network devices with provided typeHash

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

==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
: 0 (or lower) = Blue
: 1 = Grey
: 2 = Green
: 3 = Orange
: 4 = Red
: 5 = Yellow
: 6 = White
: 7 = Black
: 8 = Brown
: 9 = Khaki
: 10 = Pink
: 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>
;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>

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

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

===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):
 127
 256 (+129)
 385 (+129)
 511 (+126)
 640 (+129)
 769 (+129)
 895 (+126)
 1024 (+129)
 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)

----

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

|}

=IcX preprocessor=

[https://traineratwot.aytour.ru/wiki/icx Official wiki]

IC10

2022-07-04T16:36:38Z

Traineratwot: add IcX wiki link

Advanced IC10 Programming

2021-12-04T13:49:18Z

Traineratwot: add info about extension

[[Category:MIPS 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]

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

= Flow Control And Data Manipulation =

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

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

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

You can use a register to access the device based on pin number.

<div style="background: #000000;>

move r0 0
next:
s dr0 Horizontal 0
s dr0 Vertical 0
s dr0 On 0
add r0 r0 1
blt r0 6 next


</div>

== Functions ==

<div style="background: #000000;>
main:
jal MyFunction
j main

MyFunction:
...
j ra



</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">
main:
jal _MyFunction
j main

_MyFunction:
push ra
jal _MySecondFunction
pop ra
j ra

_MySecondFunction:
...
j ra



</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">
alias rIterator r0
main:
move rIterator 0
Loop:
...
add rIterator rIterator 1
bgt rIterator 3 Loop_End
j Loop
Loop_End:

j main



</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 and adding lines might break them if you overlook them. If code length is not an issue, stick to labels where possible.

== Indexing With Relative Jump ==

<div style="background: #000000; float: none">
alias rIndex r0
alias rTemp r1
alias rValue r2

main:
move rIndex 1
mul rTemp rIndex 2
add rTemp rTemp 1
jr rTemp
move rValue 123 #Index 0
j Select_end
move rValue 456 #Index 1
j Select_end
move rValue 789 #Index 2
j Select_end
...
Select_end:
j main



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

== 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">
main:
alias dCurrent d0
jal _MyFunction
alias dCurrent d1
jal _MyFunction
j main



</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">
alias rIterator r0
alias rTemp r1
main:
move rIterator 0
Loop:
jal _UpdateReference
jal _FunctionForDevice
add rIterator rIterator 1
bgt rIterator 3 Loop_End
j Loop
Loop_End:
j main

_UpdateReference:
mul rTemp rIterator 2
add rTemp rTemp 1
jr rTemp
alias dCurrentDevice d0 #Index 0
j Select_end
alias dCurrentDevice d1 #Index 1
j Select_end
alias dCurrentDevice d2 #Index 2
j Select_end
alias dCurrentDevice d3 #Index 3
j Select_end
Select_end:
j ra

_FunctionForDevice:
#Manipulate dCurrentDevice
j ra



</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.
<div style="background: #000000; float: none">
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


</div>

'''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)
= Sample Projects =

== Vending Machine Exporter ==

[[Vending_Machine_Export_IC10]]