555 Timer Step Sequencer Synthesiser

If you, like me, have been inhaling so much flux that the bronchioles of your lungs have mutated to convert the zinc chloride into electrolytes supplementing your chronic dehydration, then you will feel a persistent craving for analogue logic.

Perhaps, on a benign Wednesday night, your mind will construct a simple project; a weekend project with a little microcontroller, a few pots, a dozen lines of code. As you lay your head down with a smile, you start to dream simple dreams about daisies, dragonflies, and yellow mist in the sky and… oh! What’s that? It’s a lonely soldering iron on a rock.

The Iron glowing copper blue, it beckons. Your fight or flight disarmed, your inner voice screaming, you are helplessly approaching. The once-infinite meadows become claustrophobic, the mist clears revealing a void. The rock becomes a creature and the floor tumbles beneath you. The soldering iron breaths deep and it asks the devil’s question:

"Ya reckon you could do it with a NE555 instead?"

At once the calendar of your life spills into a mighty river and you are ripped into its currents. A turbulence of analogue nonsense sprawls inside your defenseless mind. LEDs and ICs webbing into knots to the hum of a coffee machine as dehydrated as you. Your simple project becomes a thought-drain of copper and plastic and you descend and descend into what should have been easy… but is now:

OK… I’m dramatising a little bit. I’ve already made all the mistakes on your behalf so if you, more disciplined than I, refrain from tangents this is a really enjoyable project with an actual musical instrument at the end of it. Building it often had a zen-like charm to it; meditative soldering to a podcast or tunes. In contrast, you also get a few “fist pump” moments when you finally crack a module or hear your first sound.

This comes together in six modules:

1. The Stepper
2. Sequence A
3. Sequence B
4. Frequency Meter
5. The Oscillator
6. Power

I approached the project from top to bottom. However, in this write-up, I want to tackle these modules in reverse, which I think will make it easier to digest and debug. As we go I’ll leave little tips and tricks I learned on the way (and you get to decide whether they are useful tricks or just emotional black holes I’m trying to offload). Don’t forget to check the comment section on the forums where you can read superior designs offered by the CE community. But you didn’t come here for engineering but for “artistic license”.

Each chapter below addresses a single module from the above diagram.

They will contain a schematic and a BOM for that module.

However, for brevity, each module's BOM will not include items like “solder”, “a pair of pliers” or “an iron”. If these are items you do not own, I have a MASTER BOM which contains everything I needed to accomplish this build down to the last screw.

When building stuff like this you're always going to run into unexpected behavior. I have learned that expecting stuff to go wrong and being prepared, helps stave off the imposter syndrome and keeps your spirits up. On this journey, there are a few debugging tools that turned out to be invaluable when debugging.

A multimeter.

This is a completely analog project. Even if you intend to follow my schematic precisely I still think you will run into puzzles that require measuring. Continuity is a real challenge on this board because there are a lot of hand-soldered connections. Some of the values of the jellybean parts have to be quite precise to get the timing correct so it’s useful if your multimeter can measure capacitance in addition to ohms.

Potentiometers.

Buy two quality potentiometers, solder on some jumpers, and screw them into a box. So many times in this build I needed a potentiometer and there was never any room on the breadboard to fit it. Just having a jumper wire that I can stick anywhere, on any input, and vary the voltage was invaluable.

A run of LEDs on a breadboard.

Before starting this project, I suggest you get one of these small breadboards, some LEDs, and resistors, then use them to build something like the picture. It’s just 8 parallel LEDs each with a current limiting resistor. So often in this project, you need to watch signals move around the board. Perhaps watching the pulses of the clock, checking for race conditions, or watching the output of a register. If like me you don’t own an oscilloscope this is probably mandatory to get through the build

An SR Latch.

I used an SR latch as a substitute for my clock whenever I needed fine control over the timing of the circuit. Timing problems were a big challenge for me but only in the design stage. Some tempted by exploration may want to remix, dare I say improve, my design. If that’s you then this is a useful breadboard to have in the pocket. 

I think building the power module is a nice first step since it squares away the task.

Interacting with this instrument usually means getting your hands close to the electronics.

That means we want to be rocking safe 5v and under an amp. The main restriction here is the counter that we are using which is a 74LS channel and needs 4.75 - 5.25V to run. There are a lot of power supplies you could use here, but I've elected to use a USB B port. Most USB power supplies use USB 2.0 specs or above which is 5 volts and a maximum ~500ma. Perfect.

We also want a switch to turn this channel on and off. On this occasion, we don’t need to worry about debouncing the switch because, as we will explore later, the sequencer has a 1.65-second reset vector built-in.

Below you can see a schematic, BOM, and pictures of what I came up with. However, having had the opportunity to measure the total amp draw of the circuit, which for me is under 100ma, I recommend something like a DFRobot Breadboard Power Supply.

For my simple design, I used half a Piicodev protoboard and soldered some dummy header pins on the corners. It plugs into a breadboard and is rock steady. I wanted it to be relatively low profile so I soldered my switch onto right-angle header pins. To get power from the protoboard to the breadboard you can solder 5v and ground to two of the corner header pins. There is a forum post on this if you have any questions.

BOM

For your synth, you could use any oscillator you like. There are lots of examples online. One popular choice for bass is a sawtooth wave which has a little color and warmth. For this build however, I want to use a square wave synth since I prefer its sharp and sweet tone in the lower octaves.

The common choice for a square wave is a NE555 timer. It’s not the most beautiful synth but it's a simple design. The NE555 is a very famous chip for hobbyist electronic nerds and we are going to use it a lot in this build. If this is your first time encountering an NE555 now’s a good opportunity to introduce yourself.

Lot’s of great introductions to NE555 timers out there. I learned from Ben Eater here. TL;DR, the magic of a 555 timer is (usually) the magic of a capacitor because a NE555 (usually) measures how long it takes for a capacitor to charge using its internal comparators. The NE555 datasheet outlines lots of common configurations. The one we want for our oscillator is what’s known as the astable configuration.

Astable: when the output is low it wants to be high and when it’s high it wants to be low. That’ll oscillate™. All that’s missing is being able to control how long it can sustain its state before it switches. We do that with the resistors Ra and Rb. Because we want our synth to hit a range of pitches we need to use potentiometers so Rb is variable.

I made a quick and dirty video which is so egregiously oversimplified it is technically incorrect. But if you want ‘technical’ I don’t know why you came to me so you’re going to forgive its incorrectness since it has temporary pragmatic value. In it, I discuss how I chose my values for Rb, Ra, and C and why you might choose different values depending on your goals. If you're already familiar with the 555, you can skip it.

Oscillator Range

I chose a relatively small 680Ω resistor for Ra which keeps the duty of the waveform relatively symmetric. I’ve split Rb in twain, a variable resistor for our frequency control and a 1.5kΩ resistor to set a floor. The size of your variable resistor will determine the range of pitches you have available and I elected 20kΩ. That left me, in theory, with freqs between ~35 and ~395hz. In practice I got numbers like 30 - 360hz.

Amplifier

Our oscillator needs an amplifier so I used Core’s Makerverse PAM8302 2.5W Mono Amplifier. Any speaker will do, but I liked this 8-ohm speaker. The Makerverse amp has 5 pins. IN is for your audio signal. In our case, the audio signal is the output of our oscillator [Pin 3]. SD stands for shutdown which we can ignore because it is active LOW and has an internal pull-down resistor. Below the IN is a GND pin, which is handy if your audio signal does not share a common ground with the power supply.

BOM

How the oscillator connects to the sequencer.

In the schematic above, our Ra resistor is [R19] and our 1.5k that sets the minimum for Rb is [R20]. Astute, you've noticed that the variable resistor that would control our frequency is not depicted. Standing in its place is a sequence. In this circuit, a Sequence is just a row of potentiometers connected in parallel with the oscillator. Pin 7, the discharge, travels to one of the potentiometers of the sequence and the returning signal is fed into the threshold adjusting the pitch of the synth.

That’s right, I promised you a particular chapter order in the introduction which it’s now revealed I had no intention of respecting.

To recap: In this instrument, a ‘sequence’ is a set of 8 pitches played one after the other.

We can vary the pitch of our oscillator with a variable resistor, so our sequence will be made up of 8 pots. These pots will need to be connected to the 555 timer in parallel. Our challenge is going to be ensuring only one of them can draw current at a time. We will worry about that later when we look at our stepper module. For right now let’s dive straight into the schematic for a single pot in our sequence.

This single channel can create one pitch using its variable resistor [R3A]. You can see the labels indicating where this channel connects to our 555’s Pin 7 (Discharge) and where it returns to Pin 6 (threshold).

In series with [R3A] is an NPN transistor, [Q1A] which is responsible for gating, meaning we can disconnect the channel when we want to. Feeding 5V into the base of the transistor connects the channel to the 555 oscillator allowing current to flow from the 555, through the potentiometer, and back into the threshold pin making it oscillate.

I/O

The transistor gates off a channel ensuring only one is connected at the time. An LED, [D1A], indicates whether the base is receiving current and the channel is connected. We can control these transistors with our stepper.

Muting the channel

[S1A] is a double-throw switch that we can use to disconnect a segment of the sequence from the stepper module. Pin 3 is connected to the stepper and will receive 5v when it’s time to connect to the oscillator. Pin 1 however is left floating and this disconnects the transistor from the stepper muting the channel. (you could use a single pole if you prefer but I recommend something like the switch I used because it comes together easily).

BOM (Per single channel)

Circling back to the schedule, let's return to our oscillator and start to think about some kind of frequency feedback. The dials that control the frequency are going to be on the other side of the circuit, and hard to read at a glance. So it would be good to have some visualiser for what the 555 timer is doing. Plugging an LED into the output of the 555 won’t provide much insight since the 555 will be cycling many hundreds of times per second. Maybe the brightness will vary a little but this isn’t what I want.

This is definitely the most complicated part of our circuit so we are going to walk through it nice and slow.

The basic idea:

The goal is to measure the speed of the 555. One way to do that is to count the rising edges of the output over time. That last sentence had two parts:

1. a counter to count the number of transitions from low to high.
2. a timer to count the number of moments elapsed.

A counter.

There are all sorts of ways we count rising edges along a sound wave. For example, we could use a 74LS90 decade counter like in this video. Or perhaps we could use a series of “divide by two D Latches” to slow down the flashing of an LED until it’s sedated enough for the human eye to see. I experimented with both of these ideas, and they’re fine.

However, what I want is a meter, vertically stacked LEDs that rise and fall with frequency. For that we are going to meet another recurring IC in this build, the 74HC595 shift register.

A shift register is a bunch of D flip-flop latches. The first latch is fed into the second latch which is fed into the third and so on. i.e. on each rising edge, which is what we are trying to measure, the output of flip-flop A is latched into flip-flop B, which is now primed on the data pin of flip-flop C. Whatever data we push into the 74HC595 will snake its way down the daisy chain of flip flops.

A meter is just a chain of LEDs and we’re going to leverage the symmetry between a chain of flip-flops and a chain of LEDs.

A timer.

When you’re measuring the number of events you need a base unit. For example, a speedometer is kilometers per hour. Our frequency meter measures cycles per _. We need our timer to fill in that blank. The lowest our oscillator can go, using the components I chose, is ~35hz which means the longest window of time we could care about is 29ms. We need a timer that clocks cycles per 29ms. For this, we can use a 555 timer again, this time in the Monostable configuration.

Monostable: meaning the output is only stable in one state. If you push it high it’ll try to hold it until it’s simply unsustainable and then will fall low and stay low. If we can help our monostable 555 hold a high state for 29ms then we can ask the question of how many oscillations occurred while the output was high. I’m calling this 29ms a window.

If you need an introduction to the monostable 555 timer I recommend this colorful video by FriendlyWire.

The race.

This is a short video where I talk about how the astable oscillator and the monostable timer are going to interact with each other in a race.

TL;DR we are pitching our two 555 timers together in a race. How many rising edges can our oscillator manage to pump into our shift register before our monostable circuit resets all the latches.

Timing diagram

Here is a timing diagram with an example scenario.

RCLK & SRCLK are driven by our oscillator. The RESET pin reads the output of our monostable timer. Notice that when the oscillator drops to a lower frequency fewer latches have the opportunity to reach the HIGH logic level.

Schematic

See below the schematic for the entire frequency meter.

On the left, we have the monostable 555 and on the right, we have the shift register.

The shift register drives our LEDs, each with a current limiting resistor. The resistor values are chosen to graduate the brightness of the LEDs across the meter. If you choose different LEDs to the BOM or decide you want the brightnesses to be identical across the meter, you may have the experiment with the resistors.

Notice that I haven’t wired up QA on [U9]. This isn’t for any reason other than I couldn’t be bothered. Below, you can see the pinout of the 74HC595 and will notice that QB-QH are all contained on one side, easily accessible to the LEDs. QA is over with all the controls, and the way I was soldering it on the board it was a pain to reach. You could include it if you like.

Adjusting the timer.

Remember when we did all that theory to decide how long we wanted a monostable timer to hold its high state? 29ms and all that? Boy, that was fun, wasn’t it? Well, now I want you to throw that all out the window because, unfortunately, we are in the real world.

Some experimentation may be required to get the frequency meter to look just right to your eyes. The speeds we are working with here are relatively fast, and the tolerances on your components and ICs may not be identical to the ones I sourced. Following the values I used will get you close, but I had to play around with lots of different resistors [R21] and Capacitors [C11] until I was happy. What I calculated I would need, isn’t exactly what I ended up using, and I suspect that’s going to be the same for you too.

BOM

This module is all the logic that connects and disconnects each channel of our sequences.

I’m building a 16-channel instrument. That’s 16 unique pitches in a cycle. We need two bytes of information to work with. The first byte can control Sequence A and the second byte Sequence B.

Software equivalent.

If we were building our stepping-in code it would look a lot like this. I think it’s a nice way to visualize and understand our goal for the stepper module. As we build our hardware solution we will see circuit equivalents to each line of code.

```rust

use std::thread;

fn main() {
    let mut k : u8;                                                     // Counter
    let mut data : u16;                                                // Register
    data, k = 0;                                                     // Reset Vec
    let tok = thread::Duration::from_millis(1000);                  // Clock

    loop {
            if k == 0 {data = 32768;}                                  // Carry IN
            println!("{:016b}", data);                                //  Data Out
            data = data >> 1;                                        // Shift Data
            k = (k + 1) % 16                                        // Counter Incr
thread::sleep(tok);                                                // CLK Speed
    }
}

/* OUTPUT
0b1000_0000_0000_0000
0b0100_0000_0000_0000
0b0010_0000_0000_0000
0b0001_0000_0000_0000
0b0000_1000_0000_0000
0b0000_0100_0000_0000
0b0000_0010_0000_0000
etc */

```

However, modern system language software is out and integrated circuits old enough to complain about the Whitlam government are in. Let’s get back to circuits.

A bird's eye view

Here is a quick video where I talk through the circuit. This is just to get an overview of the interactions between all the chips in the design. We will repeat ourselves below in more detail.

Hardware requirements

There are four sub-modules in our stepper:

1. A Reset: something to ensure we always start with all channels off when we turn on our instrument.
2. Two Registers: something to remember and modify which bit of our sequence is connected to the oscillator.
3. A Clock: something to synchronize the stepper and adjust the speed of the sequences.
4. A Counter: Something to flag the end of the sequences.

Once again, in reverse order, let’s start at the counter.

Clock

Gotcha again, promises are for chumps! For our clock, we need something periodic, quite slow, and variable speed. A common choice is a returning character to this build, the 555. We can use the Astable configuration again to synchronize the other ICs.

Slowing the clock and tuning the sequences

I think you should choose a relatively large capacitor for your clock since you want to be able to drive this quite slowly at times. That’s because there is no “pause” on this circuit, you turn it on and it just runs until you turn it off. To tune the pitches of the sequence, it’s easiest to just run the clock so slow that you have plenty of time to adjust the timpots.

You can use the skills we have already discussed to decide what kind of speeds you want for your instrument. I chose speeds between 40 and 3000 In BPM assuming each sequence is a bar of 8 quavers.

BOM

Registers

The game of this stepper is that we want to shift a single HIGH bit across two bytes of data.

Each of our two bytes is going to be controlled by an integrated circuit we have already met: the 74HC595 shift register. Let’s have a look at another circuit diagram.

See the table of the MSBs of those data outs. QA to QH each represent a channel of the sequence.

Notice that the INPUT becomes QA on the row below.

Notice also that the 1 is being shifted right each clock cycle.

Wiring

We looked at building a clock for our stepper in the previous chapter, and that’s what’s going to drive the shift clock and the register clock of our 74HC595. On the first page of the datasheet for our chip, we read:

”Both the shift register clock (SRCLK) and storage register clock (RCLK) are positive-edge triggered. If both clocks are connected together, the shift register always is one clock pulse ahead of the storage register.”

That’s ok by me. I don’t care when the data is output as long as it’s correct. Tying our clocks together will keep our wiring simple and that’s a boon. We can tie pin 4 LOW again since we always want the output to be enabled. This is all just like our frequency meter.

However, unlike last time when we tied the serial pin HIGH, we want that pin to be dynamic: sometimes HIGH and sometimes LOW. For that, we are going to need one more IC we haven’t looked at yet.

BOM

Schematic

Counter

Recap! We have this Shift register that moves data across latches and we want to inject a single 1 at the start to be shifted across. That single HIGH bit will just fall off when it reaches the end of the chain so we want to have another HIGH bit ready to replace it. Because there are 16 latches in our stepper, we need the serial input of our 595 to be HIGH every 16 rising edges of our clock. We’re going to count those 16 rising clock edges with a 74LS161 4-bit counter ( 2⁴ = 16 ). The animation below is not completely accurate, but it gives you a visual.

BOM

Schematic

Importantly, we don’t need to know what step we are up to i.e. it’s not useful to know when we are on the 7th step in our sequence. We don’t need to do any logic on the four-bit data outputs. The only step of our sequence we need to catch is the 16th step, because that’s when we need a HIGH logic level on the shift registers serial input.

RCO, pin 15 of the 74LS161, is the carry pin, which is HIGH when the count overflows from 0xF -> 0x0. That’s exactly what we need! The carry-out of the 161 is patched to the serial in of 595. Easy!

There are a few enable lines we want to tie down. You can see in this excerpt from the datasheet that we want to tie the ENT pin HIGH to activate our RCO. I’ve actually tied the ENP high as well for debugging purposes.

Reset

When you power up an ICs like the 74HC595 the outputs are not guaranteed to be either HIGH or LOW. Until data is fed in and the clock rises Qa-Qh could be anything. This is a problem for our circuit because it’s important that only one of our channels is on at any time. When I was designing this circuit one of the challenges I ran into was getting all of my ICs into known states as soon as you power on the board.

I’m not the first champion to have this problem which is why all our ICs have a reset pin that will zero out all the outputs. That reset pin is Active LOW. What we need is a circuit that, having been powered on, starts off LOW and then permanently transitions HIGH after a short moment. That way we can plug that circuit into the reset pin of all our chips and it will zero everything when we boot up the circuit.

Most of my time in the design stage was spent fumbling for a candidate reset vector. I tried logic gates, flip flops, MOSFETs, and even complaining to my mum. I finally found the right search prompt, “On after circuit” which led me to yet another NE555 timer.

To zero out the stepper on boot, the output from our 555 reset is fed into both the counter and the two shift registers of our stepper.

Schematic

This circuit starts low, charges up a capacitor, triggers pin 6, and sets the output to HIGH. It’s essentially an RC filter on pin 2 of the 555. The game here is that there is nothing attached to the 555 discharge. Since the cap can’t discharge, the 555 is stuck HIGH for the lifetime of the circuit which is exactly what we want.

BOM

We need to think about the race conditions between our counter and our shift registers.

Let’s look at two events:

Event A: To read the value on the serial input of our first shift register we use the Storage Register Clock Pin, which is positive edge triggered.

Event B: The counter is also positive edge triggered which means so is the Carry Flag. The Flag is HIGH when all four OUTPUTS are HIGH: count 0b1111.

The challenge here is that we need B to happen before A. If we read the data before the carry flag has time to go high we drop that bit. Inversely:

We need the HIGH carry flag primed before the input is read into the storage register.

Easy fix. Let’s pass an inverted clock to the Storage Register. If the duty cycle to the register is 50% out of phase behind the duty of the counter, then the counter will always be flagged first. Let’s clarify that with a timing diagram.

To invert the clock we can use this simple mosfet circuit. The pull-up resistor sets the default to be HIGH. When the clock opens the MOSFET, the source will be grounded, and the logic level will be LOW. If the clock is high, the out is grounded, and if the clock is low, the out is pulled up. I used an aggressive 550 ohm resistor but I think 1k would have been better.

BOM

Schematic

Breadboards

My vision for this was to build the entire thing on solderless prototype breadboards. Eventually, I transitioned to a permanent soldered solution. To make that transition easy I chose these Makerverse Protoboards where rows are connected and the power bars are available. As a result, I often didn’t have to recut and strip the wires in the transfer.

You, coming to this fresh and unrestricted by my early prototyping choices, may choose to start with a large generic protoboard.

However, I did find that it was useful to start on solderless breadboards, particularly if you intend on remixing the instrument e.g. adjusting the oscillator's frequency range. It’s nice to test and listen to your sound before committing to the soldering iron.

Indeed, you could keep it all on a breadboard and leave it as a more flexible instrument. (I want to talk about that more at the end of this write-up).

Basic Assembly

If you’re copying me, I imagine you have four breadboards laid out like my overview. Here are some quick notes for each module.

Stepper

You have a lot less room than you think you do, so be sure to be conservative with your space. It’s really useful to have a different coloured wire for your data, clock, and reset.

Sequences.

Again, space is a premium, try to keep your modules tight. When connecting the inputs and outputs of each channel I wired them together by twisting two wires together and feeding them into the same hole. On Sequence A you need room on the right for the 16-channel input and to pass the second byte to Sequence B below.

Oscillator, Meter, Power, and Amp.

I’d recommend putting this board vertically. That way you can face the USB socket and amplifier output right side of your instrument for easy connections. The modules can be put anywhere on the board and I found there was space to spare.

Caps on the rails.

I found that even after all my so-called “carefully considered planning”, my board was still a little glitchy. However! After 3 days of debugging, I feared all hope was lost. Then I read this article, which I dug through my history to recover. It casually suggested some capacitors on the power rails of the breadboard. I stuck some 100nf on the power rails randomly and it cleaned it all up. I used 5 in total: one on each board and a 5th right next to the USB power supply. 

3D-printed base

To keep the whole thing together, I’ve CAD up a 3D-printed base. The boards just mount onto m3 holes recessed in the base. The base comes in two parts and can be connected like a puzzle. This allows you to pack away and store the synth; it's probably not an instrument you’ll be using on the daily. Not required, but there for you.

Download base STEP files here.

Connecting our breadboards

Once you've assembled your modules with all the ICs and components you now have the question of how you're going to connect them together. For example, you have 2 bytes of data you have to patch from your stepper to your two sequences.

If you intend on a permanent fixture this is a non-issue. However, if like me you want the ability to pack down the instrument, then you need connections that can be disconnected when disassembling.

I found this problem non-trivial. I had some ideas:

1. Solder in female header pins on the sequence inputs and the stepper output. Then connect them together with jumper wires. If you’re sticking with solderless breadboards this is actually an excellent solution. Personally I didn’t like this solution because It’s too busy; too hard to access the potentiometers.
2. Do something absolutely disgusting like this. Do not pass go, do not collect $200.
3. Terminals Blocks… actually that’ll work.

Terminals

I actually use these terminal blocks in my build to connect the oscillator to the sequences. I also use one to pass power from the USB socket to the other three boards. I personally don’t think this is scalable.

I did come up with an alternate solution but … just don’t hate me.

Terminals

I actually use these terminal blocks in my build to connect the oscillator to the sequences. I also use one to pass power from the USB socket to the other three boards. I personally don’t think this is scalable.

I did come up with an alternate solution but … just don’t hate me.

Breadboard tunneling and other egregious sins

I soldered header pins to the bottom of my boards and then used underground solderless prototype breadboards to make like the London Tube and transit my bytes around. You don’t have to do this… you probably shouldn’t do this… but it worked.

Load 0b1111 into the 74LS161

When you turn on the board I built there are a few moments where nothing happens. That’s because we reset the counter, which zeros it out. That means we now need to wait 16 clock cycles for our first carry flag, and depending on the clock speed that can take a hot minute.

That didn’t bother me, but if it bothers you the 74LS161 has you covered. We glossed over it before, the chip had a LOAD pin (9). That load pin is also active low, just like the clear pin (1). Instead of using our reset vector to clear the chip to zeros, we could use it to load in a value like 0b1111. Pins 3,4,5, & 6 would all need to be tied HIGH.

Doing so would cause the counter to boot with the carry flag high and the instrument would jump right into some sweet music.

Constructing the Sequences.

When building your stepper it’s easy to make a mistake. I prepared some little ziplock bags of components, each representing a channel and I suggest you do too.

If it interests you have a look at this video below where I explain how I arranged my components on the board.

Use potentiometers instead of trimpots

I used trimpots everywhere because they were cheap and easy to order.

However, you might prefer to use potentiometers since they are nicer to use and more durable. Trim Pots aren't really designed to be used the way I'm using them.

Stabilising the reset.

I found the output of this circuit slightly unstable once I put it all together. To resolve this, I fed the output of the 555 to the base of a P100 transistor (through a resistor). This meant that the stable 5v being collected by the saturated transistor was being fed to the reset pins. I don’t know why this helped but it helped.

Use leadless solder

I wish I had used leadless solder. Using this instrument means touching solder and that means you need to wash your hands all the time. Leadless solder feels like the obvious choice, but it didn’t occur to me. It’s now occurring to you.

Pause functionality

Something I don’t think would have been too hard is a pause function. I think a cute switch like one of these could be used to disconnect the clock from the counter and registers. Just attached one pole to the clock and the other pole to 5v (because the registers shift on the inverted clock). Because the registers latch on their values, the channel you are on will stay playing and this could be an easy way to adjust the pitch. You could optionally debounce it.

Failed Design: Looped Stepper

Originally I had this idea that, instead of a counter, I would feed the output of the second shift register back into the first. This would form a feedback loop where the same single HIGH bit would be stuck in the registers forever. The trick was to get that first bit into the registers on launch. I needed multiple initialisation vectors.

I actually got this working, and had the foresight to record a video of me talking through the circuit so I wouldn’t forget how it worked. In the end it was unreliable. Sometimes it wouldn’t load in the serial data, sometimes it would lose the serial data. Sometimes it would load in two consecutive bits.

I think this idea has promise but it needs lots of parts. Maybe 74LS00 NAND gates for switching between the initialized bit and the looped bit. I found these daisy-chained 555 to spread out your initialisation over time. Would a proper stable power supply help? Lots of improvements to consider.

It’s a cool design and I would love it if someone got it working. I need a video of the instrument running 10 mins straight without glitch or it doesn’t count!

Tools

I’ve listed the skus to the exact tools I used for those interested. Obviously, you can buy what you prefer. I’m not claiming the tools I used are either optimal or preferable and I am not necessarily endorsing them.

Frame

Integrated Circuits and Breakouts

Components

If you are starting from scratch, consider buying these in packs.

I promise you will use them. I remember buying my first pack of resistors thinking “What am I supposed to do with all this?”. How naive!

For this build, you might like:

• Capacitor Kit
• Resistor Kit
• LED Kit
• Trimpot Kit

Below are the specific components I soldered onto my instrument. You don’t have to use these values exactly, they’re just what worked for me.

Conclusion

It’s a nice time to slow down and remind ourselves that all of this could have been avoided with a microcontroller and the liberal use of malloc. Commercial step sequencers are getting cheaper every year. The joy of this instrument, for me, was the dreaming and the debugging.

When I decided to make this step sequencer I gave myself the restriction that I couldn’t google “how to build a step sequencer”. I wanted to test myself, come up with a schematic on my own, and force myself to fail. I’m still a beginner and I need learning opportunities.

Since finishing the build, I’ve allowed myself to jump online and google other people's designs. I knew that this could not have been a totally original idea. I’m proud to say I remain happy with my design, even after researching other options.

You may find joy in remixing my ideas. Perhaps expanding the instrument to a 32-bit bus. Maybe add a button that manually steps the clock and makes your own rhythms. There is more room to experiment.

I am done.