Final mix

“Cheaty McCheaterpants!” I hear you cry. “You have multiple instruments playing there — where’s the challenge in that?!”

Well, this whole series is about how to achieve as close as possible to a particular imagined pulsing sound using the particular features (or working around the particular limitations) of different synthesizers; and this one has particular features that are particularly well-suited to this particular task.

(rackmount module second from the top)

Features:

• 28-voice polyphony across 8 “Parts” (instruments)
• Stereo audio output
• All voices played from PCM-encoded waveforms of recordings of real instruments
• Velocity received and used, in some cases not only for amplitude but for the way instruments sound different when played at different dynamics

Let me walk you through the orchestration and development of that sound sample on this platform, which relied heavily on the Yamaha QX5 (1986) MIDI sequencer for execution.

Roland M-OC1 Overview

The orchestral sound module has a common architecture with several other related sound modules — eight “Parts,” of which the first seven can be assigned any “Patch” (instrument variant) in the system and the eighth is dedicated to a drum kit or related percussion section. The module has “patch” and “performance” modes, with (if I understand it; I’m still learning the architecture)

• a Performance being a container for the Patches assigned to each of the eight Parts plus Effects (hazy on this one)
• a Part being one of the eight different instruments/variants, which is assigned a Patch and can be assigned its own MIDI channel
• a Patch or maybe Tone being a particular instrument/variant, of which there are 226 on this particular module, each of which is made of up of one to four Waveforms
• a Waveform being a PCM sample and the smallest unit of sound

So to look at the most granular level, Waveform List entry 68 and 69 are Timpani Roll forte and Timpani Roll piano; but I don’t find any Patch that provides Timpani Roll. I suspect the PCM samples are provided to allow you to build your own timpani roll … but I haven’t got that far yet.

In any case, with that much of the architecture sorted, my task was to decide what instruments to use, assign one to each Part (up to seven, optionally including a separate eighth for percussion), and decide what to have them play.

The Musical Plan

I’ve had this sound module in mind from the inception of this series as a very different approach from classic synthesizers. And I knew a few things in particular about how I wanted to score the pulse sample for this module:

• I wanted to use a mix of low strings, low woodwind (expecting English horn or contrabassoon), and low brass for the long pedal tone.
• I wanted to have a different but related set of instruments play just the pulses.
• I wanted timpani to introduce the pulses.
• I wanted to demonstrate what orchestral composers (which I am not, just a past performer) know — that the audience perceives the “activity” of the fastest-moving notes they can hear, even when some (or many) of the instruments are holding longer notes. In other words, the pedal tone can continue throughout; the pulses can be separate instruments; and the pedal tone needn’t change to a faster rhythm.

So my process was:

1. Audition the different Patches to find candidates for the pedal tone and for the pulses.
2. Start programming the candidates into different Parts, making sure their timbres blend the way I have in mind (because I can’t rely on a conductor to give feedback about blend to human performers who will adapt their playing to what’s needed for my mix).
3. Program the different musical lines into a sequencer on different MIDI channels, because I have three musical lines and I don’t have a keyboard with me that can split into more than two zones.
4. Set and check and set and check and set the levels of the different Parts in the final mix, making sure they balance the way I have in mind (because again I can’t rely on a conductor to give feedback about balance to human performers who will adapt their playing to what’s needed for my mix).
5. Automate the dynamics on the sequencer.

Selecting Candidate Patches

I sat down with the module, a keyboard, the manual, and Google Keep to try out the Patches pertaining to my orchestration.

To do that, hold the Part button and use the arrows to pick which of the eight Parts you’re editing, then release and use the arrows to scroll through the available Patches.

For the pedal tone, trying out low woodwinds — 11 English Hrn1, 12 English Hrn2, 13 English Hrn3, 18 Bassoon 1, 19 Bassoon 2:

Low woodwinds

For the pedal tone — which will quietly change pitches at the end — I wanted something without a significant initial attack, so I put 11 English Hrn1 onto my list.

For low brass, I listened through a lot of brass, ultimately choosing 58 Tuba 2 and 79 Big Bones to put onto my list:

Low brass

For low strings, 221 Chorus Vc (violoncello) and 222 Stereo Vc were the only realistic choices:

Cellos

On to the pulses. I wanted timpani to introduce them, so I tested 140-143 Timpani 1-4:

Timpani

You might be wondering where 143 is in that recording, and so am I. It seems to be much quieter and I wasn’t hitting the keys with enough velocity to really make it speak. I entered the second and third onto my list.

For pulsing pitches, I wanted instruments with a brighter timbre but (because I want the pulses to be more “wuh”) not particularly sharp attacks. First, 82 Full Brass and 83-90 Brass Ens 1-8:

Brass for pulsing

The latter several sound very similar, but my recollection from an earlier session is that they may have different attacks when played at a higher velocity than is really comfortable for me on this springy keyboard. I ended up putting 82 Full Brass, 84 Brass Ens 2, and 90 Brass Ens 8 onto the list.

Next, sampling low strings for pulsing — 165-171 Strs L-H (low-high) 1-7, 172 Agitato Strs, 173 Vivace Strs, 174-175 Strs M-H 1-2, and 176-178 Strs L-M 1-3:

Low strings for pulsing

Of these, 166 Strs L-M 1, 172 Agitato Strings, 173 Vivace Strings, 176 Strings L-M 1, and 177 Strings L-M 2 made the list.

Finally (for auditioning instruments), 203-204 Pizzicato (plucked) 1-2:

Pizzicato strings

MIDI Assignments (and Woes)

With some options on the table, I started “mixing” them (setting levels to blend well). In the sound module, which is not what I’d have preferred to do.

The whole time, I’d envisioned writing the orchestral score in MuseScore, including dynamics for the different instruments, and letting it play back the parts for me to the sound module. Alas, at least on the Mac, MuseScore has removed playback to external MIDI devices. Not to worry; I can save the score as a MIDI file and learn enough Ardour to import it and play it back from there. Alas, MuseScore writes a bunch of Program Change information at the beginning of the MIDI file that resets every carefully-selected patch on the M-OC1. Not to worry; surely the Internet can tell me how to delete those in Ardour. Alas, an hour gone by and no such occurrence.

Sooooo … I’ll do the playback from the 1986 Yamaha QX5 hardware sequencer. It has 8 tracks and each track can hold (mix down) multiple MIDI channels’ data which can be broken back out (extracted) if needed … so record the parts into track 1 and mix down to track 2.

The typical M-OC1 operating mode is one MIDI channel per Part — channel 1 for Part / instrument 1, channel 2 for Part / instrument 2, etc.. However …

Dynamic (volume) changes will be stored/edited in the QX5. But for the pedal tone instrument group, all the instruments will be playing the same notes and all the instruments will have a constant mix — I won’t be swelling one up above the others.

So why record the same part and duplicate exactly the same notes and dynamics into multiple channels? Instead, I glumped all of the pedal tone Parts / instruments onto MIDI channel 1 (I configured the M-OC1 with Parts 1-4 on MIDI channel 1), put timpani (Part 5) for timpani alone on MIDI channel 2, and glumped the pulse Parts / instruments (Parts 6-7) onto MIDI channel 3.

To set the MIDI channel, first hold Part and use the arrows to select the desired Part. Then press Select to enter parameter-edit mode, press it until the LED next to row 2 is lit, and press F1 to select column 1, then use the arrows to set the desired MIDI channel.

Selecting and Blending Instruments

Next was to tediously go through the Parts deciding which Patches (instruments) blend well together. In my case, after sampling for similar attacks (starts of notes) and ambience (echo/reverb, some of which I believe is in the wavetables and some of which can be edited if you know what you’re doing), I ended up with:

• Pedal tone
  • 11 English horn 1
  • 58 Tuba 2
  • 79 Big Bones
  • 221 Chorus Vc
• Timpani
  • 141 Timpani 2
• Pulses
  • 84 Brass Ens 2
  • 177 Strings L-M 2

I wanted the tuba in the tooty low end of its range, so I used the parameter edit (Key Shift — row 2 column 2) to lower it by 12 semitones (an octave).

And then to blend, again parameter edit, this time Level (row 1 column 1) to set the master volume level of each instrument for a nice blend.

Blending instruments

As an exaggerated example to make the point, here the cello starts out dominating the mix and then trims down to take its place in a nice blend.

Recording and Editing

Because I have three independent musical parts (some of which incidentally comprise multiple M-OC1 Parts) — pedal tone, timpani, and pulsing notes — and not enough coordination to play them simultaneously, I recorded them into the Yamaha QX5 MIDI sequencer.

I set it for 4/4 time and recorded the pedal tone into track 1, holding the low E for the first 9 1/2 measures, then F and D for a beat each, E for a measure and a half, etc. After recording, I entered Measure Edit, selected all measures, and quantized to eighth notes because I’m not used to recording one part at a time; and let’s face it, I’m sloppy.

I then had the notes recorded and edited to the desired timing for the first part, but with no dynamics. In Measure Edit, I selected all measures, subtracted Velocity down to the minimum, added a crescendo over the first four measures (these M-OC1 instruments respond to velocity changes mid-note; not all would), then added Velocity to measures 5-19 to bring it up to the finishing level of the crescendo.

With the first part ready in track 1 (recorded and playing back on MIDI channel 1), I “mixed down” track 1 to track 2.

I then played back track 2 (containing the pedal tone on channel 1) while recording the timpani part into track 1 on channel 2. Again quantize, drop Velocity to minimum, add crescendo to measures 5-8, add Velocity to remaining measures, and mix down to track 2.

Lastly, play back track 2 (containing pedal tone on channel 1 and timpani on channel 2) while recording the pulse instruments into track 1 on channel 3. Quantize, drop Velocity, crescendo, add Velocity, mix down to track 2.

Then to perform, play back track 2 and record the audio into Audacity. All of the notes and dynamics are automated; nothing to touch. It’s a matter of “rendering” from MIDI to audio.

Applying This Method More Broadly

“Wait, wait, wait!” I hear you cry. “This is the same as recording multiple takes! You could do this with any synthesizer!”

Well, certainly! I mean, it’s not the same as recording in multiple takes. That requires either a digital audio workstation (DAW) that can play back MIDI (Audacity can’t and I haven’t learned Ardour yet) while recording the resulting audio or playing the later takes while listening to the click track or to earlier takes; and it requires either latency correction (playback isn’t quite instantaneous and A/D recording is surprisingly far from instantaneous) or playing all of the parts to the click track without hearing the earlier ones. But yes, I could absolutely record multiple takes using the same synthesizer. I plan to.

“Or,” you cry, “you could play back the MIDI sequencer through multiple regular synthesizers!”

Yes, again, yes. Might do that as well.

But the point here is to explore the technique of using multiple instruments to accomplish the drone + pulsing effect and the capability of performing or “performing” those multiple instruments in a single take using the M-OC1, which makes it so easy.

Features:

• Monophonic — plays only one note at a time — or paraphonic (can split the two oscillators to separate notes)
• Monaural — one-channel audio output
• 2 voltage-controlled oscillators (VCOs) — sine, triangle, sawtooth, square, or PWM — pitch is controlled by voltage and I don’t find it particularly stable
• patch bay that can patch almost any signal to the control input of almost any other signal
• 1 low-frequency oscillator (LFO) — sine, triangle, sawtooth, square — that’s hardwired to modulate VCF (and maybe more things I’m overlooking) and can be patched to modulate anything
• 2 ADSR envelope generators that are hardwired to modulate amplitude and VCF and can be patched to modulate anything
• Velocity received; can be configured to control VCF and can be patched to modulate anything
• Numerous other features that I won’t use and one that I’ll describe when I do

Let’s get programming.

Make it Make Sound

Like the JX-8P, the Neutron has fewer controls than the Odyssey that mysteriously make it not make any sound, but for a good start:

• VCF Frequency to maximum (otherwise you’re low-pass filtering with a very low cutoff)
• Output Volume to mid (whether you’re using line out or headphones), because that’s the master gain
• Overdrive Tone to center and Level to mid, because that’s the other master gain
• Not necessary for making sound, but start with OverDrive Drive at minimum (because it’s a really aggressive preamplifier)
• Envelope 1 ADSR to about 9:00 – 2:00 – 9:00 – 2:00

Oscillators

In the Oscillator section, turn the Oscillator Mix all the way CCW to hear just OSC1. On the Neutron, the square wave seems a bit too dull, so set OSC1 Shape to sawtooth.

Start by setting its Range to 8 for tuning.

Pressing a key should now play a note. If you’re using headphones, plug them in and carefully dial up the headphone volume. If you’re using a mixer, press a key and dial up the input trim until you’re peaking a little below 0 dB, or dial up until input clipping lights and back down until it doesn’t.

Now tune the synthesizer. Like the Odyssey, it doesn’t have set pitch. And worse than the Odyssey, I don’t find that it holds pitch well at all — I seem to need to retune every 30-60 minutes — but it also doesn’t help that the Tune potentiometers have no resistance whatsoever and are the largest and easiest-to-bump knobs on the whole console.

Play a reference pitch, press that key, and turn OSC1 Tune to tune to that pitch.

Finally (for OSC1 initial configuration), set the Range to 32 for the beginning of a rich dual-oscillator sound. Here’s the resulting audio of the base configuration of OSC1:

OSC1 sample

To add the second oscillator, set Oscillator Mix to about the middle, OSC2 Shape to sawtooth also, OSC2 Range to 16; and then OSC2 Tune to tune it first to match the pitch of OSC1 (an octave higher) and then to slightly detune it down.

OSC2 tuning and detuning

The shimmer from the detuning is enough movement for my taste, so I won’t use LFO to modulate pitch.

Filtering

The Neutron’s sawtooth doesn’t seem as brassy as some of the other synthesizers, but I still want to dull it a bit. Dial back the VCF Frequency until satisfied, then bring up VCF Envelope until a little bit of punchy attack is restored. VCF Envelope uses Envelope 2, which I’ve set to minimum, 9:00, minimum, minimum.

Bringing down VCF to filter harmonics and bringing up VCF Envelope to restore some harmonics on attack

In my case, both the VCF Frequency and the VCF Envelope ended up around the 1:00 positions.

Envelope

Adjust the attack and decay to make softer “wuh” pulses, in my case with attack to about 1:20 and decay still at 2:00:

Softening the attack as much as possible for eighth-note pulsing

Crescendo the Pulses Only

The reason for this entire series is that I want to fade in a long note and then have pulses barely audible above that note with the pulses increasing in volume until they dominate and break to eighth notes.

Like the Odyssey, the Neutron has a VCA Bias control that brings up the minimum amplitude, with the attack-decay envelope added on top:

VCA Bias sets minimum amplitude

But with no other changes, the pulses are a fixed amplitude above that, not controlled for fading in. And here’s where the modular synth really shines.

Internally, Envelope 1 is generating control voltages to feed to the Voltage-Controlled Amplifier to set the amplitude at different moments in the lifespan of a single note. (And VCA Bias sets a base voltage that keeps the note playing forever.)

The modular synth allows us to break the chain between Envelope 1 and the VCA and route the envelope’s output control voltage to a variable attenuator before sending the sum of VCA Bias and (attenuated) Envelope 1 to the VCA. That finally lets us directly set the amount that the pulses peak above the drone.

To prepare the attenuated envelope:

1. Turn Envelope 1 Sustain to minimum, because we only need to provide the pulses and not any ongoing amplitude.
2. On the right, patch Envelope 1 Out to Attenuator 1 In, to prepare to control the amplitude of the pulses themselves.
3. Patch Attenuator 1 Out (not 2 as shown in the photo :-/ ) to VCA Control Voltage In, to add the variable-amplitude pulses back onto the Bias drone level to generate the final amplitude.
4. Set Attenuator 1 to minimum.
5. Bring up Envelope 1 Release to 12:00 to finish a soft decay if I release keys before the attack-decay cycle finishes.

And then to perform:

1. Make sure the last note I played was the low E.
2. Start recording.
3. Fade up the VCA Bias to a mp level, about 1:00.
4. Start playing quarter-note pulses on the E, completely inaudible.
5. Fade up Attenuator 1. The attack-decay peaks start being audible above the drone level of the VCA Bias. Continue fading up until they’re distinctly audible.
6. Switch to the eighth-note pattern, clearly audible above the drone.
7. Stop on an E.
8. Fade the VCA Bias back out.

Final recording with envelope attenuated and added to VCA Bias

As with the Odyssey, this was all performed with two hands, one on the MIDI keyboard and one moving VCA Bias and then Attenuator 1.

It’s very satisfying to be able to set the drone level with VCA Bias and then control the pulse amplitude (which is added to the drone level) with Attenuator 1 rather than (on the Odyssey) using VCA Gain to set a minimum amplitude and bringing up the regular gain until the pulses peek / peak above the drone. I really appreciate the direct control over the variable I want to control rather than the indirect control that happens to accomplish the same result.

So on to the Roland JX-8P, my first and most sentimental synthesizer. Ken Janzen (the younger Ken Janzen) was a music whiz who’d occasionally bring his JX-8P (and sometimes sequencer) to church for special music during my formative years. Then in college I got access to another JX-8P thanks to the forward-thinking Don Kehrberg, which I ended up buying from the college a few years later. This one is my third — that is, I have three now — just picked up for a good price on Marketplace and noting some glitchy contacts that will require attention sooner or later. I love this synthesizer obviously for the nostalgia but also for the fat sounds it makes with detuned oscillators, a little bark from the VCF, and what I find to be a particularly lush chorus.

Features:

• 6-voice polyphony
• Stereo audio output
• 2 digitally-controlled oscillators (DCOs) — sawtooth, PWM, square, or triangle — pitch is controlled digitally and is as solid as you want it to be
• 1 low-frequency oscillator (LFO) — sine, square, or random — that can modulate pitch, PWM, and VCF (not amplitude)
• 2 ADSR envelope generators that can modulate pitch, PWM, VCF, and amplitude
• Velocity-sensing keys and performance
• Onboard chorus

Let’s get programming.

Make it Make Sound

The JX-8P has fewer controls that make it mysteriously silent than does the Odyssey, but for good measure:

• VCF Frequency to maximum (otherwise you’re low-pass filtering with a very low cutoff)
• HPF Cutoff Frequency to 0 (otherwise you’re high-pass filtering with a very high cutoff)
• Voltage Controlled Amplifier to mid (because that’s the master gain)
• Volume to mid

Note that I have the PG-800 physical control panel for programming sounds. Without it, I’d use the membrane keypad to select parameters and the edit slider to change their values … and then I’d have to use an outboard MIDI controller for the performance, as you’ll see in a bit.

Oscillators

The first stages of setup are very similar on most synthesizers, so this should initially look familiar.

Set DCO1 to a square wave and (due to the range of the keyboard) to the 16′ voicing. In the mixer section, set DCO1 mix to max. Set envelope 2 ADSR to about 3-3-5-3. You get something about like this:

VCO1 sample

To add the second oscillator, set DCO2 to a square wave and — for a more interesting sound on this synthesizer — to the 8′ voicing. In the mixer, set DCO2 mix to max. I don’t actually like this synthesizer’s sound detuning an octave apart, so leave the tuning aligned.

VCO2 sample — Sounds less dull with both oscillators.

Because I’m not using detuning here for “movement,” I’d like to add the LFO for slow amplitude modulation … but the JX-8P doesn’t route the LFO to VCA! And I don’t love the sound of pitch-modulated octaves on this synth, so we’ll leave out LFO vibrato and move on.

Filtering

The sound right now is pretty brassy or twangy and I want a dull sound. That’s changed by lowering the cutoff frequency of the low-pass VCF, which we set at maximum to get started.

VCF sample 1 — Bringing the cutoff frequency down to about 7 is fairly dull.

I need a little more life in the sound and — unlike my thoughts on the Odyssey — for this sound on the JX-8P, I like a little bit of envelope in the VCF. Set Envelope 1 ADSR to 0-3-0-0 and VCF Envelope to about 7 or 8.

VCF sample 2 — Adding a touch of brass to the pulse.

And finally, since we don’t have a sense of movement from detuning the oscillators, I’ll add a bit here with LFO on the VCF. LFO Waveform to Sine, LFO Rate to about 4, VCF LFO to 2 … and then because I don’t want that flanging effect happening on shorter notes, add LFO Delay of about 5 to make it wait to bring the LFO into the VCF until a note has been held for a little while.

VCF sample 3 — Adding movement with VCF LFO.

Envelope

Like the Odyssey, the JX-8P starts the ADSR’s Release step immediately even if you release the key before the attack-decay cycle has finished, so we need to be careful that the attack-decay cycle finishes in slightly less than an eighth note.

I’ll bring up the Release for a longer decay to hold through the gap between keypresses on repeated pulses and — because I’m playing scale notes that are discordant with each other — that gives me a muddy mess!

Release sample — Notes overlap unpleasantly.

To fix that, I’m going to change the JX-8P’s Key Mode from polyphonic to “Solo” (monophonic).

Solo key mode sample — Distinct notes again.

With that taken care of, I can now set the attack-decay rates.

Attack-decay sample — Started at 5; down to 3; back up to about 3.5 for softer pulses at my planned tempo.

Chorus

Still very blah; but the JX-8P has a nice chorus effect built in.

Chorus sample — No chorus; chorus 1; chorus 2.

Now it’s getting interesting!

Crescendo the Pulses Only

Holding a pedal tone and adding pulses of increasing amplitude on top of it has the same problem as the Odyssey — the attack always goes to maximum amplitude, so we can’t (directly) change the amplitude of the attack.

What we can do is lower the Sustain level, which increases the delta of the attack amplitude above sustain amplitude. We can then push up the VCA Level to compensate for the lower sustain level. I’m not smoov enough to crossfade the sustain and VCA level with one hand, so it’s time to let Mr. Yamaha QX8 MIDI sequencer play the score for me and I’ll just do the volume automation.

Final performance — Crossfading from Sustain to VCA Level.

There’s the whole deal:

1. Set VCA to minimum.
2. Set Envelope 2 Sustain to maximum so the attacks are barely perceptible above it (the opposite setting of the Odyssey’s method).
3. Start recording.
4. Start sequencer playback (’cause I can’t do it alone).
5. Fade up the VCA Gain to a mp level.
6. Sequencer starts playing quarter-note pulses on the E, barely audible (and audible mostly because of Envelope 1 on the VCF tone rather than Envelope 2 on the VCA volume).
7. Fade down the Sustain to increase the amplitude of Attack above Sustain and fade up VCA Level to (try to) keep sustain level constant. Continue crossfading Sustain to VCA Level until the pulses are as distinct as desired.
8. Stop on an E.
9. The Release fades the E back out.

All of the effects were performed in the synth (no post-processing) with only two hands — one moving VCA Level and one moving Sustain — plus the sequencer taking the place of a third hand.

Note that although I did the crossfade using the outboard programmer, I think you could accomplish the same thing without it by using the master volume control in place of VCA Level and by preselecting Envelope 2 Sustain in the editor, then using the Edit fader to crossfade against volume.

And adding more gear, you could use an outboard MIDI expression control run into a Midihub, translating the CC messages into SysEx to reprogram the parameters in realtime, which offers the advantage of crossfading using a single hand but the disadvantage of requiring yet more extra gear. You’d also have to figure out the crossfading curves to balance the nonlinear response of a portion of VCA Level against the different nonlinear response of a different portion of Sustain.

None of that is to say it couldn’t be done — the point of this series is to show the relative ease and different methods on different synthesizers, with some having easy ways to do it, some having tricksy ways to do it, and some only being able to get close. For something that otherwise couldn’t be accomplished, I’ll cheerfully take tricksy.

Features:

• Monophonic — plays only one note at a time — or paraphonic (can split the two oscillators to separate notes)
• Monaural — one-channel audio output
• 2 voltage-controlled oscillators (VCOs) — PWM or sawtooth — pitch is controlled by voltage and is … variable
• 1 low-frequency oscillator (LFO) — square or sine — that can modulate pitch, PWM, VCF, and amplitude
• 2 envelope generators — AR and ADSR — that can modulate pitch, PWM, VCF, and amplitude
• On the Behringer replica, velocity-sensing keys but no incorporation of the velocity in the Odyssey’s audio; for MIDI transmission only
• Numerous other features that I won’t use and one that I’ll describe when I do

Let’s get programming.

Make it Make Sound

There are some controls that will make the Odyssey mystifyingly not make any sound. First off, set those to make sound:

• VCF Frequency to maximum (otherwise you’re low-pass filtering with a very low cutoff)
• HPF Cutoff Frequency to minimum (otherwise you’re high-pass filtering with a very high cutoff)
• Voltage Controlled Amplifier fairly high (because that’s the master gain)
• Not necessary for making sound, but start with [Over]Drive switched off
• The switches at the bottom of the ADSR section to Keyboard Gate (up), Keyboard Repeat (up), and AR Keyboard Gate (up).

Oscillators

In the Audio Mixer section, set the VCO1 level to maximum and (for now) VCOC2 level to minimum. I want a fairly dull sound, so below the VCO1 fader, set the waveform to square.

I’m making a low sound, so on the left, set the Transpose switch to 2 octaves down.

Set the VCA envelope switch to ADSR. Set the attack and decay faders halfway between the lowest two marks, sustain to the midpoint, and release a little above the midpoint.

Pressing a key should now play a note. If you’re using headphones, plug them in and carefully dial up the headphone volume. If you’re using a mixer, press a key and dial up the input trim until you’re peaking a little below 0 dB, or dial up until input clipping lights and back down until it doesn’t.

Now tune the synthesizer! The Odyssey doesn’t do “A makes 440 Hz” — it does “A makes some voltage that makes some pitch.” It’s up to you to tune it so that the keys match the tuning system your other instruments are in.

Pick something that generates a reference pitch (I use an online pitch generator and 440 Hz) and hold the key that generates what should be that pitch. Center the VCO1 coarse and fine frequency faders, then adjust the coarse until the Odyssey matches the reference pitch as closely as possible and fine-tune with the fine fader if necessary.

Finally (for VCO1 initial configuration), set all of the VCO1 lower faders to minimum. Here’s the resulting audio of the base configuration of VCO1:

VCO1 sample

I don’t have an audio player set up in WordPress, so you’ll need to click that link and may want to open it in a new tab.

Not very inspiring yet! Let’s add the other oscillator. In the Audio Mixer, set the VCO2 level all the way up and also set VCO2 to the square wave. In the VCO2 Frequency section, use the coarse and fine knobs to tune VCO2 to the same pitch as VCO1 … and then slightly detune them. The overall output amplitude has increased, so back down the VCA fader or your input trim until you’re not clipping again.

VCO2 sample — Much more interesting already with two oscillators detuned, even apart from my playing faster.

It would be common at this point to add LFO to the oscillator frequency (pitch) for vibrato; but the rich sound of the detuned oscillators is already enough sense of “movement” for the effect I’m building, so I’ll stop there.

Filtering

The sound right now is pretty brassy or twangy and I want a dull sound. That’s changed by lowering the cutoff frequency of the low-pass VCF, which we set at maximum to get started.

VCF sample 1 — Bringing the cutoff frequency down to the 75% mark is quite dull or distant.

VCF sample 2 — Opening the cutoff frequency back up a little above the 3rd mark to about 80% of the fader range puts a little more life back into it without being as brassy as it was originally.

It would be common at this point to add envelope to the VCF to make each note sound brighter on the initial pulse — and even resonance to make each note chirp when played — but I’m going for a dull sound and I don’t want a brighter initial attack.

Envelope

“Envelope” is the term for how the amplitude (loudness) of the sound varies over the course of one note and it’s built here using

1. Attack — how quickly the sound hits its maximum volume
2. Decay — how quickly the sound fades back from its maximum volume while the note is still being held
3. Sustain — how far the sound fades back while the note is still being held
4. Release — how quickly the sound dies off once the note is released

Not only do these change the qualitative experience of the sound — a very sharp percussive sound like a plucked string or piano hammer versus a softer start like legato strings — but they can even impact the ability to perform a musical section at all, if the attack and decay are slower than the pulse of the music. Which in my case, I think they are, for the eighth notes at the end. That is to say, I think the attach-decay cycle takes longer than my eighth notes.

Adjusting the attack and decay to the right speed is … interesting … because this synth (and at least one other) moves to the release from the current amplitude if the attack and decay haven’t finished yet.

The attack always goes to full amplitude and then the note would normally decay to the lower sustain level. When releasing a key, you then expect to hear it die off from that lower sustain level. But on this synth, if you release a key before the attack-decay cycle finishes, the note dies off from however loud it happened to be in the attack-decay cycle.

This has the counterintuitive effect that holding each key ensures that it’s quiet and releasing it quickly makes it loud! This in turn requires an organist’s degree of keyboard discipline (that I don’t quite have) rather than merely a pianist’s (that I barely have after so long away).

Early key release sample — The first time through, holding each key long enough to get through the attack-decay; the second time through, playing each note staccato and therefore starting each release from a higher starting amplitude than the sustain level, which makes the release quite loud.

It’s not common in my experience to have a synthesizer’s attack and decay set slow for a fast pulse, so this is rarely an issue. But because I want the pulses to be slow “wuh” sounds even on the eighth notes, I have to use a slower-than-typical attack and decay and therefore I have to be careful with my keyboard articulation.

With that discovery out of the way, now adjust the attack and decay to where I need them for my sound:

Adjusting attack and decay sample — Tempo dictated by the full attack-decay cycle, shortening until I can play eighth-note pulses.

Crescendo the Pulses Only

The reason for this entire series is that I want to fade in a long note and then have pulses barely audible above that note with the pulses increasing in volume until they dominate and break to eighth notes. But I’ve already said that the attack always goes to full amplitude; and the attack-decay is what makes the pulses; so how can we make the amplitude of the pulses slowly increase?

Here’s where the Odyssey’s (exceedingly rare for a fixed-architecture [non-modular] synthesizer) VCA Gain comes to the rescue. In spite of its name that suggests it might be a gain multiplier, it’s a VCA bias or minimum. It sets a minimum level for the VCA, whereas the VCA (master) control is a multiplier for what the envelope is doing that is (as far as I can tell) superimposed over (not added to) the VCA Gain.

The VCA Gain, by the way, makes the Odyssey hold the last-played note forever. So …

VCA Gain sample

There’s the whole deal:

1. Make sure the last note I played was the low E.
2. Set VCA and VCA Gain to minimum.
3. Set Sustain to a minimum so the sustain level doesn’t add to the VCA Gain drone level.
4. Start recording.
5. Fade up the VCA Gain to a mp level.
6. Start playing quarter-note pulses on the E, completely inaudible.
7. Fade up the VCA. The attack-decay peaks start being audible above the drone level of the VCA Gain. Continue fading up until they’re distinctly audible.
8. Switch to the eighth-note pattern, clearly audible above the drone.
9. Stop on an E.
10. Fade the VCA Gain back out.

All performed in the synth (no post-processing) with only two hands — one on the keyboard, one moving VCA Gain and then VCA.

I think for a refinement, I might try to pre-position the VCA at the point that the pulses are barely audible so that those of us who feel 4/4 in our heads are aligned correctly with the measures all along instead of not being sure where the count is when the pulses start. (This could also be handled by making the first pulse of each measure louder; but without velocity-responsive sound generation, that would require considerably more finesse on the VCA fader.) Also the VCA does increase the amplitude of the drone during part of the range of its movement — a weird interaction that creates an imperfect result, since I said I wanted the level under the pulses to stay the same throughout.

You’ll be thinking of other ways to get close to or accomplish the same effect … and I’ll get to those methods when I get to other synthesizers. My goal is not to demonstrate every method that each synthesizer could use, but the best or easiest method that makes a given synthesizer shine (or unshine) at a given task.

Well, they do different things.

I do have some synthesizers that only have built-in sounds; but the ones that speak to me the most are the ones where you build the sounds yourself. I’ve been thinking about a particular sound and how it would be made differently (and to different degrees of success) on different synthesizers and thought I’d demo that process on a representative sample of each underlying architecture.

Traditional musical notation doesn’t have a clear way to capture exactly what I have in mind, so let me walk you through it: A low E is gradually faded in; then imperceptibly at first it starts getting pulses on the quarter notes, with the underlying sound held constant between the pulses as only the pulses grow louder; then the pulses speed up to eighth notes and the pitch starts changing in a repeating pattern. The measure and repeat counts are arbitrary and selected here mainly to have room to write the notations.

Further and not notated, I want the held note to be a fairly dull sound and I want the pulses to be “w-w-w” and eventually “wuh-wuh-wuh” sounds — not sharp; also dull.

What’s going to be difficult about programming synthesizers to do this is increasing the dynamic (amplitude) of only the pulses while holding the drone at a constant amplitude. Only one that I have lined up can actually do it natively and I believe only other other can do it with coaxing.

MuseScore

As a side note for the curious, that score clip is engraved using MuseScore, the zero-cost open-source music notation software. I have a fair amount of sheet music I notated years ago in commercial music notation software that went out of business and now I can’t open it and I didn’t have the foresight to export to PDF; so where I’m lucky, I still have a hardcopy I can find and where I’m unlucky, it’s locked away and I don’t expect to be able to get it back.

From time to time I’d look for an open-source replacement and kept finding MuseScore but never did anything with that information until earlier this year, when I needed to do more music notation, installed it, and love it. It’s fairly easy to use; it does gorgeous typesetting; and it gives you control over every tiny little detail of the typesetting.

If you’re looking to try it, I highly recommend keeping it open in one window and Gemini open in another. When you want to do something, just ask Gemini how. It’s infinitely patient and often correct. Very good for instructions on basic operations; nearly useless for deep menu diving for fine-tuning typesetting.

The LCD I bought is a Waveshare 2.0″ LCD using an ST7789V driver chip, a variant of a popular (the popular?) LCD driver.

Wiring

The first puzzle was how to wire the LCD to the ESP32.

Different ESP32 module manufacturers provide different module pin counts and I suspect (though haven’t verified) different pinouts for the same pin counts; so I’m specifically referencing the pinouts for the module I’m using.

I found a couple of forum posts — unfortunately didn’t save the links — indicating that the LCD can run on 5V or 3.3V power and that it gets grumpy if the data lines are at a different voltage than its power. This is easily handled — power the LCD from the ESP32′s 3.3V regulator. So first wire the power connections:

Next, the LCD uses SPI, so wire the data and clock lines. The ESP32 has labeled pins for these so I used them; though I saw a forum post that the ESP32′s hardware SPI can be matrixed to any digital I/O pin, so it’s possible that these could be reassigned elsewhere.

Then three LCD pins can be wired to any available I/O, so I picked pins near the others I was already using:

And finally the backlight enable pin, which the schematic shows is pulled high / active so is superfluous unless you want to blank or PWM the backlight:

Arduino Libraries

Waveshare provides their own ST7789 and LCD graphics libraries but I overlooked those, so for what seemed like expedience I loaded the Adafruit ST77* library and Adafruit GFX library.

I could not find, in the documentation or tutorials, the syntax for some fundamentals — to wit, I didn’t find documentation stating the syntax to instantiate a display object, nor documentation of (the correct) syntax to initialize the display object. (I ran across what in retrospect incidentally sort of demonstrated these; but I would like documentation to expressly tell me how to use what I’m trying to use.)

The libraries come with example code and by examining Examples from Custom Libraries / Adafruit ST7735 and ST7789 Library / graphicstest_st7789, and with the help of a forum post, I was able first to get the graphics demo to run on my display and second to write my own code.

The library needs to know where things got wired up:

#define TFT_CS (1) // yellow wire
#define TFT_RST (21) // brown wire
#define TFT_DC (3) // blue wire


Then to be initialized with the right dimensions for this LCD:

// OR use this initializer (uncomment) if using a 2.0" 320x240 TFT:
tft.init(240, 320); // Init ST7789 320x240


And then the demo works.

My Demo

Putting it all together into my own test:

#include <Adafruit_GFX.h>
#include <Adafruit_ST7789.h>

void loop() {
}


This should be regarded as irritating rather than intractable. I present here two workarounds and leave the discovery of more as an exercise for the reader.

Option 1, remove one power-strip row from a modular breadboard and dovetail-pin that breadboard onto another. Install the ESP module over the new “power gutter” and revel in the luxury of plenty of rows for connecting jumpers.

Option 2, SAW THROUGH THAT and revel in the luxury of plenty of rows for connecting jumpers.

Footnote: Use a hacksaw. Its finer teeth cut without snagging like a wood-cutting saw’s teeth would do; I don’t want to contemplate the kind of workholding it would take for me to feel safe using a tablesaw or circular saw on this; and you would be so startled the moment a wood-cutting bandsaw’s teeth first engage in the edge of the plastic and the blade leaps toward you.

My refresher on the basics came from https://samueladesola.medium.com/how-to-set-up-esp32-wroom-32-b2100060470c, although he had to go through some steps I didn’t and vice-versa.

First, go to File / Preferences / Additional boards manager URLs and add
https://dl.espressif.com/dl/package_esp32_index.json to indicate another repository to search for board definitions.

Then Tools / Board / Boards Manager... to pick an available board bundle, start typing esp32, and click to install esp32 by Espressif Systems .

I’m installing this on my Linux workstation so I had to give myself permission to access the USB port, which was:

sudo usermod -aG dialout neufeld

To make that group change take effect, I was only supposed to need to logout; but doing so added me to the entry in /etc/group but didn’t activate the group membership when I ran id or tried to access the device file. I had an OS update to apply anyway so I rebooted and all was well.

Back in the Arduino IDE, Select Other Board and Port, start typing esp32 dev into the board search, and pick ESP32 Dev Module when it popped up.

Weirdly, even with the USB serial port selected (and accessible), it complains that no boards were found — but it works.

Finally, File / Examples / 01.Basics / Blink to make sure I can compile and upload code to the correct board.

Blink relies on an LED_BUILTIN macro that’s not defined in this Espressif board spec. This forum post suggested pin 2 for the built-in LED on this board and adding

#define LED_BUILTIN (2)

did the trick. Compile, upload, and I have a blinking blue LED next to the red power LED.

RL

AAA = (BBB, CCC)
BBB = (DDD, EEE)
CCC = (ZZZ, GGG)
DDD = (DDD, DDD)
EEE = (EEE, EEE)
GGG = (GGG, GGG)
ZZZ = (ZZZ, ZZZ)


All one need do is make a hash of the nodes with their branches, then dance through it.

my %index = ( L => 0, R => 1 );

The dance moves are specified as L or R and for no particular reason I decided to save the branches as arrays instead of hashes, so I prepare to translate dance moves into array indices. Why on earth did I call this %index instead of %dirindex or %dir? Because I had just woken up and it was time to do AoC? Probably.

$_ = <>; chomp;
my @instr = map { $index{$_} } split(//);

<>;


I grab the dance moves, translate them from directions to indices, and toss the following blank line.

my %map;
while (<>) {
my ($node, $l, $r) = /(\w{3})/g;
$map{$node} = [ $l, $r ];
}


Then read in and save all the nodes.

my $count = 0;
my $pos = "AAA";

until ($count % @instr == 0 && $pos eq "ZZZ") {
$pos = $map{$pos}[$instr[$count++ % @instr]];
}


Finally, start at AAA; take steps, counting as I go (and using the modulus of the number of dance moves in the pattern); and stop at ZZZ only if it's the end of this dance pattern.

Full Program

#!/usr/bin/perl

print "$count steps\n";


my $cardlist = "AKQT98765432J";

Change the card sort order;

my $jokers = grep { $_ eq "J" } @cards;

count the jokers;

++ $tally{$_} foreach grep { $_ ne "J" } @cards;

omit the jokers when counting cards for type of hand;

$ofakind[0] += $jokers;

and in this poker variant, simply add the count of jokers to the count of the most-frequent card when determining type of hand.

Full Program

#!/usr/bin/perl

sub cardval {
my $c = shift;
my $cardlist = "AKQT98765432J";
return length($cardlist) - index($cardlist, $c);
}