Advanced Redstone Circuits

From Minecraft Wiki
(Redirected from Advanced redstone circuits)
Jump to navigation Jump to search
Guides This is a Guide.

This article has been assembled by one or more members of the community as a helpful resource, instructing players on some aspect of Minecraft. If desired, you may clarify or expand this article yourself.

File:258inv.png This article or section requires a cleanup in order to meet the Minecraft Wiki's quality standards.
Please edit this page to improve it.
Add the missing files.
For other redstone related objects found in Minecraft, see Redstone (Disambiguation).

Advanced Redstone Circuits encompass mechanisms that require complicated Redstone circuitry.

Miscellaneous[edit | edit source]

Order Insensitive Combination Locks[edit | edit source]

A door that opens when a certain combination of buttons/levers are on. (Note: A moderate understanding of logic gates is needed for this device.)
Combination Lock Tutorial (easy to follow)

RSNOR Combo Lock[edit | edit source]

Connect a series of buttons to the S-input of RS Latches. Feed the Q or Q (choose which one for each latch to set the combination) outputs of the RS Latches into a series of AND gates, and connect the final output to an iron door. Finally, connect a single button to all the R-inputs of the RS Latches. The combination is configured by using either Q or Q for each button (Q means that the button would need to be pressed, Q don't press) Example:


With the automated reset, it causes the correct combo to cause a pulse instead of an "always-on" until reset.

AND Combo Lock[edit | edit source]

The AND based combo lock uses switches and NOT gate inverters instead of the RSNOR latches in the previous design. This makes for a simpler design but becomes less dynamic in complicated systems, and it also lacks an automated reset. The AND design is configured by adding inverters to the switches. Example: File:Combolockredstone.gif

OR Combo Lock[edit | edit source]

The OR combo lock is actually an AND combo lock without unnecessary repeaters, override lever and last inverter. The output is off when the code is correct.

Due to its compact size and fast response time, this combination lock is also ideal for use as an address decoder in the construction of addressable memory (RAM)

Design A. Code is set by torches on inputs (1001):

One can expand on this by creating a new level on top of the first and using the same principle as the first level, keep creating them.

Design B. Code is set by inverters in the blue area (001001):

File:Compact or-lock.JPG

N - number of inputs. K - number of 1's in code.

Design A B
Size 2N-1x3x1 Nx6x2
Torches K 2N-K
Redstone 3N-K-1 2.5N + 2K

Order-sensitive RSNOR Combo Lock[edit | edit source]

A door that opens when buttons are pressed in certain order.

(Note: A moderate understanding of logic gates is needed for this device.)

Make a series of buttons, and connect only one to an RSNOR latch. Then connect both the RSNOR latch and a second button to an AND Gate, which feeds to another RSNOR latch. Do this continually until one has either filled all of the buttons or are satisfied with the lock. Connect the final RSNOR latch to a separate AND Gate with a signal from an enter button. Feed that to the output RSNOR latch. Then connect any of the left-over buttons to the enter button and send reset signals to all of the RSNOR latches. A pressure plate next to a door can reset the door. This type of lock has severe limitations to its security. For example, not all the buttons could be used in the pin or there would be nothing to reset the system.

For a lock that can have a combination of any size, using all the buttons, and still have a wrong entry reset the system, one needs a different way for it to reset. To construct this, hook up a panel of buttons (any number, but four or more is preferred) to a parallel series of adjacent repeaters. Invert as necessary so that all the repeaters are powered and are unpowered by the press of the corresponding button. These repeaters power a row of blocks. On top of the blocks, place a torch corresponding to the incorrect buttons for the first number in the PIN. For the correct button/number, place dust under the powered block which leads to an RS NOR Latch. Place a row of blocks above the torches for the incorrect buttons, with Redstone dust on top. Then connect this dust to the reset of the first RS NOR Latch. Only the correct button will set the RS NOR Latch and all others will reset it. Connect the output of the RS NOR LATCH to half of an AND gate. After the first row of blocks with the reset torches, place another row of repeaters and another row of blocks. Again, place torches for the incorrect buttons and dust under the correct button's line. Power will be fed from the buttons through the rows of repeaters and blocks for as many rows as there are digits in the PIN number. Connect the dust from the correct button to the other half of the AND gate coming from the first RS NOR Latch. Only if the two conditions are met, that the first button was pushed correctly, setting the first RS NOR Latch, and the second button is pushed correctly will the AND gate send a signal to set the second RS NOR Latch. Again, connect a reset line from the incorrect button's torches to the reset of the second RS NOR Latch. NOTE: Delay the reset signals by one full repeater to give time for the next RS NOR Latch to be set before the reset happens. Continue building the array in the same manner until one reaches the desired number of digits. In operation, when a button is hit, each RS NOR Latch checks (through the AND gate) to see if the previous RS NOR Latch is set, and the correct button for this RS NOR Latch has been pushed. Only when the correct buttons are pressed in order, will the signal progress through the conditional RS NOR Latches to the end. Connect the output of the last RS NOR Latch to a door and attach a line to a pressure plate inside the door to reset the last RS NOR Latch. See the video demonstration linked below.

Binary to Octal[edit | edit source]

File:3bit Implies.gif
3Bit Binary to Octal gates.

A series of gates that convert a 3bit binary input from inputs into an octal output from 0-7. Useful in many ways as they are compact 5x5x3 at the largest.

These can be linked in a series from one input source, but it's recommended to place an inverter before each input into the circuit to keep them isolated from interacting with the other circuits since some drive a combination of High and Low current.

Need clarification, but some of these may also work as Tri State buffers or as close as possible with redstone, depending on one's setup.

Number 0 1 2 3 4 5 6 7
Size 5x3x2 5x3x3 5x5x3 5x5x3 5X3X3 5x4x3 5x5x3 5x5x3
Torches 1 2 2 3 2 3 3 4
Redstone 7 7 12 10 7 7 10 10

Binary to Decimal/HexaDecimal[edit | edit source]

File:4bit Implies.png
4Bit Binary to Decimal/HexaDecimal gates.

A series of gates that convert a 4bit binary input from inputs into a decimal or HexaDecimal output from 0-9 (if one is using Decimal) or 0-F(if one is using HexaDecimal). Useful in many ways as they are compact 3x5x2 at the largest.

These can be linked in a series from one input source, but it is recommended to place an inverter before each input into the circuit to keep them isolated from interacting with the other circuits since some drive a combination of High and Low current.

Following the image, the first input is the second Lever on the right. The second input is the first Lever on the right. The third is the first lever on the left. The fourth, and last, the input is the second Lever on the left.

Number 0 1 2 3 4 5 6 7 8 9 A B C D E F
Size 3x3x2 3x4x2 3x4x2 3x4x2 3x4x2 3x5x2 3x5x2 3x5x2 3x4x2 3x5x2 3x5x2 3x5x2 3x5x2 3x5x2 3x5x2 3x5x2
Torches 1 2 2 3 2 3 3 4 2 3 3 4 3 4 4 5
Redstone 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

HexaDecimal to Binary[edit | edit source]

One also can convert a Hexadecimal signal to a 4bit-binary signal. Here one doesn't need any gates, except separating ORs. Therefore, one has to put the input through a block. From this, put lines trough the bit lines. And separate these from input via (Not-Not)-gate or a diode. The most suitable point to separate is directly after the point one differentiates the input trough the output lines. One has to separate these lines, in order that the bit-illustration will be correct.

Number 0 1 2 3 4 5 6 7 8 9 A B C D E F
4-bit 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
3-bit 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
2-bit 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
1-bit 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

Now one has the 4-bit converted signal in the four lines. To get an Octal2Binary-MUXer, just ignore the entries, where the 4-bit-line is 1.

Example[edit | edit source]

File:Door Lock Key.png
Logic for a 3-digit key log, with digits 0-9. It's order-sensitive

The example on the right uses ORs (>=1), XNORs (=), RS-NOR latches (SR) and some delays (dt*). For the XNORs, I would prefer C-design.

The example on the right uses a 4-bit design, so one can handle a hexa-decimal key. So one can use 15 various digits, [1,F] or [0,E]. One only can use 15, because the state (0)h == (0000)2 won't activate the system. If one wants to handle 16 states, one edits the logic, to interact for a 5-bit input, where the 5th bit represents the (0)h state.

In the following we'll use (0)h := (1111)2. And for [1,9] the MUX-table upon. So the key uses decimal digits. Therefore, we have to mux the used buttons to binary data. Here look trough the first two columns. The first represents the input-digit in (Hexa)decimal, the second represents the input-digit in binary code. Here one can add also buttons for [A, E], but I disclaimed them preferring better arranging. The /b1\-box outputs the first bit, the /b2\-box the second, and so on.

Now one sees Key[i] with i=1..3, here one sets the key one wants to use. The first output of them is the 1-bit, the second the 2-bit and so on. One can set one's key here with levers in binary-encryption. Use here the MUX-table upon, and for (0)h := (1111)2. If we enter the first digit, we have to compare the bits by pairs (b1=b1, b2=b2, b3=b3, b4=b4). If every comparison is correct, we set the state, that the first digit is correct.

Therefore, we combine (((b1=b1 & b2=b2) & b3=b3) & b4=b4) =: (b*=b*). In Minecraft we have to use four ANDs like the left handside. Now we save the status to the RS-latch /A\. The comparison works the same way for Key[2], and Key[3].

Now we have to make sure, that the state will be erased if the following digit is wrong. Therefore, we handle a key-press-event (--/b1 OR b2 OR b3 OR b4\--/dt-\--/dt-\--). Search the diagram for the three blocks near "dt-". Here we look, if any key is pressed, and we forward the event with a minor delay. For resetting /A\, if the second digit is wrong, we combine (key pressed) & (not B). It means: any key is pressed and the second digit of the key is entered false. Therewith /A\ will be not reset, if we enter the first digit, /A\ only should be reset, if /A\ is already active. So we combine (B* & A) =: (AB*). /AB*\ now resets the memory-cell /A\, if the second digit is entered false and the first key has been already entered. The major delay /dt+\ must be used, because /A\ resets itself if we press the digit-button too long. To prevent this failure for a little bit, we use the delay /dt+\. The OR after /AB*\ is used, for manually resetting, i.e. by a pressure plate.

Now, we copy the whole reset-circuit for Key[2]. The only changes are that the manually reset comes from (not A), and the auto-reset (wrong digit after) comes from (C). The manual reset from A prevents B to be activated if the first digit is not entered. So this line makes sure that our key is order-sensitive.

The question is, why we use the minor-delay-blocks /dt-\? Visualize /A\ is on. Now we enter a correct second digit. So B will be on, and (not B) is off. But while (not B) is still on, the key-pressed-event is working yet, so A will be reseted, but it shouldn't. With the /dt-\-blocks, we give /B\ the chance to act, before key-pressed-event is activated.

For /C\, the reset-event is only the manual-reset-line, from B. So it is prevented to be activated, before /B\ is true, and it will be deactivated when a pressure-plate resets /A\ and /B\.

pros and cons:

+ one can change the key in every digit, without changing the circuit itself.
+ one can extend the key by any amount of digits, by copying the comparison-circuit. Dependencies from previous output only.
+ one can decrease the amount of digits by one by setting any digit (except the last) to (0000)b.
+ one can open the door permanently by setting the last digit to (0000)b
- the bar to set the key will be get the bigger, the longer the key one wants to be. The hard-coded key-setting is a compromise for a pretty smaller circuit, when using not too long keys. If one wants to use very long keys, one also should softcode the key-setting. But mention, in fact the key-setting-input will be very small, but the circuit will be much more bigger, than using hard-coded key-setting.

Not really a con: in this circuit the following happens with maybe the code 311: 3 pressed, A activated; 1 pressed, B activated, C activated. To prevent this, only set a delay with a repeater between (not A) and (reset B). So the following won't be activated with the actual digit.

If one fixes this, the circuit have the following skill, depending on key-length. ( ||digit|| = 2n-1, possibilities: ||digit||Length )

Length 1 2 3 4 5
2 bit 3 9 27 81 243
3 bit 7 49 343 2.401 16.807
4 bit 15 225 3.375 50.625 759.375
5 bit 31 961 29.791 923.521 28.629.151

Sorting Device[edit | edit source]

File:Sorting Device.png This is a device which sorts the inputs, putting 1's at the bottom and 0's at the top. In effect counting how many 1s and how many 0s there are. The diagram is designed so that it is easily expandable, as shown in the diagram. The bright squares shows how to expand it, and also where the in- and outputs are.

Truth table for a three-bit sorting device:

A B C 1 2 3
0 0 0 0 0 0
1 0 0 1 0 0
0 1 0 1 0 0
0 0 1 1 0 0
1 1 0 1 1 0
0 1 1 1 1 0
1 0 1 1 1 0
1 1 1 1 1 1

Computation[edit | edit source]

We can arrange logic gates to make binary calculations, like in a computer. When using the gates below, mind the inputs and outputs. One may be wondering why there are so many inverted signals being used instead of the regular signal. The adders below use XNOR gates rather than XOR gates because they are more compact. As a result, IMPLIES gates must be used instead of an AND gate, which also happen to be more compact. Therefore, for the most compact adder, inverse signals must be used. These adders are too complex to be easily deciphered with 2 layers per square, so each single layer has been drawn separately to ease the building process.

Half Adder[edit | edit source]

Half Adder


Torches: 12

Redstone: 7

Blocks: 19

Size: 5X4X4

This adder will take 2 bits and add them together. The resulting bit will be the output of S (sum). If both bits are 1, there will be a carry over, and C will become 1 (C will become 0). This half adder can be modified to create a non inverted C output, but this configuration is used so that it can be implemented as the start of a chain of full adders.

(Note: This design no longer works)

Full Adder (1 Bit Adder)[edit | edit source]

Full Adder (1 Bit Adder)

Gates: XNOR (2), AND (2)

Torches: 25

Redstone: 121

Blocks: 41

Size: 21X17X4 Ceiling to floor, including I/O spaces.

This adder will take 2 bits and a carried over bit (actually C, rather than C, a value held in the redstone in the bottom left corner on layer 1) and add them all together, producing a sum (S) bit and a carry (actually C rather than C).

In order to make a subtractor, simply invert one of the binary inputs (the 1st or 2nd number). If the number is negative, the answer comes out inverted. In real computers, the first bit (also called the sign) decides weather the number is positive or negative, if one includes this (applying the same inverting rule) one can detect whether the number is negative, or if it's just a big number.

Piston Full-Adder[edit | edit source]

1 Piston Full-Adder

2 Piston Full-Adder

Torches: 3

Sticky Pistons: 2

Repeater: 8

Redstone: 16

Blocks: 7

Alternate Full Adder[edit | edit source]

Full Adder

Carry input and output are aligned to easily connect many of these modules in series.

Torches: 14

Redstone wire: 15

Size: 5x6x3

4 Bit Adder[edit | edit source]

4 bit Adder

Note! The least significant digit ("ones" digit) is on the left of the diagram so that the progression from half adder to the full adders can be seen more clearly. Reverse the diagram if one wants a conventional left to right input.

Gates: XNOR (7), IMPLIES (4), NOT (4), OR (3), AND (3)

Torches: 56

Redstone: 108

Blocks: 164

Size: 23X12X5

This adder will take 2, 4 bit numbers (A and B) and add them together, producing a sum (S) bit for each bit added and a carry (C) for the whole sum. The sum bits are in the same order as the input bits, which on the diagram means that the leftmost S output is the least significant digit of the answer. This is just an example of a string of adders; adders can be strung in this way to add bigger numbers as well.

ALU/CPU creation[edit | edit source]

An ALU (arithmetic logic unit) is a unit that can perform multiple mathematical calculations (add, subtract, and, or, xor, etc.) and allows one to chose the function performed.

A CPU (central processing unit) has an ALU, along with RAM or memory, to store answers and numbers for the ALU to compute. an example of a CPU can be found here.

A computer consists of a CPU, program memory, a clock, and program handler, that can take and execute commands from program memory.

A GPU (graphic processing unit) is capable of computing images, and displaying them on a monitor. in also has RAM to save the image being drawn. the 1st was made by dudearent006[1] and can be found here

theinternetftw made the first ALU, CPU and computer[2](as far as we know)

Logic units[edit | edit source]

In circuits, it might be useful to have a logic unit that will, based on the input, decide which output is to be chosen. Such a unit can be then used for more complex circuits, such as an ALU.

This is an example of a 2-bit logic unit that will have 4 states depending on the input.

File:Logic unit.gif

The outputs are in top row, with 11, 00, 01, 10 order (input order: first first, bottom second).

This is another example of a simplified version using Gray codes. The output appears at the torches at the end of the top rows. This design can be extended to any number of bits, but practical limitations due to timing considerations restrict the use of more than a byte or so. The outputs are triggered by the inputs 11, 01, 00, 10, respectively.

File:Logic unit 3.gif

Related pages[edit | edit source]

References[edit | edit source]