[Guide] Advanced Wiring Guide

This is an advanced wiring guide. It was originally a guide on latches and flipflops. If you're new to wiring, you should read the basic guide first!

Contents

• Latches and Flip-flops
  • The D-Latch
  • Example: Locking Trap
  • Persistent Switch ("Edge-triggered SR-Latch")
  • D-flip-flop
  • Pushbutton Toggle Circuit
• Small Wall Switch (SWS)
  • Example: Trading Room
  • Example 2: Binary Ripple Counter
• Clocks
• Pulse Shorteners/Extenders
  • Pulse Shorteners
  • Example: Automatic Door
  • Pulse Extenders
• 1-tick Latching
  • Example: Shift Register
  • Example 2: Binary Synchronous Counter
  • Example 3: BCD Counter
• BCD to 7-segment Decoder
• Combination Locks
• Airlocks
• Fin

Latches and Flip-flops

Latches are a very simple unit of memory. A single latch can remember a single binary digit or bit (1 or 0).

The Latch in Starbound is a D-Latch. It has two inputs and one output.



Data (or D for short) : This is what you want the output to become.

Enable (or EN for short): Determines whether D is connected to the output or not. When Enable is on (1), the output is the same as the D input (ie. it will act as a repeater). When Enable is turned off (0), the output will freeze at the last value it had. D will not have any effect while Enable is off.

If you like, you can imagine Enable as controlling a switch between D and the output. This isn't technically correct, but not a terribly bad analogy.



Example: Locking Trap

The simplest and most common use for latches is to "lock" things. I'll use a trap as an example.

If I step on the pressure plate, this turns on both Enable and D, activating the trap. If I step off, the trap will stay on - this is because Enable and D turn off at the same time, so the output freezes in the on state.

A reset button is needed to deactivate the trap. This is connected to Enable, which will update the output to be off.



Persistent Switch ("Edge-triggered SR-Latch")

As of Upbeat Giraffe, there's now a new and easy way to lock things - the Persistent Switch (PS). It has separate set and reset inputs. When the Set input goes from 0 to 1, the switch turns on. When the Reset switch goes from 0 to 1, the switch turns off. The rest of the time, it stays the same.

Side note: If you know what an SR-Latch is, A PS is similar, but not the same. The Persistent Switch is edge-sensitive (it changes when an input changes from 0 to 1) , while an SR latch is level-sensitive (it changes when one input is 1 and the other is 0).
eg. (set,reset) goes from (0,1) to (1,1). PS gets set, SR-Latch stays the same (or has undefined output - depends on implementation).
eg2. (set,reset) goes from (1,1) to (0,1). PS stays the same, SR-Latch is reset

You'll find the PS to be a surprisingly useful little block, it's good for turning things on (or off) only once. The missions use these a lot in their traps and doors to keep things activated once they've been triggered. We'll use the PS a bit later in our Airlock example.






D-Flip-flop

Latches are level-sensitive, meaning the output can change whenever the Enable is on. Flip-flops are edge-sensitive, meaning the output changes when a Clock input changes value (on the rising or falling edge of a clock input, depending on the type).

In other words, when a latch is enabled, it continuously samples the D input. It's like it's "recording a video" of the D input while enabled. On the other hand, when a flip-flop is given a clock pulse, it takes one "snapshot" of the current value of D. So latches are "like camcorders", and flip-flops are "like cameras" when it comes to how their output updates.

Flip-flops are useful for making things like state machines, counters and registers. The flip-flop pictured below is a negative-edge triggered D-flip-flop. "Negative-edge triggered" means that the output will update when the clock drops from on to off (this is also called "falling-edge triggered"). It's simple, only needing two latches and a NOT gate. Note how the Clock connects to two points. If you want a positive-edge-triggered flip-flop, chain a NOT gate onto the clock.





Pushbutton Toggle (Negative-edge triggered Toggle Circuit)

Sometimes you want to toggle something using a button. But a button releases a pulse - how can we use a button to create a system that toggles when given a pulse?

One solution is to build a flip-flop, then feed the output into the D input via an inverter. Hence, the next output will always be the opposite of the current output!

The button is the clock. Hitting the button introduces a clock pulse, which updates the state (toggles the output).

As flip-flops are edge-sensitive and hence only update once per pulse, we need to use a flip-flop and not just a latch. If we used a latch, the output would toggle several times while the clock pulse was on.

This one toggles on the negative edge (1 to 0), since we are using a negative-edge triggered flipflop. This is useful in counters (you'll see why later), but it also means it takes a little time to respond after pressing a button. If you want instantaneous response, put an inverter on the button.



The Small Wall Switch (SWS)

The Small Wall Switch (SWS) is a very useful component that made a lot of latch stuff obsolete. It can be used as a regular switch, but it can also act as a positive-edge triggered toggle. When its input goes from 0 to 1, the switch will toggle. It's much more compact than a toggle made out of a flip-flop.

Here's a pushbutton toggle, except using an SWS instead of a flip-flop. If you want a negative-edge triggered toggle, just put an inverter between the button and the SWS.



You can also make a positive-edge-triggered D-flip-flop from an SWS. For an even more compact flip-flop, see the "1-tick Latching and Shift Registers" section.



Example: Trading Room

Starbound doesn't currently have a trading mechanic, so it might be nice to have a way of trading with fellow players that doesn't rely on an honor system. It'll serve as an example of something you can build that can use an edge-triggered toggle.

Here's how it works:

1. One player enters from each side.

2. They each drop an object in the space provided (as marked).

3. When both players agree on the trade by pressing their buttons at roughly the same time, the four doors toggle. This event denies you access to the object you just dropped, and allows you to pick up the item the other player dropped. The players switch places, and exit through the door opposite to the one they entered through.



Example 2: Binary Ripple Counter

You'll need to know how to count in binary to really understand what's going on here.

As you may have guessed from the name, binary counters keep track of how many times something has occurred, or how many seconds have passed. The number is expressed in binary.

First, let's build a counter that counts from 0 to 1, then back to 0 again, and so on - a one-bit counter. This will be simple to implement.



I wasn't kidding when I said it'd be simple. This is just a Timer gate, which turns on and off at a rate of about once per second. The switch pauses the counter.

Right now it's not a very useful counter, is it? Let's add another bit. A two-bit counter counts from 0 to 3 in binary - 00, 01, 10, 11, then back to 00 again, and so on. How do we do this?

Imagine that our one-bit counter is the "1s" column of a binary number (the least significant bit or LSB ). The bit we want to add is in the "2s" column. After the 1s column reaches 1, it goes back to zero and the 2s column is incremented to make the number 10 in binary, or 2 in decimal. So on the negative edge of a bit, the bit to the left of it is toggled! If only we had a negative-edge triggered toggling circuit...



We fed our 1s bit into the toggling circuit, such that when the 1s bit goes low, the 2s bit will be toggled. Here's a diagram of the two outputs over time.



Now let's add a third and fourth bit to make a 4-bit counter that counts from 0 to 15 in binary. All we have to do is continue the pattern.



From here it should be easy to see how to make longer counters, just keep adding more bits. The way I've done it here (using the Timer gate as the 1s column), the counter counts at a rate of about once per second - perfect for timing the duration of things. However, the problem is that for lots of bits this type of counter is slow. Because the bits are chained together, you have to wait for all the bits to "settle", which restricts your possible clock speed. To overcome this, you can make synchronous counters. (see the "1-tick Latching" section)

Clocks

Clocks generate a regular sequence of pulses. This is good for powering state machines, counters, shift registers, strobe lights, CPUs, etc.

A fairly slow clock is the Timer gate, which blinks on and off about once per second. You can freeze the Timer gate by giving it 1 at its input. Slower timer gates are spawnable using console commands:
\spawnitem timer1s 1
\spawnitem timer2s 1
\spawnitem timer3s 1
\spawnitem timer4s 1
\spawnitem timer5s 1

For a fast clock, hook up a NOT gate with a repeater in a closed loop. This produces a clock that flips every 2 ticks - we call this a 2-clock (stealing from Minecraft terminology). You can pause the clock by connecting a switch to the input of the NOT gate.



To make the clock slower, simply connect more things in the loop. This makes it longer for the signal to travel around the loop, hence slowing the clock down.



Notice that odd clocks have only inverters, while even clocks need a repeater. If you tried to wire up an even number of inverters, it'd create a stable circuit - useless as a clock.

If you want very slow clocks, build a binary counter (like the one above), and use the last digit of the counter as your clock. Each bit in a binary counter toggles half as quickly as the one before it, so adding a bit will halve your clock speed. This is much more efficient than chaining up a million gates. Use a counter made out of SWSs that counts down instead of up - it uses half as many blocks that way.

Pulse Shorteners/Extenders

Pulse Shortener

This circuit by saik0 will shorten a pulse down to one tick. It takes advantage of gate delay to do this. When you hit the button, the AND gate will light up because it's receiving 1 from both the NOT gate and the button, but one tick later the NOT gate will turn off, causing the AND gate to turn off. Hence a pulse of only one tick in length is transmitted.



If you want a pulse slightly longer than one tick, you can chain repeaters onto the the NOT gate to create a larger delay. This circuit shortens the button pulse down to 5 ticks in length.



This circuit is an edge detector - it spits out a short pulse when it senses a positive edge (input going from 0 to 1). Here are all 3 types of edge detectors:



To make a clock spit out 1-tick pulses, chain an edge detector onto it! I tried chaining a DDR edge detector onto a 2-clock to make a 1-clock, but it didn't really work, the output wasn't as regular as I wanted it to be. YMMV.

Example: Automatic Door

This is an example demonstrating why pulse shorteners are useful - a door that opens when you walk into it, and closes as you walk away. Stepping on a pressure plate generates a short pulse, which clocks the SWS. If we didn't have pulse shorteners, the pulses from the pressure plates would "overlap", and the SWS would not be able to clock twice in quick succession.

Of course, you could just wire both pressure plates directly to the door and get a similar effect, but this closes behind you quickly instead of hanging open for a second. If this is an entrance to your base, replace the outside-facing pressure plate with a button - monsters and NPCs can trigger pressure plates too!

Note: One-tick pulses generally don't clock the SWS reliably. YMMV. Try two or three ticks (a couple extra repeaters) if you're having issues. This example uses 3 ticks.



Pulse Extenders

Extending the length of a pulse is a little harder than shortening it. This design uses a counter that initializes itself at 11111...1, then counts downwards until it hits 0, at which point it turns itself off. See this thread for more info.

This one uses a 4-bit counter. You can adjust the pulse length by changing the number of bits - adding a bit doubles the length. I forgot to put a wire between the output and the bulb - oops!



1-tick Latching

Latches behave like flip-flops when they are clocked by 1-tick pulses. Because the clock pulse is only one tick in length, the latch's output only has a chance to change once. To extend our "latch/flipflop = camcorder/camera" analogy from before, this is like running a camcorder for only a single frame, creating a video of zero length - a photograph!

This is interesting because it allows us to effectively make flip-flops that are 3 times more compact than any other implementation, and hence make some cool stuff that would otherwise take up too much space. These are also much faster than any other flip-flop.

You might think that these are an unreliable technology that shouldn't be bothered with, but as long as your PC can run Starbound smoothly you shouldn't see any problems in singleplayer. In multiplayer though, all bets are off. If your machines no longer work in MP, just use more traditional flip flops and clocks instead, and deal with the slowness and size.

Example: Shift Registers

An example of how this is useful is the shift register. A shift register is a bunch of flip-flops cascaded in a row, and the contents of the register shifts down the line every time the register is clocked. It can be used to transmit data serially, display scrolling text or patterns, plot waveforms, etc.

Here's a basic shift register. Using the Data switch, you can choose what new data to push into the register. The Clock button is connected to a pulse shortener that transmits a 1-tick pulse. Hitting the Clock clocks the register, moving everything to the right. Notice how the data falls off the end and is lost.



It should be pretty easy to see how to make shift registers longer - and wider! You can transmit more than one bit per clock pulse by having multiple shift registers in parallel. This one is 3 bits wide and 8 long.



Once you've filled your register with some data, you can connect the end to the beginning, creating a closed loop which cycles through a fixed pattern. I've connected a 2-clock to the pulse shortener to create an infinitely scrolling sine-wave.



To inspire you, here are some fun things you can do with shift registers:





Example 2: Binary Synchronous Counter

As mentioned earlier, ripple counters are easy to make, but are slow to update if you have more than a few bits, as you have to wait for the bits to "settle". In a synchronous counter, all the bits are connected to the same clock, so they all change at once.

However, in order to do this, we need to set up some tricky combinational logic to calculate the next number to display in between clock pulses. Make sure you're familiar with Boolean algebra - while possible, it's going to be hard to follow these sections by just looking at the wiring.

Let's build a 4-bit synchronous counter. Say that (q3, q2, q1, q0) is the current state of the counter, or the current outputs of each latch (8s column, 4s column, 2s column, 1s column). Then the next state is (d3, d2, d1, d0) - the D inputs to each latch.

Here it is implemented below. I've highlighted an AND gate that you can re-use in blue. By just following the pattern, you can make these clocks quite large - but the more bits you add, the more AND gates you have to cascade.



Example 3: BCD Counter

(Warning! This is is an old and inefficient design, and I am too lazy to replace it with a guide on how to make this design, which is simpler and better in every way. The short version: make a 10-long shift register that goes in a loop (a ring counter), and map each of the 10 flip-flips to display the numbers 0-9.)

That was pretty cool, but nobody reads in binary, right? We want to have a counter that can display numbers in a more human-readable format. Enter the binary-coded decimal (BCD) counter. This type of counter consists of 4-bit binary counters, one for each decimal digit. Each counter counts from 0 to 9 (0000 to 1001 in binary), then back to 0. These are easy to wire up to a graphical display (which is the next section!)

Unfortunately, a BCD counter involves slogging through even more combinational logic to get it working. It's time-consuming but not too difficult - just be careful to not make any mistakes. I suggest reading the equations and constructing it yourself rather than trying to copy all the wires across. The wires are more there to give you an idea of how to structure it.

Here's a single decimal digit:



To add more digits, simply chain a negative-edge detector onto the highest bit, then connect that to another digit, creating a kind of hybrid ripple- and synchronous counter.



BCD to 7-segment Decoder

Now we have our BCD counter, we want to display it on a screen. Typically you'll use a 7-segment decimal display to show this. Converting from binary to 7-segments is no trivial feat, however. This is the most complex machine in this guide when it comes to combinational logic.

I've broken it into digestible pieces so you can put it together yourself. There are a lot of blocks you can re-use between segments, I've highlighted them in their own colors. The more blocks you re-use, the more compact your decoder will be, but it can be tricky keeping track of it all!

I've labeled each segment arbitrarily as (s0...s6). I've used Outpost Wall Lights to build my segments. The segments actually overlap in my implementation - the corners are just the OR of the touching segments.



I wasn't kidding when I said it'd be tricky, but it's not as complex to implement as you might think. Here's all 7 logic circuits in isolation (as thumbnails, click to enlarge) - the decoder is just all 7 of these wired up at once.



Not too bad, right? The only annoying one is s6, which re-uses a ton of blocks. The whole decoder looks like this:



In retrospect, I actually goofed a little on this one - the purple block is redundant because you can reuse the inverted q1 that's already available (right below the q1 latch). Same goes for the inverter of the orange block, which means this decoder is 2 gates bigger than it needs to be - but hell if I'm going to change it now. With the modifications I just mentioned, the entire decoder is just 10 gates (and about a million wires)!

Here it is in action. I've modded the sprite for the Outpost Wall Light to have better contrast between on and off. Horizontal/vertical fluoroescent lights and wired custom signs tiled together are also a good candidate for a display.



Combination Locks

The logic behind a simple combination lock is simple. Chain up some AND and NOT gates so the door opens as long as all the right buttons are pressed and none of the wrong ones are pressed. The correct buttons are wired directly to an AND gate input, while the wrong buttons are chained to a NOT gate.

(Note: For the sake of clarity, the logic here isn't nearly as efficient as it could be. You can use less gates by using the fact that an AND gate with NOT gates at its inputs is effectively a NOR gate, which uses one gate instead of three.)



Alternatively, store the correct combination in a grid of levers, and use XOR gates to do a comparison. Recall that XOR gates tell you whether the inputs are different, so if any of the XOR gates turn on, don't open the door. This is a little bulkier, but it allows you to change the combination at any time without messing with the wiring.



There's a problem here, though. Once you punch in the correct combination, you only have a very small time window to dive through the door before it closes. By sticking a pulse extender on the end of the logic, you can hold a door open for long enough to walk through at a leisurely pace. See this thread for more info.



If you want an order-sensitive combination lock, you'll need memory to hold the order in which each key was pressed. This example uses a 9-bit-wide shift register. When you press a button, you load up the next "frame" to be bumped upwards into the shift register, then a short time later, the register is clocked to move everything upward. XOR gates are used to compare each frame to the correct combination.

Once you're on the other side, you can close the door behind you by hitting a button that clocks the register, causing an empty frame to be pushed up.







In this version, you need to wait for the previous button to turn off before hitting the next button, or it won't detect an edge and clock the register. If you have a separate edge detector for each button, you can punch the combo in much faster. As a bonus, this makes the combination lock timing-sensitive as well as order-sensitive - a fast sequence of keypresses will create a "snake", while a slow sequence will not. Pretty cool!

Also, there are only 9^3 = 729 possible combinations. A determined intruder could brute-force the lock in less than an hour. To make the lock stronger, you can change the grid to use levers, disconnect the keypad from the edge detector, and put in a separate button to clock the register, allowing each frame to contain any 3x3 pattern. This increases the combinations to (2^9)^3 = 134217728, which would take years to brute-force.

Airlocks

By putting together a few pieces we've learned thus far, we can build a cool airlock. I won't go too far in depth about the wiring, you should be able to work it out by now.

Because you can't have both doors open at the same time, the PS's make it so that opening one door will shut the other, and vice versa. For realism, I used pulse extenders (working as delays) to make the doors close before the other one opens. Since a PS is sensitive to positive edges, a pulse extender works as a delay (if you invert the output) because the positive edge arrives much later, at the end of the pulse.

Entering the airlock:

1. Outside door closes (button is connected to Reset of outside PS)
2. Pulse extender takes the button input and extends it, powering the Alarm and Drains, and turning off the regular lights.
3. The extended pulse finishes, which gives a positive edge to the Set input of the inside PS, opening the inside door.

Fin

I hope that you enjoyed this guide. If you want to learn even more, other forum members have made lots of great replies to this thread with their own creations and ideas that expand upon what I've written here.

If you would like to use pictures or text verbatim from this guide in your own stuff, you don't need to ask for permission but please credit me and supply a link to this guide. Using information or designs in your own words is fine without crediting, but it doesn't hurt! Thanks.

I'd like to thank the following people for helping me write this guide:

• MeMyselfAnDie demonstrated how to control odd-numbered clocks.
  
• Eht helped me design and build the trading room.
  
• saik0 has made many important contributions, including the SWS as a positive-edge toggle, pulse shortener circuits, the "v4" design for the pulse extender, and 1-tick latch circuits like shift registers.
  
• Eonwulf created the "v3" design for the pulse extender, and the combination lock with delayed close.
  
• Everyone who shared new and cool stuff in the replies! Check them out.

If you'd like to suggest additions or corrections send me a PM or post a reply.

 

Omg! A fellow electronic-orientated person in the Starbound World!!!!
Why there's only 1 like possible!!!!!! + Like!!!!

 

We're not the only ones

 

Awesome - I was wondering about the latch right now. Thanks so much!

Now, a question: I was testing the newly implemented Gunturrets. Since I had no f'n clue as to how to use the latch to turn a button into a switch, I used a simple apex-terminal (which basically does the same^^) in order to de-/activate my turrets. Now, the question is: It seems to me, there is a not-told-about maximum outputs stuff like the terminal can activate at once - is this true or was it just my wiring failure that I could activate 3 turrets all fine, but as soon as I wired up 4 or more, some always refused to de-/activate properly?

 

Hmm... I can't replicate this with a button. Don't have an Apex terminal on hand, but a button wired to however-many-turrets-this-is works just great.

Afaik there is no maximum fan-out for wire devices.

 

Now I can't replicate it either. *sigh* Yeah well, time to feel dumb. xD Seems I indeed messed up the wiring somehow. Now it works. But I used the FlipFlop anyways. Now all I need is wireable lights and alarms. ^^ (and more+different turrets)

Sorry I wasted your time - thanks for your reply, much appreciated. =)

 

A friend of mine said he had this problem too, so I was going to investigate it anyway, don't worry. Glad it works now, haha.

 

I was a redstone fan once in Minecraft. I knew everything related to redstone, I knew lots of mechanisms and stuff, and that's when i learnt about logic gates, latches, etc. Sadly, now I am SO lost in Starbound wiring

 

Oooh, I feel ya! E.g., a simple T-FlipFlop for a button is/was a nobrainer in Minecraft for me, but this? My brain hurts from trying to wrap its gyrus cinguli around the wiring mechanics.

 

To me, the most obvious way to make a T-FF in Starbound is to use a XOR feedback loop on a D-FF, turning it into a T-FF.

I'm sure there are other ways.



Also, just because it's in the same room, have a 4-bit ripple counter too.

 

Huh.. *pretends to have understood all of that* Yeah, that's really obvious.

Aw c'mon man, now you're just showin' off!

 

The best way I can explain it is as follows:

When you give a D-flip-flop a clock pulse, it "copies" the current input and produces it at the output.

If you have a repeater as your feedback, the output feeds into the input, so the value will stay the same on a clock pulse.

If you have an inverter as your feedback, the complement of the output feeds into the input, so the value will toggle every clock pulse.

A XOR gate acts as a repeater if the other input is fixed at 0, and acts as an inverter when the other input is fixed at 1.

Hence, you have a repeater feedback (stay the same value) if T = 0, and inverter feedback (toggle value) if T = 1, which is what a T-FF is.

 

Yeah, understood, but what is a feedback?

 

A feedback is something that connects the output to the input. It literally "feeds back" the output. I won't bore you with the details.

 

Oh, I see.

 

First off, I love the guide. I loved redstone in minecraft and i love this. But I have to ask, is there any benefit to using the latch for the oscillator, as opposed to just hooking a NOT gate up to itself? It uses half as many materials, which isn't a big deal now, but when they become more expensive from the 3D printer, it might be


On another topic, if you use an AND gate (an OR gate would work too) as a 1-tick delay, and an XOR gate, you can make a pulse shortener, so that each button press outputs a pulse of exactly 1 tick in length


You can then use this, connected to an XOR gate, with its own output connected to its other input to create a (to me, at least) simpler button toggle

 

I was working on a side note about clocks while you made this reply. Freaky. However, all my odd clocks were free-running, it didn't occur to me to tack switches on to them. I've updated it with your designs and credited you for the idea.

About the latch clock, excellent point, if you just want something to blink really fast you should use a NOT gate. However, they're not the same clock, the latch clock is a 2-clock while the NOT gate is a 1-clock. If you really need a 2-clock for whatever reason, the latch clock is fine (another option is an AND gate and a NOT gate, so if AND becomes cheaper than latches in future updates I'll advocate that instead)

I like the pulse shortener. How about a pulse lengthener? In Minecraft I always had a mess of parallel repeaters. I don't know the canon way of doing it.

Your pushbutton toggle uses one fewer gate, nice.

 

I'm not sure why my toggle wasn't working for you, I used it to build a binary clock. Perhaps if you would be interested you could hop on a server i could host and we could test out different wiring mechanics.

And as for a pulse lengthener, I think your best bet would be to use AND or OR gates as repeaters and do it the same way as minecraft. I'll look into more efficient ways of extending the pulse

 

Weird, I rebuilt it and it works now. The wiring system is a little buggy from time to time. That's my excuse, and I'm sticking to it.

But yeah, that's real nice. Totally stealing that.