Passencore: chord ornament, music-theory crime.

sixolet · 2021-06-13T06:46:13.164Z

Passencore

Turn an LFOs into a chord progression? Harmonize a bass line that doesn’t just play roots, with an eye to functional harmony and keeping voices within a range? Just want something in the lines library category for a platform not yet represented?

(this clip is my test patch right now, rather than an attempt at a “piece of music” so it’s nothing special, but maybe it gives an idea)

Patch notes: Pam’s triangle LFO into Passencore tension input, TR1 set to “sample” and “passing” and TR2 set to “target”, both from Pam’s at different times. Passencore 4x CV into Stages configured as a sequential switch into rings 4x polyphonic to make chords

Passencore is an Ornament & Crime app that replaces Meta-Q in an alternate firmware. It’s a chord sequencer without the sequence, where you don’t (have to) pick the chords. Instead, you patch in an LFO or two and some triggers for when you want it to pick a new chord. One of your trigger options is for a “passing chord”, to lead you from whatever chord you’re playing now to your target chord. I have imbued it with just enough music theory to be dangerous, because that’s how much music theory I know. It knows:

basic voice leading, but dgaf about parallel fifths because idgaf about parallel fifths
functional harmony, ish, with the ability to substitute chords
dominants are pretty cool
sus chords are even cooler

The inspiration is somewhere between Acid Curds (for the s&h chord workflow), MI Grids (for how it’s repeatable, but not exactly predictable), and some kind of “synf-onion” that I have only heard about but never seen.

Requirements

Ornament & Crime, Teensy bootloader, uUSB cable, willingness to try something new.

Documentation

Installation

Follow the Ornament & Crime firmware installation instructions with the firmware linked below.

Basic use

Patch a slow 0to5v LFO of some kind to CV1. This is “tension”.

Scroll down in the settings to make sure “sample trigger” and “target trigger” are both set to TR1 (that’s the default I set, but I’m somewhat new to o_C development, and sometimes I find my defaults set wrong, so ymmv.) Anyway, patch a trigger to TR1 that goes more than once per cycle of your LFO. Tune some oscillators to each other, and give all four outputs to them, or maybe give them to one oscillator with a sequential switch.

Your fancy trigger inputs

All assignable, so you can duplicate “sample” and “target” or “sample” and “passing” or whatever.

sample: Read the values of tension and color and whatever other constraints and pick the next target chord based on them. Don’t necessarily play it yet, but do play it yet if target is also triggered.
target: Play the target chord.
passing: Play a passing chord to get to the target chord. If you’re already at the target chord, play a passing chord to get back there anyway. The algorithm currently likes sus chords and secondary dominants, but chromatic or stepwise passing chords are also possible.
reset: Pick the next target chord with a root voicing. Useful for if you find yourself with a pattern that kind of wanders around based on the voice leading rules without repeating in as short a time as you like. Since the algorithm is deterministic (even if it’s complicated) reset can be a forced repetition point.

Your trusty CV inputs

CV1 tension, roughly equivalent to “function” in functional harmony. Goes from 0v is roughly “tonic”, 5v is roughly “dominant”, and intermediate voltages do predominants and other chords and stuff.
[include instructions inline, or provide link to external documentation, or attach a PDF/etc.]

CV2 color, roughly equivalent to how consonant the chord is going to be on its own. Goes from “power” (roots and fifths) through “classic” (triads) to “interesting” and “ext/subst” (which start adding in 7th and sus chords, and have weightings that allow for more functional substitutions, ex vi for I or iii for V) to “iono jazz?”. You can set the “base color” in settings, and CV2 adds to that. Default base color is “classic” for triads and the occasional seventh chord.

CV3 & CV4 Assignable. For now options that constrain the target chords we’re picking, but not the passing chords.

-: nuthin’
include: Input a note. It gets quantized to your active scale, and the resulting target chord must include that note.
root: Input a note. It gets quantized to your active scale, and the resulting target chord has that root. Any inversion remains possible.
bass: Input a note. It gets quantized to your active scale, and the resulting target chord has that note in output A.

Other business

Settings for the center of each voice’s range. Controls for octave and half-steps up or down from that.
In certain cases Passencore wants to borrow a chord from another mode — chromatic passing chords and dominants or secondary dominants, usually. Allow or disallow, as you please.

How does it pick chords?

It does a few rounds of “add some chords to a buffer, evaluate them on some criteria, narrow down to just a few”.

Round 1: Add all triads, narrow by function and by required root note
Round 2: Add variations like sus chords, sevenths, and ninths, narrow by function, color, required included note.
Round 3: Add different voicings, narrow by all criteria above plus voice leading rules and required bass notes.

Pick the top-rated chord.

It does something similar for passing chords, but simpler, and populates with secondary dominants, sus chords, and chords rooted in between the notes it’s trying to get between.

Bonus

Passencore works with all the modes of the diatonic scale and the harmonic minor scale; the harmonic minor and its modes are now in the global scale list.

NB I’m not actually that sure how applicable functional harmony is to the ultralocrian or whatever, but whatever my code does with it sounds interesting at least.

Roadmap

Features I want to add:

CV assignments that let you modulate key & scale
Ability to limit chord output to 3 outputs, and reserve one for a melody quantizer channel.
Given a melody quantizer channel, options to let it quantize to the home scale or an “appropriate” pentatonic for the chord.

Download

v0.1
o_c_REV.ino.TEENSY31.hex (689.2 KB)

Github link. Note that the code is on the passencore branch for now.

Mod note: I want to tag this with o_C but that doesn’t seem an option?

desolationjones · 2021-06-17T21:19:21.944Z

Whoa, you’ve made quite the chord brain! Do you know if it would work with my 1U 4ROBOTS VOR O_c? (I think the Variable Output Range part is the important bit there… Dunno how official it is)

sixolet · 2021-06-17T21:26:27.342Z

I think so, source code wise, but the build I uploaded doesn’t have VOR enabled in the OC_options.h file.

Now that work has finally cleared me to officially be allowed to code on this personal project I will post the GitHub link tonight or tomorrow, and you can enable the options you need and do your own build. That goes for other options too, like FLIP_180 etc.

Edit: github now added above.

catkins · 2021-06-18T01:47:14.595Z

Ooh this is very cool! I’d kinda love to port it to Lua for Norns & MIDI/Crow usage.

cosmicsoundexplorer · 2021-06-18T01:48:21.102Z

Would be awesome to add JF and W/synth support too!

sixolet · 2021-06-18T03:22:51.233Z

Oh! Let me know if I can help with a Lua port. I don’t have Crow or Norns, though, sadly, so I am not sure I could test it out.

catkins · 2021-06-18T05:02:07.976Z

I guess the main way would be sharing the source

sixolet · 2021-06-18T05:40:30.346Z

Oh, sorry, I should have been clear. I added the github link to the main post above just before sending that message. So far the code’s a little rough, but not too bad.

catkins · 2021-06-18T06:52:48.657Z

Oh I missed that! Thanks for sharing it

github.com

sixolet/O_C/blob/passencore/software/o_c_REV/APP_PASSENCORE.ino

#include <algorithm>

#include "OC_apps.h"
#include "util/util_settings.h"
#include "util/util_trigger_delay.h"
#include "braids_quantizer.h"
#include "braids_quantizer_scales.h"
#include "OC_menus.h"
#include "OC_scales.h"
#include "OC_scale_edit.h"
#include "OC_strings.h"
#include "OC_chords.h"
#include "OC_chords_edit.h"
#include "OC_input_map.h"
#include "OC_input_maps.h"

#define POSSIBLE_LEN 32

enum PASSENCORE_SETTINGS {
  PASSENCORE_SETTING_SCALE,

This file has been truncated. show original

I’ll have a dig through later in

infinitedigits · 2021-07-11T04:24:12.906Z

don’t have an ornament and crime to try this but I just want to say that this is so brilliant! I am so intrigued by the way you’ve mapped chords and how you go about choosing them. I am studying your implementation and getting ideas. thanks

wayk · 2023-07-25T17:17:39.540Z

Bumping this old thread just to ask if the brains of the chord generation here has ever been ported or adapted to a norns script. I’ve been looking around for music-theory-forward compositional tools and I’m really intrigued by this, but don’t have ornament and crime to be able to play with it.

I have combed through the forum and didn’t see anything like it, but apologies if I missed something!

sixolet · 2023-07-25T17:58:58.606Z

There’s a prototype! I’ll post a link to it here next I fire up the Norns. Warning: it’s a bit rough.

pftjschute · 2023-07-31T16:10:29.494Z

is this a finnegans wake reference???

sixolet · 2023-07-31T16:21:33.434Z

For all your rearriving-from-North-Armorica needs.

pftjschute · 2023-07-31T17:01:03.518Z

uhhhhh holy scamander

mendel · 2023-12-10T18:39:52.610Z

This app rips! It just got merged onto the dev branch of Phazerville, and I’m really enjoying testing it out (getting some immediate and delightfully musical results). Excited to see the roadmap take shape!

One initial question:

How should I be thinking about the effect of the Scale integer parameter? I can see that each increment and decrement impacts the chord structure, but it’s not obvious to me exactly how. If the entire 16-bit space is useful, I think it could be a good idea to borrow the per-digit editable hex UI from TB3PO in Hemispheres (and perhaps the randomize function along with it). Otherwise it’s a real pain to scroll.

sixolet · 2023-12-10T19:24:00.262Z

Whooooa! This was like my first music coding project, I’m so happy it got merged into a live branch of o_c!

To answer your actual question, I’m going to have to re-familiarize myself with the code…

sixolet · 2023-12-10T19:31:53.574Z

It’s the scales that o_c defines globally, like for the quantizers and stuff. Past the first fifteen or so, they start getting pretty esoteric.