Stationeers Community Wiki - User contributions [en]

User:Carsten Milkau/Dual-Atmosphere Airlock

2018-07-22T14:18:46Z

89.16.148.86: /* Vent direction */ Vent direction: equality comparison is a more straightforward explanation than a NOT gate

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

<pre>if (internal_pressure > vacuum_pressure)
then current_atmosphere = current_atmosphere
else current_atmosphere = target_atmosphere</pre>

=== Door sensor ===

* <del>[[User:Carsten Milkau/OR Gate]]</del>
* [[Kit (Logic I/O)#Batch Reader|Batch Reader]]
* [[User:Carsten Milkau/NOT Gate]]

<pre>num_open_doors = read_sum(airlock_door open)
doors_closed = (num_open_doors = 0)</pre>

=== Door control ===

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

=== Vent activation ===

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

* atmosphere 0: max(atmosphere1, any door open) = Zero
* atmosphere 1: atmosphere1 > any door open

=== Vent direction ===

[[Kit (Logic Processor)#Compare Unit|Compare Unit]]

<pre>if (my target atmosphere)
then pressurize
else depressurize</pre>

User:Carsten Milkau/Dual-Atmosphere Airlock

2018-07-22T12:29:01Z

89.16.148.86: /* Vent direction */ pseudocode

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

<pre>if (internal_pressure > vacuum_pressure)
then current_atmosphere = current_atmosphere
else current_atmosphere = target_atmosphere</pre>

=== Door sensor ===

* <del>[[User:Carsten Milkau/OR Gate]]</del>
* [[Kit (Logic I/O)#Batch Reader|Batch Reader]]
* [[User:Carsten Milkau/NOT Gate]]

<pre>num_open_doors = read_sum(airlock_door open)
doors_closed = (num_open_doors = 0)</pre>

=== Door control ===

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

=== Vent activation ===

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

* atmosphere 0: max(atmosphere1, any door open) = Zero
* atmosphere 1: atmosphere1 > any door open

=== Vent direction ===

[[User:Carsten Milkau/NOT Gate]]

<pre>if (my target atmosphere)
then pressurize
else depressurize</pre>

User:Carsten Milkau/Dual-Atmosphere Airlock

2018-07-22T12:26:50Z

89.16.148.86: /* Door sensor */ pseudocode

User:Carsten Milkau/Dual-Atmosphere Airlock

2018-07-22T12:18:11Z

89.16.148.86: /* Current Atmosphere */ pseudocode

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

<pre>if (internal_pressure > vacuum_pressure)
then current_atmosphere = current_atmosphere
else current_atmosphere = target_atmosphere</pre>

=== Door sensor ===

* <del>[[User:Carsten Milkau/OR Gate]]</del>
* [[Kit (Logic I/O)#Batch Reader|Batch Reader]]
* [[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

* atmosphere 0: max(atmosphere1, any door open) = Zero
* atmosphere 1: atmosphere1 > any door open

=== Vent direction ===

[[User:Carsten Milkau/NOT Gate]]

User:Carsten Milkau/NOT Gate

2018-07-22T12:13:11Z

89.16.148.86: /* Definition */ names x and y for inputs/outputs in truth table

= 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
|-
!'''inputs''' || '''outputs'''
|-
!x || y
|-
|0||1
|-
|1||0
|}

=== Connectors ===

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

== Implementation ==

NOT gates can often be avoided by modifying the circuit. For instance, an [[User:Carsten Milkau/OR Gate|OR Gate]] with two NOT gates connected to its inputs and outputs can always be replaced by an AND gate with just one NOT gate connected.

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

[[File:CompareUnit.png|thumb]]

If you have a circuit available (e.g. a constant memory) that has a value ''b'' known to stay between 0 and 1 (but not 0), you can turn a [[Kit (Logic Processor)#Compare Unit|Compare Unit]] into a logic NOT gate by comparing the input ''x'' to ''b'', i.e.

<pre>y = (x < b)</pre>

{| class="wikitable"
|+ circuit setup
|-
! unit || unit type || connector/setting || source / value
|-
|compare 1 || Compare Unit || Input 1 || x '''(input)'''
|-
| || || Input 2 || ''b'' (constant or bounded value)
|-
| || || Operation Selector || Lesser
|-
| || || Output || y '''(output)'''
|}

=== Using An Equality Comparator ===

[[File:CompareUnit.png|thumb]]

If you have a circuit output available that is known to be zero when the NOT gate is used (e.g. a constant memory), you can turn a [[Kit (Logic Processor)#Compare Unit|Compare Unit]] into a logic NOT gate by comparing the input ''x'' to ''0'', i.e.

<pre>y = (x = 0)</pre>

{| class="wikitable"
|+ circuit setup
|-
! unit || unit type || connector/setting || source / value
|-
|compare 1 || Compare Unit || Input 1 || x '''(input)'''
|-
| || || Input 2 || 0 (constant)
|-
| || || Operation Selector || Equals
|-
| || || Output || y '''(output)'''
|}

=== Using Subtraction ===

[[File:MathUnit.png|thumb]]

If you do not use 0 and 1 as the two possible input values of the inverter, you can use subtraction for implementation. In this case, you need a constant that is exactly the mean of the two input values, i.e.

<pre>y = (m - x)</pre>

where m = (a + b)/2 is the mean of the two allowed input values, (called ''a'' and ''b'' here).

{| class="wikitable"
|+ Circuit setup
|-
! unit || unit type || connector/setting || source/value
|-
| math 1 || [[Kit (Logic Processor)#Math Unit|Math Unit]] || Input 1 || x '''(input)'''
|-
| || || Input 2 || m (constant, see above)
|-
| || || Operation || Subtract
|-
| || || Output || y '''(output)'''
|}

User:Carsten Milkau/NOT Gate

2018-07-22T12:11:58Z

89.16.148.86: /* Connectors */ y again

= 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 x: one of two values (0 or 1)
* Output y: the other of the two values

== Implementation ==

NOT gates can often be avoided by modifying the circuit. For instance, an [[User:Carsten Milkau/OR Gate|OR Gate]] with two NOT gates connected to its inputs and outputs can always be replaced by an AND gate with just one NOT gate connected.

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

[[File:CompareUnit.png|thumb]]

If you have a circuit available (e.g. a constant memory) that has a value ''b'' known to stay between 0 and 1 (but not 0), you can turn a [[Kit (Logic Processor)#Compare Unit|Compare Unit]] into a logic NOT gate by comparing the input ''x'' to ''b'', i.e.

<pre>y = (x < b)</pre>

{| class="wikitable"
|+ circuit setup
|-
! unit || unit type || connector/setting || source / value
|-
|compare 1 || Compare Unit || Input 1 || x '''(input)'''
|-
| || || Input 2 || ''b'' (constant or bounded value)
|-
| || || Operation Selector || Lesser
|-
| || || Output || y '''(output)'''
|}

=== Using An Equality Comparator ===

[[File:CompareUnit.png|thumb]]

If you have a circuit output available that is known to be zero when the NOT gate is used (e.g. a constant memory), you can turn a [[Kit (Logic Processor)#Compare Unit|Compare Unit]] into a logic NOT gate by comparing the input ''x'' to ''0'', i.e.

<pre>y = (x = 0)</pre>

{| class="wikitable"
|+ circuit setup
|-
! unit || unit type || connector/setting || source / value
|-
|compare 1 || Compare Unit || Input 1 || x '''(input)'''
|-
| || || Input 2 || 0 (constant)
|-
| || || Operation Selector || Equals
|-
| || || Output || y '''(output)'''
|}

=== Using Subtraction ===

[[File:MathUnit.png|thumb]]

If you do not use 0 and 1 as the two possible input values of the inverter, you can use subtraction for implementation. In this case, you need a constant that is exactly the mean of the two input values, i.e.

<pre>y = (m - x)</pre>

where m = (a + b)/2 is the mean of the two allowed input values, (called ''a'' and ''b'' here).

{| class="wikitable"
|+ Circuit setup
|-
! unit || unit type || connector/setting || source/value
|-
| math 1 || [[Kit (Logic Processor)#Math Unit|Math Unit]] || Input 1 || x '''(input)'''
|-
| || || Input 2 || m (constant, see above)
|-
| || || Operation || Subtract
|-
| || || Output || y '''(output)'''
|}

User:Carsten Milkau/NOT Gate

2018-07-22T12:10:58Z

89.16.148.86:

= 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, an [[User:Carsten Milkau/OR Gate|OR Gate]] with two NOT gates connected to its inputs and outputs can always be replaced by an AND gate with just one NOT gate connected.

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

[[File:CompareUnit.png|thumb]]

If you have a circuit available (e.g. a constant memory) that has a value ''b'' known to stay between 0 and 1 (but not 0), you can turn a [[Kit (Logic Processor)#Compare Unit|Compare Unit]] into a logic NOT gate by comparing the input ''x'' to ''b'', i.e.

<pre>y = (x < b)</pre>

{| class="wikitable"
|+ circuit setup
|-
! unit || unit type || connector/setting || source / value
|-
|compare 1 || Compare Unit || Input 1 || x '''(input)'''
|-
| || || Input 2 || ''b'' (constant or bounded value)
|-
| || || Operation Selector || Lesser
|-
| || || Output || y '''(output)'''
|}

=== Using An Equality Comparator ===

[[File:CompareUnit.png|thumb]]

If you have a circuit output available that is known to be zero when the NOT gate is used (e.g. a constant memory), you can turn a [[Kit (Logic Processor)#Compare Unit|Compare Unit]] into a logic NOT gate by comparing the input ''x'' to ''0'', i.e.

<pre>y = (x = 0)</pre>

{| class="wikitable"
|+ circuit setup
|-
! unit || unit type || connector/setting || source / value
|-
|compare 1 || Compare Unit || Input 1 || x '''(input)'''
|-
| || || Input 2 || 0 (constant)
|-
| || || Operation Selector || Equals
|-
| || || Output || y '''(output)'''
|}

=== Using Subtraction ===

[[File:MathUnit.png|thumb]]

If you do not use 0 and 1 as the two possible input values of the inverter, you can use subtraction for implementation. In this case, you need a constant that is exactly the mean of the two input values, i.e.

<pre>y = (m - x)</pre>

where m = (a + b)/2 is the mean of the two allowed input values, (called ''a'' and ''b'' here).

{| class="wikitable"
|+ Circuit setup
|-
! unit || unit type || connector/setting || source/value
|-
| math 1 || [[Kit (Logic Processor)#Math Unit|Math Unit]] || Input 1 || x '''(input)'''
|-
| || || Input 2 || m (constant, see above)
|-
| || || Operation || Subtract
|-
| || || Output || y '''(output)'''
|}

User:Carsten Milkau/NOT Gate

2018-07-22T12:10:09Z

89.16.148.86: /* Using Subtraction */

= 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, an [[User:Carsten Milkau/OR Gate|OR Gate]] with two NOT gates connected to its inputs and outputs can always be replaced by an AND gate with just one NOT gate connected.

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

[[File:CompareUnit.png|thumb]]

If you have a circuit available (e.g. a constant memory) that has a value ''b'' known to stay between 0 and 1 (but not 0), you can turn a [[Kit (Logic Processor)#Compare Unit|Compare Unit]] into a logic NOT gate by comparing the input ''x'' to ''b'', i.e.

<pre>not_x = (x < b)</pre>

{| class="wikitable"
|+ circuit setup
|-
! unit || unit type || connector/setting || source / value
|-
|compare 1 || Compare Unit || Input 1 || x '''(input)'''
|-
| || || Input 2 || ''b'' (constant or bounded value)
|-
| || || Operation Selector || Lesser
|-
| || || Output || y '''(output)'''
|}

=== Using An Equality Comparator ===

[[File:CompareUnit.png|thumb]]

If you have a circuit output available that is known to be zero when the NOT gate is used (e.g. a constant memory), you can turn a [[Kit (Logic Processor)#Compare Unit|Compare Unit]] into a logic NOT gate by comparing the input ''x'' to ''0'', i.e.

<pre>not_x = (x = 0)</pre>

{| class="wikitable"
|+ circuit setup
|-
! unit || unit type || connector/setting || source / value
|-
|compare 1 || Compare Unit || Input 1 || x '''(input)'''
|-
| || || Input 2 || 0 (constant)
|-
| || || Operation Selector || Equals
|-
| || || Output || y '''(output)'''
|}

=== Using Subtraction ===

[[File:MathUnit.png|thumb]]

If you do not use 0 and 1 as the two possible input values of the inverter, you can use subtraction for implementation. In this case, you need a constant that is exactly the mean of the two input values, i.e.

<pre>y = (m - x)</pre>

where m = (a + b)/2 is the mean of the two allowed input values, (called ''a'' and ''b'' here).

{| class="wikitable"
|+ Circuit setup
|-
! unit || unit type || connector/setting || source/value
|-
| math 1 || [[Kit (Logic Processor)#Math Unit|Math Unit]] || Input 1 || x '''(input)'''
|-
| || || Input 2 || m (constant, see above)
|-
| || || Operation || Subtract
|-
| || || Output || y '''(output)'''
|}

User:Carsten Milkau/NOT Gate

2018-07-22T11:53:33Z

89.16.148.86:

= 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, an [[User:Carsten Milkau/OR Gate|OR Gate]] with two NOT gates connected to its inputs and outputs can always be replaced by an AND gate with just one NOT gate connected.

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

[[File:CompareUnit.png|thumb]]

If you have a circuit available (e.g. a constant memory) that has a value ''b'' known to stay between 0 and 1 (but not 0), you can turn a [[Kit (Logic Processor)#Compare Unit|Compare Unit]] into a logic NOT gate by comparing the input ''x'' to ''b'', i.e.

<pre>not_x = (x < b)</pre>

{| class="wikitable"
|+ circuit setup
|-
! unit || unit type || connector/setting || source / value
|-
|compare 1 || Compare Unit || Input 1 || x '''(input)'''
|-
| || || Input 2 || ''b'' (constant or bounded value)
|-
| || || Operation Selector || Lesser
|-
| || || Output || y '''(output)'''
|}

=== Using An Equality Comparator ===

[[File:CompareUnit.png|thumb]]

If you have a circuit output available that is known to be zero when the NOT gate is used (e.g. a constant memory), you can turn a [[Kit (Logic Processor)#Compare Unit|Compare Unit]] into a logic NOT gate by comparing the input ''x'' to ''0'', i.e.

<pre>not_x = (x = 0)</pre>

{| class="wikitable"
|+ circuit setup
|-
! unit || unit type || connector/setting || source / value
|-
|compare 1 || Compare Unit || Input 1 || x '''(input)'''
|-
| || || Input 2 || 0 (constant)
|-
| || || Operation Selector || Equals
|-
| || || Output || y '''(output)'''
|}

=== Using Subtraction ===

User:Carsten Milkau/NOT Gate

2018-07-22T11:51:25Z

89.16.148.86:

= 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, an [[User:Carsten Milkau/OR Gate|OR Gate]] with two NOT gates connected to its inputs and outputs can always be replaced by an AND gate with just one NOT gate connected.

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

[[File:CompareUnit.png|thumb]]

If you have a circuit available (e.g. a constant memory) that has a value ''b'' known to stay between 0 and 1 (but not 0), you can turn a [[Kit (Logic Processor)#Compare Unit|Compare Unit]] into a logic NOT gate by comparing the input ''x'' to ''b'', i.e.

<pre>not_x = (x < b)</pre>

{| class="wikitable"
|+ circuit setup
|-
! unit || unit type || connector/setting || source / value
|-
|compare 1 || Compare Unit || Input 1 || x '''(input)'''
|-
| || || Input 2 || ''b'' (constant or bound value)
|-
| || || Operation Selector || Lesser
|-
| || || Output || y '''(output)'''
|}

=== Using An Equality Comparator ===

[[File:CompareUnit.png|thumb]]

If you have a circuit output available that is known to be zero when the NOT gate is used (e.g. a constant memory), you can turn a [[Kit (Logic Processor)#Compare Unit|Compare Unit]] into a logic NOT gate by comparing the input ''x'' to ''0'', i.e.

<pre>not_x = (x = 0)</pre>

{| class="wikitable"
|+ circuit setup
|-
! unit || unit type || connector/setting || source / value
|-
|compare 1 || Compare Unit || Input 1 || x '''(input)'''
|-
| || || Input 2 || 0 (constant)
|-
| || || Operation Selector || Equals
|-
| || || Output || y '''(output)'''
|}

=== Using Subtraction ===

User:Carsten Milkau/NOT Gate

2018-07-22T11:48:01Z

89.16.148.86:

User:Carsten Milkau/NOT Gate

2018-07-22T10:35:00Z

89.16.148.86: /* Implementation */ Improved example of NOT gate elimination