This is one of the modules I’ve been working on, the Kosmo sequential switch based on the fonitronik design. (fonitronik modular synth diy)
It is a nice multipurpose utility module for cv or audio routing, apparently any signal up to 12v. It has one input that switches between up to 4 outputs and is reversible (4 in, 1 out), with manual push button and cv controlled reset and “clock.” As well as a switch to select how many switch steps you want to cycle through (2-3-4).
For example, it can sequentially route an audio signal to different effects or filters or route one cv source to multiple modules. Combined with a clock divider and a sequencer (it is sort of a sequencer in itself) you can make more complex rhythms or note timings. I’ve learned this is called ‘ratcheting’ in synth-speak.
I just finished building the first one, it works! Here is a video of the first patch I rigged up. The drums and the master clock come from the Roland TR-8s which is clocking the LMNC 8step and an envelope generator. The 8 step is providing 1v/octave to both oscillators while the envelope goes to the sequential and is switched between the two oscillators, an unfiltered bass and a filtered ‘lead’ oscillator:
It seems to behave pretty well as long as you give it a clean clock source, you can use a lmnc envelope generator on loop with the right settings.
This was the best price I could find for a single chip !!12$!!! and would the most expensive IC I’ve got to date. I found a deal for 10 for 80$ and went ahead and did it. If you guys are interested in the panel/pcb I will pass on the bulk buy savings to you. I have 7 extra sets.
The circuit is already on my Github (/ctorpin). I will upload the faceplates and any final changes if you want to print your own in the next few days. I’ll put together some build notes and a BOM.
I like how that one’s using a very expensive precision switch ($8.84 ea @1ku) designed for very low on resistance and surrounds it with 1k resistors Vishay’s DG412 is about 1/3 the price but still low resistance, and the good old 4066 is still way below 1k and costs almost nothing ($0.10 ea @1ku).
(but surely true Kosmo-style would be using relays? )
EDIT: Ok, the expensive one is guaranteed rail to rail, the 4066 isn’t. Seems the original Doepfer used a raw 4052 ($0.15 ea @1ku) which is an analog mux, not a switch, also with Vpp limitations, but they abandoned that later. Guess adding buffers would take away some of the fun.
Yeah, my sequence build is using analog muxes, 4051’s though. but they are only passing a static voltage for the CV feed. they were cheap enough and get 8 channels.
They used half the circuit for signals, the other half for LEDs.
(if you want rail to rail, you can build buffered mux/demux pairs with 4051/52/66, but I guess at some point you’ll spend more on jack sockets than you’d pay for that fancy precision IC…)
Yeah, they provide a bunch of BOM scripts just about all of which are pretty useless, so I wrote my own. It writes a Markdown format file.
#
# Python script to generate a BOM from a KiCad generic netlist
#
# Sorted and Grouped Markdown BOM with advanced grouping
# same as version from KiCad install but without footprints
#
"""
@package
Generate a Markdown BOM list.
Components are sorted and grouped by value
Fields are (if exist)
Ref, Quantity, Value, Part, Description, Vendor
Command line:
python "pathToFile/bom_group_md.py" "%I" "%O_bom.md"
"""
from __future__ import print_function
# Import the KiCad python helper module and the csv formatter
import kicad_netlist_reader
import sys
import re
# Start with a basic md template
md = """# <!--SOURCE--> BOM
<!--DATE-->
Generated from schematic by <!--TOOL-->
<!--COMPCOUNT-->
<!--TABLEROW-->
"""
def myEqu(self, other):
"""myEqu is a more advanced equivalence function for components which is
used by component grouping. Normal operation is to group components based
on their Value and Footprint.
In this example of a more advanced equivalency operator we also compare the
custom fields Voltage, Tolerance and Manufacturer as well as the assigned
footprint. If these fields are not used in some parts they will simply be
ignored (they will match as both will be empty strings).
"""
result = True
if self.getValue() != other.getValue():
result = False
elif self.getPartName() != other.getPartName():
result = False
elif self.getFootprint() != other.getFootprint():
result = False
elif self.getField("Tolerance") != other.getField("Tolerance"):
result = False
elif self.getField("Manufacturer") != other.getField("Manufacturer"):
result = False
elif self.getField("Voltage") != other.getField("Voltage"):
result = False
return result
# Override the component equivalence operator - it is important to do this
# before loading the netlist, otherwise all components will have the original
# equivalency operator.
kicad_netlist_reader.comp.__eq__ = myEqu
# Generate an instance of a generic netlist, and load the netlist tree from
# <file>.tmp. If the file doesn't exist, execution will stop
net = kicad_netlist_reader.netlist(sys.argv[1])
# Open a file to write to, if the file cannot be opened output to stdout
# instead
try:
f = open(sys.argv[2], 'w')
except IOError:
e = "Can't open output file for writing: " + sys.argv[2]
print(__file__, ":", e, file=sys.stderr)
f = sys.stdout
# Output a set of rows for a header providing general information
s = net.getSource()
r = re.search ("^.*/(.*)\.sch", s);
md = md.replace('<!--SOURCE-->', r.group(1))
md = md.replace('<!--DATE-->', net.getDate())
md = md.replace('<!--TOOL-->', net.getTool())
md = md.replace('<!--COMPCOUNT-->', "**Component Count:** " + \
str(len(net.components)))
row = "| Value | Qty | Part | Description | Vendor |"
md = md.replace('<!--TABLEROW-->', row + "<!--TABLEROW-->")
row = "\n| ----- | --- | ---- | ----------- | ------ |"
md = md.replace('<!--TABLEROW-->', row + "<!--TABLEROW-->")
components = net.getInterestingComponents()
# Get all of the components in groups of matching parts + values
# (see kicad_netlist_reader.py)
grouped = net.groupComponents(components)
# Output all of the component information
for group in grouped:
refs = ""
# Add the reference of every component in the group and keep a reference
# to the component so that the other data can be filled in once per group
for component in group:
if len(refs) > 0:
refs += ", "
refs += component.getRef()
c = component
row = "\n"
row += "| " + refs +" | " + str(len(group))
row += " | " + c.getValue() + " | "
# row += c.getLibName() + ":"
row += c.getDescription() + " | " + c.getField("Vendor")
row += " |"
md = md.replace('<!--TABLEROW-->', row + "<!--TABLEROW-->")
# Print the formatted md to output file
md = md.replace('<!--TABLEROW-->', "")
print(md, file=f)
Do you just put that code in the command line of the “bill of material” window? Or make a new plugin? I don’t think I mentioned how much I appreciated getting the BOM hard copy with your PCBs
Apparently, it does exactly what some other a lot cheaper ICs do except can handle signals as high as the rail voltages on the chip, -12 to 12v in our case
Vishay’s DG412 is about 1/3 the price but still low resistance, and the good old 4066 is still way below 1k and costs almost nothing ($0.10 ea 
)
Doepfer’s (old) schematics are here: