Stationeers Community Wiki - User contributions [en]

Furnace

2018-09-28T22:30:14Z

Carsten Milkau: /* Recipes */ Fixed Constantan Celsius values

<languages />
<translate>
[[Category:Machines]]
{{Itembox
| name = Kit (Furnace)
| image = [[File:ItemKitFurnace.png]]
| createdwith = [[Autolathe]], [[Fabricator]]
| cost = 30g [[Iron]], 10g [[Copper]]
| volume = 250 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
| decon_with_tool1 = [[Hand Drill]]
| item_rec1 = [[Kit (Furnace)]]
}}

== Description ==
Used to smelt ingots and alloys using an oxygen/volatile gas mix. [[Ice (Oxite)]] and [[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 [[Reagent]] which can be processed in a [[Centrifuge]] to recover the raw ores.

== Recipes ==

While smelting steel is easily achieved with ice, other recipes usually require a working piping setup. This can be done by separating gases into tanks using atmospheric units and piping individual gases through a mixer and a [[Pressure Regulator]] or a [[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.'''
{| class="wikitable" style="background:#183d62; color: white"
! colspan="1" rowspan="2" | Item
! colspan="2" rowspan="1" style="text-align:center;" | Pressure (kPa)
! colspan="2" rowspan="1" style="text-align:center;" | Temp (K)
! colspan="2" rowspan="1" style="text-align:center;" | Temp (C)
! colspan="2" rowspan="1" style="text-align:center;" | Ingredients
! rowspan="2" | Notes
|-
!Min
!Max
!Min
!Max
!Min
!Max
!Ratio
!Ore
|-
| style="background:#183d62; color: white" | Lead
| colspan="1" rowspan="7" style="text-align:center;background:#183d62; color: white" | 100
| colspan="1" rowspan="7" style="text-align:center;background:#183d62; color: white" | 100,000
| style="text-align:center;background:#183d62; color: white" | 300
| colspan="1" rowspan="7" style="text-align:center;background:#183d62; color: white" | 100,000
| style="text-align:center;background:#183d62; color: white" | 26.85
| colspan="1" rowspan="7" style="text-align:center;background:#183d62; color: white" | 99,726.85
| colspan="1" rowspan="7" style="text-align:center;background:#183d62; color: white" | 1
| style="background:#183d62; color: white" | Lead
| colspan="1" rowspan="7" style="text-align:center;background:#183d62; color: white" |
|-
| style="background:#183d62; color: white" | Gold
| style="text-align:center;background:#183d62; color: white" | 600
| style="text-align:center;background:#183d62; color: white" | 326.85
| style="background:#183d62; color: white" | Gold
|-
| style="background:#183d62; color: white" | Copper
| style="text-align:center;background:#183d62; color: white" | 600
| style="text-align:center;background:#183d62; color: white" | 326.85
| style="background:#183d62; color: white" | Copper
|-
| style="background:#183d62; color: white" | Silver
| style="text-align:center;background:#183d62; color: white" | 600
| style="text-align:center;background:#183d62; color: white" | 326.85
| style="background:#183d62; color: white" | Silver
|-
| style="background:#183d62; color: white" | Nickel
| style="text-align:center;background:#183d62; color: white" | 800
| style="text-align:center;background:#183d62; color: white" | 526.85
| style="background:#183d62; color: white" | Nickel
|-
| style="background:#183d62; color: white" | Iron
| style="text-align:center;background:#183d62; color: white" | 900
| style="text-align:center;background:#183d62; color: white" | 626.85
| style="background:#183d62; color: white" | Iron
|-
| style="background:#183d62; color: white" | Silicon
| style="text-align:center;background:#183d62; color: white" | 900
| style="text-align:center;background:#183d62; color: white" | 626.85
| style="background:#183d62; color: white" | Silicon
|-
| style="background:#183d62; color: white" | [[Solder Ingot|Solder]]
| style="text-align:right;background:#183d62; color: white;" | 300
| style="text-align:right;background:#183d62; color: white;" | 3 500
| style="text-align:right;background:#183d62; color: white;" | 300
| style="text-align:right;background:#183d62; color: white;" | 2 000
| style="text-align:right;background:#183d62; color: white;" | 26.85
| style="text-align:right;background:#183d62; color: white;" | 1 726.85
| style="text-align:center;background:#183d62; color: white;" | 1:1
| style="background:#183d62; color: white" | Iron:Lead
| style="background:#183d62; color: white" | Can be achieved by dropping 2 oxite and 1 volatile
|-
| style="background:#183d62; color: white" | [[Steel Ingot|Steel]]
| style="text-align:right;background:#183d62; color: white;" | 100
| style="text-align:right;background:#183d62; color: white;" | 100 000
| style="text-align:right;background:#183d62; color: white;" | 600
| style="text-align:right;background:#183d62; color: white;" | 100 000
| style="text-align:right;background:#183d62; color: white;" | 326.85
| style="text-align:right;background:#183d62; color: white;" | 99,726.85
| style="text-align:center;background:#183d62; color: white;" | 3:1
| style="background:#183d62; color: white" | Iron:Carbon(Coal)
| style="background:#183d62; color: white" | Can easily be achieved by just dropping 1 oxite and 2 volatiles
|-
| style="background:#183d62; color: white" | [[Electrum Ingot|Electrum]]
| style="text-align:right;background:#183d62; color: white;" | 800
| style="text-align:right;background:#183d62; color: white;" | 2 400
| style="text-align:right;background:#183d62; color: white;" | 700
| style="text-align:right;background:#183d62; color: white;" | 10 000
| style="text-align:right;background:#183d62; color: white;" | 426.85
| style="text-align:right;background:#183d62; color: white;" | 9726.85
| style="text-align:center;background:#183d62; color: white;" | 1:1
| style="background:#183d62; color: white" | Gold:Silver
| style="background:#183d62; color: white" | Can be achieved by just dropping 1 oxite and 2 volatiles
|-
| style="background:#183d62; color: white" | [[Invar Ingot|Invar]]
| style="text-align:right;background:#183d62; color: white;" | 6 000
| style="text-align:right;background:#183d62; color: white;" | 7 000
| style="text-align:right;background:#183d62; color: white;" | 1 200
| style="text-align:right;background:#183d62; color: white;" | 2 000
| style="text-align:right;background:#183d62; color: white;" | 926.85
| style="text-align:right;background:#183d62; color: white;" | 1726.85
| style="text-align:center;background:#183d62; color: white;" | 1:1
| style="background:#183d62; color: white" | Iron:Nickel
| style="background:#183d62; color: white" | Can be achieved by just dropping 4 volatiles and 2 oxite (for 50:50)
|-
| style="background:#183d62;" |[[Constantan Ingot|Constantan]]
| style="text-align:right;background:#183d62; color: white;" | 100
| style="text-align:right;background:#183d62; color: white;" | 10 000
| style="text-align:right;background:#183d62; color: white;" | 1 000
| style="text-align:right;background:#183d62; color: white;" | 1 500
| style="text-align:right;background:#183d62; color: white;" | 726.85
| style="text-align:right;background:#183d62; color: white;" |1 226.85
| style="text-align:center;background:#183d62; color: white;" | 1:1
| style="background:#183d62; color: white" | Copper:Nickel
| style="background:#183d62; color: white" | Can be achieved by dropping 4 oxite and 1 volatile
|}

===Some example fuel mixes===

{| class="wikitable"
! colspan="1" rowspan="2" |Prime
! colspan="1" rowspan="2" |AFR
! colspan="2" rowspan="1" |In: Mols
! colspan="2" rowspan="1" |Result
! colspan="4" rowspan="1" |Out: Mols
|-
!H2
!O2
!Press.
!Temp
!O2
!H2
!Co2
!X
|-
|100 kPa
|2:1
|29
|14
|2 135
|1 953
|1
|3
|82
|33
|-
|200 kPa
|2:1
|59
|29
|4 500
|2 000
|1
|5
|169
|80
|-
|200 kPa
|3:1
|65
|21
|3 400
|1 900
|2
|26
|118
|52
|-
|200 kPa
|4:1
|72
|18
|3 000
|1 800
|1
|40
|99
|42
|-
|200 kPa
|1:1
|43
|43
|3 493
|1 917
|22
|2
|127
|59
|-
|200 kPa
|1:4
|17
|68
|1 646
|1 319
|63
|2
|50
|18
|-
|300 kPa
|2:1
|86
|42
|6 850
|2 109
|2
|7
|242
|115
|-
|500 kPa
|2:1
|143
|69
|11 814
|2 150
|3
|11
|400
|193
|}

{{Data Network Header}}

{{Data Parameters}}
{| class="wikitable"
|-
! Parameter Name !! Data Type !! Description
|-
| Open || Boolean || Opens the Furnace, when set to 1. Closes it, when set to 0.
|-
| Activate || Boolean || Activates the Furnace, when set to 1.
|-
| Lock || Boolean || Locks the Furnace, when set to 1. Unlocks it when set to 0.
|-
| Setting || Float || (Unknown) Affects the Setting output.
|}

{{Data Outputs}}
{| class="wikitable"
|-
! Output Name !! Data Type !! Description
|-
| Open || Boolean || Returns whether the Furnace is open. (0 for no, 1 for yes)
|-
| Pressure || Float || Returns the pressure in the Furnace in kilo pascal.
|-
| Temperature || Float || Returns the temperature in the Furnace in kelvin.
|-
| Lock || Boolean || Returns whether the Furnace is locked.
|-
| Setting || Float || (Unknown) Affected by the Setting parameter.
|-
| Reagents || Float || Returns the amount of reagents (smeltable ores, not counting ice) in the Furnace, in grams.
|-
| RatioOxygen || Float || Returns a range from 0.0 to 1.0. Returns the percentage ratio of the amount of oxygen in the Furnace.
|-
| 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.
|-
| 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.
|-
| Maximum || Integer || (Unknown) Returns 100.
|-
| Ratio || Float || (Unknown) Returns 0.5.
|-
| ImportQuantity || Float || Returns the amount of items in the import slot of the Furnace, which are currently smelted, in grams.
|-
| ImportSlotOccupant || Boolean || Returns whether there is something in the import slot of the Furnace, being smelted. (0 for no, 1 for yes)
|-
| ExportQuantity || Float || Returns the amount of items in the export slot of the Furnace, in grams. (Only briefly returns a value, when the Furnace is opened and items are exported.)
|-
| ExportSlotOccupant || Boolean || Returns whether there is something in the export slot of the Furnace. (Only briefly returns a value, when the Furnace is opened and items are exported.)
|}
</translate>

Always-on circuit guide

2018-08-17T22:28:26Z

Carsten Milkau: /* Improved version */

This circuit will check a device - in this example a [[Wall Light]] - and restart it, if it will shut down / deactivate for a reason.

<gallery>
AlwaysOnCircuit.jpg|Full Visual with Settings
</gallery>

[[File:AlwaysOnCircuit.jpg|thumb]]

== Trivia==
*This little thing was invented by user '''"Simoyd"''' in discord-chat "logic-ciruit-discussion" and needed and created by user "Raumfahrtdoc"
*This is super useful to restart the [[Kit (Gas Generator)]] / [[Gas Generator]]

== Improved version ==

[[File:Improved Always-On-Circuit.png|thumb|Improved Always-On-Circuit using only two I/O and two processing units.|thumb]]

Using the new [[Kit_(Logic_Processor)#Min.2FMax_Unit|Min/Max Unit]] as an OR gate and [[Kit_(Logic_Processor)#Compare_Unit|Compare unit]] as a (controlled) NOT gate, a much cheaper version is possible. Basically, it is a controlled clock that only runs when the device is off and otherwise stays at 1. The circuit can also be modified easily to make an always-off circuit (e.g. to auto-close doors), see table below.

{| class="wikitable"
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| reader || Logic Reader Unit || IN || '''device''' (whatever you want to control)
|-
| || || VAR || On (''Open'' for a door or switch)
|-
| max || Min/Max Unit || OPR || Greater (''Less'' for an always-off-circuit)
|-
| || || 1 (input 1) || reader
|-
| || || 2 (input 2) || compare
|-
| compare || Compare Unit || OUT || Equals (''NotEquals'' for an always-off-circuit)
|-
| || || 1 (input 1) || reader
|-
| || || 2 (input 2) || max
|-
| writer || Logic Writer || IN || max (''compare'' will also do)
|-
| || || OUT || '''device''' (whatever you want to control)
|-
| || || OUT VAR || On (''Open'' for a door or switch)
|}

File:Improved Always-On-Circuit.png

2018-08-17T22:06:29Z

Carsten Milkau: User created page with UploadWizard

=={{int:filedesc}}==
{{Information
|description={{en|1=Improved Always-On-Circuit using only two I/O and two processing units.}}
|date=2018-08-17
|source={{own}}
|author=[[User:Carsten Milkau|Carsten Milkau]]
|permission=
|other versions=
}}

=={{int:license-header}}==
{{licensing|generic}}

User:Carsten Milkau/NOT Gate

2018-07-19T17:49:17Z

Carsten Milkau: Created page with "= NOT Gate = A NOT gate, sometimes also called ''inverter'', is a circuit that outputs the value that was not input. It has a single input and output, and each can only take..."

= NOT Gate =

A NOT gate, sometimes also called ''inverter'', is a circuit that outputs the value that was not input. It has a single input and output, and each can only take one of two pre-defined values (typically 0 and 1). Whatever the input value is selected, the output value will be the other of the two.

== Definition ==

{| class="wikitable"
|+ value table
|-
!input || output
|-
|0||1
|-
|1||0
|}

=== Connectors ===

* Input: one of two values (0 or 1)
* Output: the other of the two values

== Implementation ==

NOT gates can often be avoided by modifying the circuit. For instance, if you use the output of a NOT gate to control the selector input of a [[Kit (Logic Processor)#Logic Select Unit|Logic Select Unit]], you can just switch the two inputs with each other instead and eleminate the NOT gate.

Unfortunately, there is no single-component implementation of a NOT gate. However, if you happen to have a data signal with a known value (like a memory containing a constant), often you can feed this signal into a single component in order to turn it into a NOT gate.

=== Using A Less-Than Comparator ===
=== Using An Equality Comparator ===
=== Using Subtraction ===

User:Carsten Milkau/

2018-07-19T17:19:56Z

Carsten Milkau: Carsten Milkau moved page User:Carsten Milkau/ to User:Carsten Milkau: title typo (sorry)

#REDIRECT [[User:Carsten Milkau]]

User:Carsten Milkau

2018-07-19T17:19:55Z

Carsten Milkau: Carsten Milkau moved page User:Carsten Milkau/ to User:Carsten Milkau: title typo (sorry)

A stationeer with interest in mathematics, engineering and sciences.

If you want to contact me, please leave a note on [[User_talk:Carsten_Milkau]]

== My pages ==
* [[User:Carsten Milkau/Dual-Atmosphere Airlock]]
* [[User:Carsten Milkau/RS-Latch]]
* [[User:Carsten Milkau/D-Latch]]
* [[User:Carsten Milkau/OR Gate]]

User:Carsten Milkau/Dual-Atmosphere Airlock

2018-07-19T17:18:18Z

Carsten Milkau: Adding User namespace to user pages.

== Structure ==

== Piping ==

== Electronics ==

=== Constants ===

* Zero
* "Vacuum" pressure

=== Target Atmosphere ===

* [[Kit (Logic Switch)|Switch]]
* [[User:Carsten Milkau/RS-Latch]]

=== Current Atmosphere ===

[[User:Carsten Milkau/D-Latch]]

=== Door sensor ===

* [[User:Carsten Milkau/OR Gate]]
* [[User:Carsten Milkau/NOT Gate]]

=== Door control ===

if (my atmosphere)
then (internal pressure >= external pressure)
else Zero

=== Vent activation ===

if (my atmosphere)
then (doors closed)
else Zero

=== Vent direction ===

[[User:Carsten Milkau/NOT Gate]]

User:Carsten Milkau

2018-07-19T17:16:22Z

Carsten Milkau: Possibly relevant info

User talk:Carsten Milkau

2018-07-19T17:14:58Z

Carsten Milkau: Welcome message

Hello, visitor! You can use this page to leave me a message. Please make a new section unless you are replying to an existing topic, and sign your messages using four tilde symbols (<nowiki>~~~~</nowiki>). -- [[User:Carsten Milkau|Carsten Milkau]] ([[User talk:Carsten Milkau|talk]]) 12:14, 19 July 2018 (CDT)

User:Carsten Milkau

2018-07-19T17:08:58Z

Carsten Milkau: /* My pages */

A stationeer with interest in mathematics, engineering and sciences.
== My pages ==
* [[User:Carsten Milkau/Dual-Atmosphere Airlock]]
* [[User:Carsten Milkau/RS-Latch]]
* [[User:Carsten Milkau/D-Latch]]
* [[User:Carsten Milkau/OR Gate]]

Carsten Milkau/OR Gate

2018-07-19T17:07:52Z

Carsten Milkau: Carsten Milkau moved page Carsten Milkau/OR Gate to User:Carsten Milkau/OR Gate: This was supposed to be a user page.

#REDIRECT [[User:Carsten Milkau/OR Gate]]

User:Carsten Milkau/OR Gate

2018-07-19T17:07:52Z

Carsten Milkau: Carsten Milkau moved page Carsten Milkau/OR Gate to User:Carsten Milkau/OR Gate: This was supposed to be a user page.

= OR Gate =

Since the advent of the [[Kit_(Logic_Processor)#Min.2FMax_Unit|Min/Max Unit]], OR and AND gates are actually extremely simple: just can use MAX for OR and MIN for AND.[[#fn_BooleanOrder|*]]

So the OR gate becomes a single Min/Max Unit with the following setup:

[[File:MinMaxUnit.png|thumb|Logic Processor Variation: Min/Max Unit]]

=== Connectors ===

* Top: Power
* Left: Input 1
* Right: Input 2
* Bottom: Output

=== Screws (options) ===

* Bottom Left: Input 1 Selector. Click with screwdriver to select the "left" operand
* Bottom Right: Input 2 Selector. Click with screwdriver to select the "right" operand
* Bottom Center: Operation Selector. '''Click with screwdriver to select "Greater"'''

== Notes ==

<cite id="fn_BooleanOrder">[[#fn_BooleanOrder_back|*)]]</cite> Note: (If you use numbers for TRUE and FALSE satisfying TRUE > FALSE, e.g. the popular choice of TRUE = 1 and FALSE = 0 satisfies 1 > 0. Otherwise, use MIN for OR and MAX for AND).

User:Carsten Milkau

2018-07-19T17:06:36Z

Carsten Milkau: Created page with "A stationeer with interest in mathematics, engineering and sciences. == My pages == User:Carsten Milkau/Dual-Atmosphere Airlock User:Carsten Milkau/D-Latch User:Cars..."

A stationeer with interest in mathematics, engineering and sciences.
== My pages ==
[[User:Carsten Milkau/Dual-Atmosphere Airlock]]
[[User:Carsten Milkau/D-Latch]]
[[User:Carsten Milkau/RS-Latch]]

Carsten Milkau/RS-Latch

2018-07-18T22:08:43Z

Carsten Milkau: Carsten Milkau moved page Carsten Milkau/RS-Latch to User:Carsten Milkau/RS-Latch: This was supposed to be a user page.

#REDIRECT [[User:Carsten Milkau/RS-Latch]]

User:Carsten Milkau/RS-Latch

2018-07-18T22:08:42Z

Carsten Milkau: Carsten Milkau moved page Carsten Milkau/RS-Latch to User:Carsten Milkau/RS-Latch: This was supposed to be a user page.

An RS-latch is a circuit that stores which of its inputs was last "on". It has typically two inputs: input ''reset'' storing value "0" and input ''set'' storing value "1", hence the name. It can have multiple outputs (possibly inverted), which typically differ mostly in their behavior when multiple inputs are "on" at the same time. Usually, it is considered illegal to set more than one input to "on", but sometimes this is used deliberately (e.g. when constructing an [[Edge-Triggered RS-Latch]]).

== Definition ==

{| class="wikitable"
|+ value table
|-
!colspan="4"|'''inputs'''||colspan="4"|'''outputs'''
|-
!reset||set||output1 (previous)||output2 (previous)||output1||output2
|-
|0||0||''x''||''y''||''y''||''x''
|-
|0||1||''x''||''y''||0||0
|-
|1||0||''x''||''y''||1||1
|-
|1||1||''x''||''y''||0||1
|}

It is possible to define a variant with more than two values. Also, the values stored need not necessarily be 0 and 1.

=== Connectors ===

* Reset: Stores the first value (typically 0)
* Set: Stores the second value (typically 1)
* Output1: Stored value (first value if in illegal state)
* Output2: Stored value (second value if in illegal state)

=== Illegal State ===

If multiple inputs are on at the same time, the latch is considered in "illegal state". In principle, the RS-latch assumes both values at once, which circulate through the latch when both inputs turn off immediately (see value table), i.e. the latch becomes a [[Clock]]. This is usually undesired, but can be useful in some cases.

== Implementation Using Logic Select Units ==

[[File:RS-Latch Using Select Units.png|thumb|An RS-Latch implemented using two Logic Select Units and two Logic Memory units]]

This RS-latch can store arbitrary values. It can also easily be extended to support more than two different values. It consists of a loop of [[Kit (Logic Processor)#Logic Select Unit|Logic Select Units]], each connected to a dedicated memory cell (or other data source). If all inputs are off, the values circulate in the loop. If one input is on, its corresponding value is read from the respective memory cell and replaces all values in the loop (unless an additional input is on).

{| class="wikitable"
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| select 1 || Logic Select Unit || select || '''reset''' (input)
|-
| || || 0 (input 1) || select 2
|-
| || || 1 (input 2) || "0" (constant)
|-
| || || output || '''output1''' (output)
|-
| select 2 || Logic Select Unit || select || '''set''' (input)
|-
| || || 0 (input 1) || select 1
|-
| || || 1 (input 2) || "1" (constant)
|-
| || || output || '''output2''' (output)
|}

Carsten Milkau/D-Latch

2018-07-18T22:07:47Z

Carsten Milkau: Carsten Milkau moved page Carsten Milkau/D-Latch to User:Carsten Milkau/D-Latch: This was supposed to be a user page.

#REDIRECT [[User:Carsten Milkau/D-Latch]]

User:Carsten Milkau/D-Latch

2018-07-18T22:07:47Z

Carsten Milkau: Carsten Milkau moved page Carsten Milkau/D-Latch to User:Carsten Milkau/D-Latch: This was supposed to be a user page.

A d-latch is a circuit that stores the last value seen at its "data" input while its "enable" input was on.

== Definition ==

{| class="wikitable"
|+ value table
|-
!colspan="3"|'''inputs'''||'''outputs'''
|-
!enable||data||previous output||output
|-
|0||''x''||''y''||''y''
|-
|1||''x''||''y''||''x''
|}

=== Connectors ===

* enable: if 1, store ''data'', else do nothing.
* data: input
* output: stored value

== Relation to Multiplexer (Logic Select Unit) ==

In theory, a single multiplexer ([[Kit_(Logic_Processor)#Logic_Select_Unit|Logic Select Unit]]) can do this (selector input = enable, input 1 = output, input 2 = data, output = output). In practice, this is not possible as the game does not allow it to have its own output as input. However, several constructions using two or more circuits are possible.

== Implementation Using Logic Select Unit and Logic Reader ==

[[File:D-latch.png|thumb|D-latch using select unit and reader]]

This d-latch can store any value. It works in two steps:

<ol>
<li>a Logic Select Unit determines whether to store the last output or the "data" input using the "enable" input. i.e.
<pre> if enable
then store = data
else store = output</pre></li>
<li>a [[Kit_(Logic_I/O)#Logic_Reader|Logic Reader]] mirrors the value to be stored and feeds it back into the select unit so it can circulate (effectively being stored). This would be obsolete if the select unit could read its own output.
<pre> output = store</pre></li>
</ol>

{| class="wikitable"
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| select 1 || Logic Select Unit || select || '''enable''' (input)
|-
| || || 0 (input 1) || reader 1
|-
| || || 1 (input 2) || '''data''' (input)
|-
| reader 1 || Logic Reader || in || select 1
|-
| || || var || setting
|-
| || || out || '''output''' (output)
|}

User:Carsten Milkau/Dual-Atmosphere Airlock

2018-07-18T21:54:53Z

Carsten Milkau: Restructuring

== Structure ==

== Piping ==

== Electronics ==

=== Constants ===

* Zero
* "Vacuum" pressure

=== Target Atmosphere ===

* [[Kit (Logic Switch)|Switch]]
* [[Carsten Milkau/RS-Latch]]

=== Current Atmosphere ===

[[Carsten Milkau/D-Latch]]

=== Door sensor ===

* [[Carsten Milkau/OR Gate]]
* [[Carsten Milkau/NOT Gate]]

=== Door control ===

if (my atmosphere)
then (internal pressure >= external pressure)
else Zero

=== Vent activation ===

if (my atmosphere)
then (doors closed)
else Zero

=== Vent direction ===

[[Carsten Milkau/NOT Gate]]

User:Carsten Milkau/D-Latch

2018-07-18T21:50:25Z

Carsten Milkau: enabled -> enable

User:Carsten Milkau/D-Latch

2018-07-18T21:45:16Z

Carsten Milkau: Restructuring

A d-latch is a circuit that stores the last value seen at its "data" input while its "enable" input was on.

== Definition ==

{| class="wikitable"
|+ value table
|-
!colspan="3"|'''inputs'''||'''outputs'''
|-
!enabled||data||previous output||output
|-
|0||''x''||''y''||''y''
|-
|1||''x''||''y''||''x''
|}

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

== Relation to Multiplexer (Logic Select Unit) ==

In theory, a single multiplexer ([[Kit_(Logic_Processor)#Logic_Select_Unit|Logic Select Unit]]) can do this (selector input = enable, input 1 = output, input 2 = data, output = output). In practice, this is not possible as the game does not allow it to have its own output as input. However, several constructions using two or more circuits are possible.

== Implementation Using Logic Select Unit and Logic Reader ==

[[File:D-latch.png|thumb|D-latch using select unit and reader]]

This d-latch can store any value. It works in two steps:

<ol>
<li>a Logic Select Unit determines whether to store the last output or the "data" input using the "enabled" input. i.e.
<pre> if enabled
then store = data
else store = output</pre></li>
<li>a [[Kit_(Logic_I/O)#Logic_Reader|Logic Reader]] mirrors the value to be stored and feeds it back into the select unit so it can circulate (effectively being stored). This would be obsolete if the select unit could read its own output.
<pre> output = store</pre></li>
</ol>

{| class="wikitable"
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| select 1 || Logic Select Unit || select || '''enabled''' (input)
|-
| || || 0 (input 1) || reader 1
|-
| || || 1 (input 2) || '''data''' (input)
|-
| reader 1 || Logic Reader || in || select 1
|-
| || || var || setting
|-
| || || out || '''output''' (output)
|}

User:Carsten Milkau/RS-Latch

2018-07-18T21:42:08Z

Carsten Milkau: /* RS-latch */

User:Carsten Milkau/RS-Latch

2018-07-18T21:38:09Z

Carsten Milkau: /* Illegal State */

== RS-latch ==

An RS-latch is a circuit that stores which of its inputs was last "on". It has typically two inputs: input ''reset'' storing value "0" and input ''set'' storing value "1", hence the name. It can have multiple outputs (possibly inverted), which typically differ mostly in their behavior when multiple inputs are "on" at the same time. Usually, it is considered illegal to set more than one input to "on", but sometimes this is used deliberately (e.g. when constructing an [[Edge-Triggered RS-Latch]]).

{| class="wikitable"
|+ value table
|-
!colspan="4"|'''inputs'''||colspan="4"|'''outputs'''
|-
!reset||set||output1 (previous)||output2 (previous)||output1||output2
|-
|0||0||''x''||''y''||''y''||''x''
|-
|0||1||''x''||''y''||0||0
|-
|1||0||''x''||''y''||1||1
|-
|1||1||''x''||''y''||0||1
|}

It is possible to define a variant with more than two values. Also, the values stored need not necessarily be 0 and 1.

=== Connectors ===

* Reset: Stores the first value (typically 0)
* Set: Stores the second value (typically 1)
* Output1: Stored value (first value if in illegal state)
* Output2: Stored value (second value if in illegal state)

=== Illegal State ===

If multiple inputs are on at the same time, the latch is considered in "illegal state". In principle, the RS-latch assumes both values at once, which circulate through the latch when both inputs turn off immediately (see value table), i.e. the latch becomes a [[Clock]]. This is usually undesired, but can be useful in some cases.

=== Using Logic Select Units ===

[[File:RS-Latch Using Select Units.png|thumb|An RS-Latch implemented using two Logic Select Units and two Logic Memory units]]

This RS-latch can store arbitrary values. It can also easily be extended to support more than two different values. It consists of a loop of [[Kit (Logic Processor)#Logic Select Unit|Logic Select Units]], each connected to a dedicated memory cell (or other data source). If all inputs are off, the values circulate in the loop. If one input is on, its corresponding value is read from the respective memory cell and replaces all values in the loop (unless an additional input is on).

{| class="wikitable"
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| select 1 || Logic Select Unit || select || '''reset''' (input)
|-
| || || 0 (input 1) || select 2
|-
| || || 1 (input 2) || "0" (constant)
|-
| || || output || '''output1''' (output)
|-
| select 2 || Logic Select Unit || select || '''set''' (input)
|-
| || || 0 (input 1) || select 1
|-
| || || 1 (input 2) || "1" (constant)
|-
| || || output || '''output2''' (output)
|}

User:Carsten Milkau/RS-Latch

2018-07-18T21:30:00Z

Carsten Milkau: /* Connectors */

== RS-latch ==

An RS-latch is a circuit that stores which of its inputs was last "on". It has typically two inputs: input ''reset'' storing value "0" and input ''set'' storing value "1", hence the name. It can have multiple outputs (possibly inverted), which typically differ mostly in their behavior when multiple inputs are "on" at the same time. Usually, it is considered illegal to set more than one input to "on", but sometimes this is used deliberately (e.g. when constructing an [[Edge-Triggered RS-Latch]]).

{| class="wikitable"
|+ value table
|-
!colspan="4"|'''inputs'''||colspan="4"|'''outputs'''
|-
!reset||set||output1 (previous)||output2 (previous)||output1||output2
|-
|0||0||''x''||''y''||''y''||''x''
|-
|0||1||''x''||''y''||0||0
|-
|1||0||''x''||''y''||1||1
|-
|1||1||''x''||''y''||0||1
|}

It is possible to define a variant with more than two values. Also, the values stored need not necessarily be 0 and 1.

=== Connectors ===

* Reset: Stores the first value (typically 0)
* Set: Stores the second value (typically 1)
* Output1: Stored value (first value if in illegal state)
* Output2: Stored value (second value if in illegal state)

=== Using Logic Select Units ===

[[File:RS-Latch Using Select Units.png|thumb|An RS-Latch implemented using two Logic Select Units and two Logic Memory units]]

This RS-latch can store arbitrary values. It can also easily be extended to support more than two different values. It consists of a loop of [[Kit (Logic Processor)#Logic Select Unit|Logic Select Units]], each connected to a dedicated memory cell (or other data source). If all inputs are off, the values circulate in the loop. If one input is on, its corresponding value is read from the respective memory cell and replaces all values in the loop (unless an additional input is on).

{| class="wikitable"
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| select 1 || Logic Select Unit || select || '''reset''' (input)
|-
| || || 0 (input 1) || select 2
|-
| || || 1 (input 2) || "0" (constant)
|-
| || || output || '''output1''' (output)
|-
| select 2 || Logic Select Unit || select || '''set''' (input)
|-
| || || 0 (input 1) || select 1
|-
| || || 1 (input 2) || "1" (constant)
|-
| || || output || '''output2''' (output)
|}

User:Carsten Milkau/RS-Latch

2018-07-18T21:25:19Z

Carsten Milkau: /* RS-latch */ illegal state

== RS-latch ==

An RS-latch is a circuit that stores which of its inputs was last "on". It has typically two inputs: input ''reset'' storing value "0" and input ''set'' storing value "1", hence the name. It can have multiple outputs (possibly inverted), which typically differ mostly in their behavior when multiple inputs are "on" at the same time. Usually, it is considered illegal to set more than one input to "on", but sometimes this is used deliberately (e.g. when constructing an [[Edge-Triggered RS-Latch]]).

{| class="wikitable"
|+ value table
|-
!colspan="4"|'''inputs'''||colspan="4"|'''outputs'''
|-
!reset||set||output1 (previous)||output2 (previous)||output1||output2
|-
|0||0||''x''||''y''||''y''||''x''
|-
|0||1||''x''||''y''||0||0
|-
|1||0||''x''||''y''||1||1
|-
|1||1||''x''||''y''||0||1
|}

It is possible to define a variant with more than two values. Also, the values stored need not necessarily be 0 and 1.

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

=== Using Logic Select Units ===

[[File:RS-Latch Using Select Units.png|thumb|An RS-Latch implemented using two Logic Select Units and two Logic Memory units]]

This RS-latch can store arbitrary values. It can also easily be extended to support more than two different values. It consists of a loop of [[Kit (Logic Processor)#Logic Select Unit|Logic Select Units]], each connected to a dedicated memory cell (or other data source). If all inputs are off, the values circulate in the loop. If one input is on, its corresponding value is read from the respective memory cell and replaces all values in the loop (unless an additional input is on).

{| class="wikitable"
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| select 1 || Logic Select Unit || select || '''reset''' (input)
|-
| || || 0 (input 1) || select 2
|-
| || || 1 (input 2) || "0" (constant)
|-
| || || output || '''output1''' (output)
|-
| select 2 || Logic Select Unit || select || '''set''' (input)
|-
| || || 0 (input 1) || select 1
|-
| || || 1 (input 2) || "1" (constant)
|-
| || || output || '''output2''' (output)
|}

User:Carsten Milkau/RS-Latch

2018-07-18T21:17:40Z

Carsten Milkau: /* Using Logic Select Units */

== RS-latch ==

An RS-latch is a circuit that stores which of its inputs was last "on". It has typically two inputs: input ''reset'' storing value "0" and input ''set'' storing value "1", hence the name. It can have multiple outputs, which typically differ mostly in their behavior when multiple inputs are "on" at the same time.

{| class="wikitable"
|+ value table
|-
!colspan="4"|'''inputs'''||colspan="4"|'''outputs'''
|-
!reset||set||output1 (previous)||output2 (previous)||output1||output2
|-
|0||0||''x''||''y''||''y''||''x''
|-
|0||1||''x''||''y''||0||0
|-
|1||0||''x''||''y''||1||1
|-
|1||1||''x''||''y''||0||1
|}

It is possible to define a variant with more than two values. The values stored need not necessarily be 0 and 1.

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

=== Using Logic Select Units ===

[[File:RS-Latch Using Select Units.png|thumb|An RS-Latch implemented using two Logic Select Units and two Logic Memory units]]

This RS-latch can store arbitrary values. It can also easily be extended to support more than two different values. It consists of a loop of [[Kit (Logic Processor)#Logic Select Unit|Logic Select Units]], each connected to a dedicated memory cell (or other data source). If all inputs are off, the values circulate in the loop. If one input is on, its corresponding value is read from the respective memory cell and replaces all values in the loop (unless an additional input is on).

{| class="wikitable"
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| select 1 || Logic Select Unit || select || '''reset''' (input)
|-
| || || 0 (input 1) || select 2
|-
| || || 1 (input 2) || "0" (constant)
|-
| || || output || '''output1''' (output)
|-
| select 2 || Logic Select Unit || select || '''set''' (input)
|-
| || || 0 (input 1) || select 1
|-
| || || 1 (input 2) || "1" (constant)
|-
| || || output || '''output2''' (output)
|}

User:Carsten Milkau/RS-Latch

2018-07-18T21:16:08Z

Carsten Milkau: /* Using Logic Select Units */

== RS-latch ==

An RS-latch is a circuit that stores which of its inputs was last "on". It has typically two inputs: input ''reset'' storing value "0" and input ''set'' storing value "1", hence the name. It can have multiple outputs, which typically differ mostly in their behavior when multiple inputs are "on" at the same time.

{| class="wikitable"
|+ value table
|-
!colspan="4"|'''inputs'''||colspan="4"|'''outputs'''
|-
!reset||set||output1 (previous)||output2 (previous)||output1||output2
|-
|0||0||''x''||''y''||''y''||''x''
|-
|0||1||''x''||''y''||0||0
|-
|1||0||''x''||''y''||1||1
|-
|1||1||''x''||''y''||0||1
|}

It is possible to define a variant with more than two values. The values stored need not necessarily be 0 and 1.

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

=== Using Logic Select Units ===

[[File:RS-Latch Using Select Units.png|thumb|An RS-Latch implemented using two Logic Select Units and two Logic Memory units]]

This RS-latch can store arbitrary values. It can also easily be extended to support more than two different values. It consists of a loop of [[Kit (Logic Processor)#Logic Select Unit|Logic Select Units]], each connected to a dedicated memory cell (or other data source). If all inputs are off, the values circulate in the loop. If one input is on, its corresponding value is read from the respective memory cell and replaces all values in the loop (unless an additional input is on).

{| class="wikitable"
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| select 1 || Logic Select Unit || select || '''reset''' (input)
|-
| || || 0 (input 1) || select 2
|-
| || || 1 (input 2) || memory 1 (constant)
|-
| || || output || '''output1''' (output)
|-
| select 2 || Logic Select Unit || select || '''set''' (input)
|-
| || || 0 (input 1) || select 1
|-
| || || 1 (input 2) || memory 2 (constant)
|-
| || || output || '''output2''' (output)
|}

File:RS-Latch Using Select Units.png

2018-07-18T21:02:34Z

Carsten Milkau: Carsten Milkau uploaded a new version of File:RS-Latch Using Select Units.png

=={{int:filedesc}}==
{{Information
|description={{en|1=An RS-Latch implemented using two Logic Select Units and two Logic Memory units}}
|date=2018-07-18
|source={{own}}
|author=[[User:Carsten Milkau|Carsten Milkau]]
|permission=
|other versions=
}}

=={{int:license-header}}==
{{licensing|generic}}

User:Carsten Milkau/RS-Latch

2018-07-18T20:58:44Z

Carsten Milkau: /* RS-latch */ image

== RS-latch ==

An RS-latch is a circuit that stores which of its inputs was last "on". It has typically two inputs: input ''reset'' storing value "0" and input ''set'' storing value "1", hence the name. It can have multiple outputs, which typically differ mostly in their behavior when multiple inputs are "on" at the same time.

{| class="wikitable"
|+ value table
|-
!colspan="4"|'''inputs'''||colspan="4"|'''outputs'''
|-
!reset||set||output1 (previous)||output2 (previous)||output1||output2
|-
|0||0||''x''||''y''||''y''||''x''
|-
|0||1||''x''||''y''||0||0
|-
|1||0||''x''||''y''||1||1
|-
|1||1||''x''||''y''||0||1
|}

It is possible to define a variant with more than two values. The values stored need not necessarily be 0 and 1.

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

=== Using Logic Select Unit and Logic Reader ===

[[File:RS-Latch Using Select Units.png|thumb|An RS-Latch implemented using two Logic Select Units and two Logic Memory units]]

This d-latch can store any value. It works in two steps:

<ol>
<li>a Logic Select Unit determines whether to store the last output or the "data" input using the "enabled" input. i.e.
<pre> if enabled
then store = data
else store = output</pre></li>
<li>a [[Kit_(Logic_I/O)#Logic_Reader|Logic Reader]] mirrors the value to be stored and feeds it back into the select unit so it can circulate (effectively being stored). This would be obsolete if the select unit could read its own output.
<pre> output = store</pre></li>
</ol>

{| class="wikitable"
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| select 1 || Logic Select Unit || select || '''enabled''' (input)
|-
| || || 0 (input 1) || reader 1
|-
| || || 1 (input 2) || '''data''' (input)
|-
| reader 1 || Logic Reader || in || select 1
|-
| || || var || setting
|-
| || || out || '''output''' (output)
|}

File:RS-Latch Using Select Units.png

2018-07-18T20:57:13Z

Carsten Milkau: User created page with UploadWizard

User:Carsten Milkau/RS-Latch

2018-07-18T20:45:03Z

Carsten Milkau: Introduction

== RS-latch ==

An RS-latch is a circuit that stores which of its inputs was last "on". It has typically two inputs: input ''reset'' storing value "0" and input ''set'' storing value "1", hence the name. It can have multiple outputs, which typically differ mostly in their behavior when multiple inputs are "on" at the same time.

{| class="wikitable"
|+ value table
|-
!colspan="4"|'''inputs'''||colspan="4"|'''outputs'''
|-
!reset||set||output1 (previous)||output2 (previous)||output1||output2
|-
|0||0||''x''||''y''||''y''||''x''
|-
|0||1||''x''||''y''||0||0
|-
|1||0||''x''||''y''||1||1
|-
|1||1||''x''||''y''||0||1
|}

It is possible to define a variant with more than two values. The values stored need not necessarily be 0 and 1.

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

=== Using Logic Select Unit and Logic Reader ===

[[File:D-latch.png|thumb|D-latch using select unit and reader]]

This d-latch can store any value. It works in two steps:

<ol>
<li>a Logic Select Unit determines whether to store the last output or the "data" input using the "enabled" input. i.e.
<pre> if enabled
then store = data
else store = output</pre></li>
<li>a [[Kit_(Logic_I/O)#Logic_Reader|Logic Reader]] mirrors the value to be stored and feeds it back into the select unit so it can circulate (effectively being stored). This would be obsolete if the select unit could read its own output.
<pre> output = store</pre></li>
</ol>

{| class="wikitable"
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| select 1 || Logic Select Unit || select || '''enabled''' (input)
|-
| || || 0 (input 1) || reader 1
|-
| || || 1 (input 2) || '''data''' (input)
|-
| reader 1 || Logic Reader || in || select 1
|-
| || || var || setting
|-
| || || out || '''output''' (output)
|}

File:D-latch.png

2018-07-18T20:27:10Z

Carsten Milkau: Carsten Milkau uploaded a new version of File:D-latch.png

=={{int:filedesc}}==
{{Information
|description={{en|1=D-latch using select unit and reader}}
|date=2018-07-17
|source={{own}}
|author=[[User:Carsten Milkau|Carsten Milkau]]
|permission=
|other versions=
}}

=={{int:license-header}}==
{{licensing|generic}}

User:Carsten Milkau/D-Latch

2018-07-18T18:11:49Z

Carsten Milkau: /* Using Logic Select Unit and Logic Reader */

== D-latch ==

A d-latch is a circuit that stores the last value seen at its "data" input while its "enable" input was on.

{| class="wikitable"
|+ value table
|-
!colspan="3"|'''inputs'''||'''outputs'''
|-
!enabled||data||previous output||output
|-
|0||''x''||''y''||''y''
|-
|1||''x''||''y''||''x''
|}

In theory, a single [[Kit_(Logic_Processor)#Logic_Select_Unit|Logic Select Unit]] can do this (selector input = enable, input 1 = output, input 2 = data, output = output). In practice, this is not possible as the game does not allow it to have its own output as input. However, several constructions using two or more circuits are possible.

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

=== Using Logic Select Unit and Logic Reader ===

[[File:D-latch.png|thumb|D-latch using select unit and reader]]

This d-latch can store any value. It works in two steps:

<ol>
<li>a Logic Select Unit determines whether to store the last output or the "data" input using the "enabled" input. i.e.
<pre> if enabled
then store = data
else store = output</pre></li>
<li>a [[Kit_(Logic_I/O)#Logic_Reader|Logic Reader]] mirrors the value to be stored and feeds it back into the select unit so it can circulate (effectively being stored). This would be obsolete if the select unit could read its own output.
<pre> output = store</pre></li>
</ol>

{| class="wikitable"
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| select 1 || Logic Select Unit || select || '''enabled''' (input)
|-
| || || 0 (input 1) || reader 1
|-
| || || 1 (input 2) || '''data''' (input)
|-
| reader 1 || Logic Reader || in || select 1
|-
| || || var || setting
|-
| || || out || '''output''' (output)
|}

User:Carsten Milkau/D-Latch

2018-07-18T18:10:49Z

Carsten Milkau: /* D-latch */

== D-latch ==

A d-latch is a circuit that stores the last value seen at its "data" input while its "enable" input was on.

{| class="wikitable"
|+ value table
|-
!colspan="3"|'''inputs'''||'''outputs'''
|-
!enabled||data||previous output||output
|-
|0||''x''||''y''||''y''
|-
|1||''x''||''y''||''x''
|}

In theory, a single [[Kit_(Logic_Processor)#Logic_Select_Unit|Logic Select Unit]] can do this (selector input = enable, input 1 = output, input 2 = data, output = output). In practice, this is not possible as the game does not allow it to have its own output as input. However, several constructions using two or more circuits are possible.

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

=== Using Logic Select Unit and Logic Reader ===

[[File:D-latch.png|thumb|D-latch using select unit and reader]]

This d-latch can store any value. It works in two steps:

<ol>
<li>a select unit determines whether to store the last output or the "data" input using the "enabled" input. i.e.
<pre> if enabled
then store = data
else store = output</pre></li>
<li>a [[Kit_(Logic_I/O)#Logic_Reader|logic reader]] mirrors the value to be stored and feeds it back into the select unit so it can circulate (effectively being stored). This would be obsolete if the select unit could read its own output.
<pre> output = store</pre></li>
</ol>

{| class="wikitable"
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| select 1 || Logic Select Unit || select || '''enabled''' (input)
|-
| || || 0 (input 1) || reader 1
|-
| || || 1 (input 2) || '''data''' (input)
|-
| reader 1 || Logic Reader || in || select 1
|-
| || || var || setting
|-
| || || out || '''output''' (output)
|}

User:Carsten Milkau/D-Latch

2018-07-18T18:09:11Z

Carsten Milkau: /* D-latch */

== D-latch ==

A d-latch is a circuit that stores the last value seen at its "data" input while its "enable" input was on.

{| class="wikitable"
|+ value table
|-
!colspan="3"|'''inputs'''||'''outputs'''
|-
!enabled||data||previous output||output
|-
|0||x||y||y
|-
|1||x||y||x
|}

In theory, a single [[Kit_(Logic_Processor)#Logic_Select_Unit|Logic Select Unit]] can do this (selector input = enable, input 1 = output, input 2 = data, output = output). In practice, this is not possible as the game does not allow it to have its own output as input. However, several constructions using two or more circuits are possible.

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

=== Using Logic Select Unit and Logic Reader ===

[[File:D-latch.png|thumb|D-latch using select unit and reader]]

This d-latch can store any value. It works in two steps:

<ol>
<li>a select unit determines whether to store the last output or the "data" input using the "enabled" input. i.e.
<pre> if enabled
then store = data
else store = output</pre></li>
<li>a [[Kit_(Logic_I/O)#Logic_Reader|logic reader]] mirrors the value to be stored and feeds it back into the select unit so it can circulate (effectively being stored). This would be obsolete if the select unit could read its own output.
<pre> output = store</pre></li>
</ol>

{| class="wikitable"
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| select 1 || Logic Select Unit || select || '''enabled''' (input)
|-
| || || 0 (input 1) || reader 1
|-
| || || 1 (input 2) || '''data''' (input)
|-
| reader 1 || Logic Reader || in || select 1
|-
| || || var || setting
|-
| || || out || '''output''' (output)
|}

User:Carsten Milkau/D-Latch

2018-07-18T18:04:19Z

Carsten Milkau: /* D-latch */

== D-latch ==

A d-latch is a circuit that stores the last value seen at its "data" input while its "enable" input was on.

{|
|enabled||data||previous output||output
|-
|0||x||y||y
|-
|1||x||y||x
|}

In theory, a single [[Kit_(Logic_Processor)#Logic_Select_Unit|Logic Select Unit]] can do this (selector input = enable, input 1 = output, input 2 = data, output = output). In practice, this is not possible as the game does not allow it to have its own output as input. However, several constructions using two or more circuits are possible.

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

=== Using Logic Select Unit and Logic Reader ===

[[File:D-latch.png|thumb|D-latch using select unit and reader]]

This d-latch can store any value. It works in two steps:

<ol>
<li>a select unit determines whether to store the last output or the "data" input using the "enabled" input. i.e.
<pre> if enabled
then store = data
else store = output</pre></li>
<li>a [[Kit_(Logic_I/O)#Logic_Reader|logic reader]] mirrors the value to be stored and feeds it back into the select unit so it can circulate (effectively being stored). This would be obsolete if the select unit could read its own output.
<pre> output = store</pre></li>
</ol>

{| class="wikitable"
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| select 1 || Logic Select Unit || select || '''enabled''' (input)
|-
| || || 0 (input 1) || reader 1
|-
| || || 1 (input 2) || '''data''' (input)
|-
| reader 1 || Logic Reader || in || select 1
|-
| || || var || setting
|-
| || || out || '''output''' (output)
|}

User:Carsten Milkau/D-Latch

2018-07-18T18:00:09Z

Carsten Milkau: /* Using Select Unit and Logic Reader */

== D-latch ==

A d-latch is a circuit that stores the last value seen at its "data" input while its "enable" input was on.

{|
|enabled||data||previous output||output
|-
|0||x||y||y
|-
|1||x||y||x
|}

In theory, a single [[Kit_(Logic_Processor)#Logic_Select_Unit|select unit]] can do this (selector input = enable, input 1 = output, input 2 = data, output = output). In practice, this is not possible as the game does not allow it to have its own output as input. However, several constructions using two or more circuits are possible.

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

=== Using Select Unit and Logic Reader ===

[[File:D-latch.png|thumb|D-latch using select unit and reader]]

This d-latch can store any value. It works in two steps:

<ol>
<li>a select unit determines whether to store the last output or the "data" input using the "enabled" input. i.e.
<pre> if enabled
then store = data
else store = output</pre></li>
<li>a [[Kit_(Logic_I/O)#Logic_Reader|logic reader]] mirrors the value to be stored and feeds it back into the select unit so it can circulate (effectively being stored). This would be obsolete if the select unit could read its own output.
<pre> output = store</pre></li>
</ol>

{| class="wikitable"
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| select 1 || Logic Select Unit || select || '''enabled''' (input)
|-
| || || 0 (input 1) || reader 1
|-
| || || 1 (input 2) || '''data''' (input)
|-
| reader 1 || Logic Reader || in || select 1
|-
| || || var || setting
|-
| || || out || '''output''' (output)
|}

User:Carsten Milkau/D-Latch

2018-07-18T17:54:26Z

Carsten Milkau: /* Using Select Unit and Logic Reader */

== D-latch ==

A d-latch is a circuit that stores the last value seen at its "data" input while its "enable" input was on.

{|
|enabled||data||previous output||output
|-
|0||x||y||y
|-
|1||x||y||x
|}

In theory, a single [[Kit_(Logic_Processor)#Logic_Select_Unit|select unit]] can do this (selector input = enable, input 1 = output, input 2 = data, output = output). In practice, this is not possible as the game does not allow it to have its own output as input. However, several constructions using two or more circuits are possible.

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

=== Using Select Unit and Logic Reader ===

[[File:D-latch.png|thumb|D-latch using select unit and reader]]

This d-latch can store any value. It works in two steps:

<ol>
<li>a select unit determines whether to store the last output or the "data" input using the "enabled" input. i.e.
<pre> if enabled
then store = data
else store = output</pre></li>
<li>a [[Kit_(Logic_I/O)#Logic_Reader|logic reader]] mirrors the value to be stored and feeds it back into the select unit so it can circulate (effectively being stored). This would be obsolete if the select unit could read its own output.
<pre> output = store</pre></li>
</ol>

{|
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| select 1 || Select Unit || selector input || '''enabled''' (input)
|-
| || || 0 (input 1) || reader 1
|-
| || || 1 (input 2) || '''data''' (input)
|-
| reader 1 || Logic Reader || in || select 1
|-
| || || var || setting
|-
| || || out || '''output''' (output)
|}

User:Carsten Milkau/D-Latch

2018-07-18T17:53:32Z

Carsten Milkau: /* Using Select Unit and Logic Reader */

== D-latch ==

A d-latch is a circuit that stores the last value seen at its "data" input while its "enable" input was on.

{|
|enabled||data||previous output||output
|-
|0||x||y||y
|-
|1||x||y||x
|}

In theory, a single [[Kit_(Logic_Processor)#Logic_Select_Unit|select unit]] can do this (selector input = enable, input 1 = output, input 2 = data, output = output). In practice, this is not possible as the game does not allow it to have its own output as input. However, several constructions using two or more circuits are possible.

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

=== Using Select Unit and Logic Reader ===

[[File:D-latch.png|thumb|D-latch using select unit and reader]]

This d-latch can store any value. It works in two steps:

<ol>
<li>a select unit determines whether to store the last output or the "data" input using the "enabled" input. i.e.
<pre> if enabled
then store = data
else store = output</pre></li>
<li>a [[Kit_(Logic_I/O)#Logic_Reader|logic reader]] mirrors the value to be stored and feeds it back into the select unit so it can circulate (effectively being stored). This would be obsolete if the select unit could read its own output.
<pre> output = store</pre></li>
</ol>

{|
|+ Circuit setup
|-
! Unit name || Unit type || Connector / Setting || Source / Value
|-
| select 1 || Select Unit || selector input || '''enabled''' (input)
|-
| || || 0 (input 1) || reader 1
|-
| || || 1 (input 2) || '''data''' (input)
|-
| reader 1 || Logic Reader || in || select 1
|-
| || || var || setting
|-
| || || out || '''stored''' (output)
|}

User:Carsten Milkau/D-Latch

2018-07-17T21:57:28Z

Carsten Milkau: /* D-latch */ input 1 and 2 of select unit were mixed up in intro

== D-latch ==

A d-latch is a circuit that stores the last value seen at its "data" input while its "enable" input was on.

{|
|enabled||data||previous output||output
|-
|0||x||y||y
|-
|1||x||y||x
|}

In theory, a single [[Kit_(Logic_Processor)#Logic_Select_Unit|select unit]] can do this (selector input = enable, input 1 = output, input 2 = data, output = output). In practice, this is not possible as the game does not allow it to have its own output as input. However, several constructions using two or more circuits are possible.

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

=== Using Select Unit and Logic Reader ===

[[File:D-latch.png|thumb|D-latch using select unit and reader]]

This d-latch can store any value. It works in two steps:

<ol>
<li>a select unit determines whether to store the last output or the "data" input using the "enabled" input. i.e.
<pre> if enabled
then stored = data
else stored = output</pre></li>
<li>a [[Kit_(Logic_I/O)#Logic_Reader|logic reader]] mirrors the value to be stored and feeds it back into the select unit so it can circulate (effectively being stored). This would be obsolete if the select unit could read its own output.
<pre> output = stored</pre></li>
</ol>

User:Carsten Milkau/D-Latch

2018-07-17T21:52:45Z

Carsten Milkau: /* Using Select Unit and Logic Reader */ store the value *to be* stored

== D-latch ==

A d-latch is a circuit that stores the last value seen at its "data" input while its "enable" input was on.

{|
|enabled||data||previous output||output
|-
|0||x||y||y
|-
|1||x||y||x
|}

In theory, a single [[Kit_(Logic_Processor)#Logic_Select_Unit|select unit]] can do this (selector input = enable, input 1 = data, input 2 = output, output = output). In practice, this is not possible as the game does not allow it to have its own output as input. However, several constructions using two or more circuits are possible.

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

=== Using Select Unit and Logic Reader ===

[[File:D-latch.png|thumb|D-latch using select unit and reader]]

This d-latch can store any value. It works in two steps:

<ol>
<li>a select unit determines whether to store the last output or the "data" input using the "enabled" input. i.e.
<pre> if enabled
then stored = data
else stored = output</pre></li>
<li>a [[Kit_(Logic_I/O)#Logic_Reader|logic reader]] mirrors the value to be stored and feeds it back into the select unit so it can circulate (effectively being stored). This would be obsolete if the select unit could read its own output.
<pre> output = stored</pre></li>
</ol>

User:Carsten Milkau/D-Latch

2018-07-17T21:49:14Z

Carsten Milkau: /* Using Select Unit and Logic Reader */ if enabled then stored = data else stored = output (not the other way around)

== D-latch ==

A d-latch is a circuit that stores the last value seen at its "data" input while its "enable" input was on.

{|
|enabled||data||previous output||output
|-
|0||x||y||y
|-
|1||x||y||x
|}

In theory, a single [[Kit_(Logic_Processor)#Logic_Select_Unit|select unit]] can do this (selector input = enable, input 1 = data, input 2 = output, output = output). In practice, this is not possible as the game does not allow it to have its own output as input. However, several constructions using two or more circuits are possible.

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

=== Using Select Unit and Logic Reader ===

[[File:D-latch.png|thumb|D-latch using select unit and reader]]

This d-latch can store any value. It works in two steps:

<ol>
<li>a select unit determines whether to store the last output or the "data" input using the "enabled" input. i.e.
<pre> if enabled
then stored = data
else stored = output</pre></li>
<li>a [[Kit_(Logic_I/O)#Logic_Reader|logic reader]] mirrors the stored value and feeds it back into the select unit so it can circulate (effectively being stored). This would be obsolete if the select unit could read its own output.
<pre> output = stored</pre></li>
</ol>

User:Carsten Milkau/D-Latch

2018-07-17T21:45:01Z

Carsten Milkau: /* Using Select and Reader Unit */ add image

== D-latch ==

A d-latch is a circuit that stores the last value seen at its "data" input while its "enable" input was on.

{|
|enabled||data||previous output||output
|-
|0||x||y||y
|-
|1||x||y||x
|}

In theory, a single [[Kit_(Logic_Processor)#Logic_Select_Unit|select unit]] can do this (selector input = enable, input 1 = data, input 2 = output, output = output). In practice, this is not possible as the game does not allow it to have its own output as input. However, several constructions using two or more circuits are possible.

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

=== Using Select Unit and Logic Reader ===

[[File:D-latch.png|thumb|D-latch using select unit and reader]]

This d-latch can store any value. It works in two steps:

<ol>
<li>a select unit determines whether to store the last output or the "data" input using the "enabled" input. i.e.
<pre> if enabled
then stored = output
else stored = data</pre></li>
<li>a [[Kit_(Logic_I/O)#Logic_Reader|logic reader]] mirrors the stored value and feeds it back into the select unit so it can circulate (effectively being stored). This would be obsolete if the select unit could read its own output.
<pre> output = stored</pre></li>
</ol>

File:D-latch.png

2018-07-17T21:39:44Z

Carsten Milkau: User created page with UploadWizard

User:Carsten Milkau/D-Latch

2018-07-17T20:04:53Z

Carsten Milkau: /* Using Select and Reader Unit */

User:Carsten Milkau/D-Latch

2018-07-17T19:49:42Z

Carsten Milkau: Created page with "== D-latch == A d-latch is a circuit that stores the last value seen at its "data" input while its "enable" input was on. {| |enabled||data||previous output||output |- |0||x..."

== D-latch ==

A d-latch is a circuit that stores the last value seen at its "data" input while its "enable" input was on.

{|
|enabled||data||previous output||output
|-
|0||x||y||y
|-
|1||x||y||x
|}

In theory, a single [[Kit_(Logic_Processor)#Logic_Select_Unit|select unit]] can do this (selector input = enable, input 1 = data, input 2 = output, output = output). In practice, this is not possible as the game does not allow it to have its own output as input. However, several constructions using two or more circuits are possible.

=== Connectors ===

* Enabled: if 1, store ''data'', else do nothing.
* Data: input
* Output: stored value

=== Using Select and Reader Unit ===

This d-latch can store any value. It works in two steps:

==== Step 1 : Selection ====
a select unit determines whether to output the "stored value" or the "data" input using the "enabled" input. i.e.

if enabled
then output = stored
else output = data</code>

==== Step 2: Feedback ====
a reader unit feeds the output value back into the select unit so it can circulate (effectively being stored). This would be obsolete if the select unit could read its own output.

stored = output

User:Carsten Milkau/OR Gate

2018-04-13T10:57:40Z

Carsten Milkau: Created page with "= OR Gate = Since the advent of the Min/Max Unit, OR and AND gates are actually extremely simple: just can use MAX for OR and MIN for..."

User:Carsten Milkau/Dual-Atmosphere Airlock

2018-04-13T10:18:11Z

Carsten Milkau:

= Dual-Atmosphere Airlock =

== Constants ==

* Zero
* "Vacuum" pressure

== Target Atmosphere ==

* [[Kit (Logic Switch)|Switch]]
* [[Carsten Milkau/RS-Latch]]

== Current Atmosphere ==

[[Carsten Milkau/D-Latch]]

== Door sensor ==

* [[Carsten Milkau/OR Gate]]
* [[Carsten Milkau/NOT Gate]]

== Door control ==

if (my atmosphere)
then (internal pressure >= external pressure)
else Zero

== Vent activation ==

if (my atmosphere)
then (doors closed)
else Zero

== Vent direction ==

[[Carsten Milkau/NOT Gate]]

User:Carsten Milkau/Dual-Atmosphere Airlock

2018-04-13T07:28:03Z

Carsten Milkau: /* Current Atmosphere */

= Dual-Atmosphere Airlock =

== Target Atmosphere ==

[[Kit (Logic Switch)|Switch]]
[[Carsten Milkau/RS-Latch]]

== Current Atmosphere ==

[[Carsten Milkau/D-Latch]]

User:Carsten Milkau/Dual-Atmosphere Airlock

2018-04-13T07:27:44Z

Carsten Milkau: Created page with "= Dual-Atmosphere Airlock = == Target Atmosphere == Switch Carsten Milkau/RS-Latch == Current Atmosphere == Carsten Milkau/RS-Latch"

= Dual-Atmosphere Airlock =

== Target Atmosphere ==

[[Kit (Logic Switch)|Switch]]
[[Carsten Milkau/RS-Latch]]

== Current Atmosphere ==

[[Carsten Milkau/RS-Latch]]