ArdCore - An Arduino-based Compute Device for Modular Synthesizers

As part of my Masters Degree at University of Denver, I (Darwin) have developed a specification for the use of the Arduino microcontroller as a generalized compute device for modular synths. What does that mouthful of words represent? It means that I've developed a module that can perform a multitude of different functions, controlled by Arduino sketches that you (or I) can create.

The purpose of this device is three-fold:

- To allow programming-savvy artists to pursue synthesis options that aren't currently available (either because they are too difficult or too idiosyncratic).

- To allow for temporary-use function that are not often needed (and hence not worth the expense or space) but may be important for a specific composition.

- To provide a simple platform for functions that are much easier to accomplish in the digital domain than in the analog domain.

This page, and our site, will provide a number of different things for interested modular users:

1. A specification for the use of the Arduino in a modular environment.

2. Examples of sketches that can be used for Arduino-based modules that follow the specification.

3. Examples of boards that can use the Arduino in an embedded module.

4. Completed boards and modules (for sale) that implement this specification.

The current specification document can be viewed from this PDF file (which will be constantly updated as new information is made available).

Design Decisions

In order to focus on a single platform for development, we made a few design decisions that drove the development of both the specification and the board we've created:

  1. We would focus on CV generation and manipulation, and limit our explorations of audio output.
  2. We would produce output with 8-bit resolution, and do so by the direct manipulation of digital output pins (one pin per bit).
  3. We would limit both input and output ranges to a 0-5 Volt range. This is the most useful range for control voltages to affect oscillators and filters, and is therefore our main targeted connection.
  4. We would fit the main unit in a single width 5U (MU) space. Additions would be made that would provide enhanced input and output expansion, but the core computational engine could be effectively used in a single MU width.

These four decisions were made for a number of reasons. Part of it is to keep the circuit (and therefore board construction for DIY'ers) very simple. It is also to simplifly the programming of Arduino sketches that would make for useful output. Finally, we want this module to be usable in a lot of different environments (performance, studio, installation), so having a minimal space footprint was very important.

Some may question the use of 8-bit output, but it is a compromise that we ended up appreciating once we saw that a) it made programming very easy, even with low-end Arduino boards, and b) the resolution was sufficient (especially if paired with a slew limiter) for every sort of output we needed. Our test results have been very positive, and the result is used in our systems every day.

NOTE: All sketches can be downloaded from our Github location.

Available Arduino Sketches

01. Ardcore Template

The template serves two purposes: as a starting point for new programmers to understand the ArdCore standard, as a hardware testing application for the module. When an end user chooses to build their own version of the ArdCore module, the template sketch will serve as the reference implementation test, proving that the user’s device is meeting the module specification.

 


02. Note Quantizer

The note quantizer creates in-tune notes out of arbitrary voltages. It can be used to scale a sequence into tune, or to take random notes and make them melodic. Since quantizers are often very expensive (and inflexible with regards to available scales), the quantizer is expected to be one of the more inspiring modules for new users of the platform.

 

 


03. Drunken Walk Generator

The drunken walk (or random walk) algorithm is one of the most often used random functions in computer music. However, a drunken walk (band-limited randomization) is very difficult to accomplish in the analog domain, but is quite simple to create digitally. This sketch will produce a drunken walk at full 8-bit resolution, providing a useful option for non-pitched modulation.

AC03-DrunkenWalk by DarwinGrosse

This audio example shows the DrunkenWalk sketch running a resonant filter over the top of a typical FM oscillator patch. If you listen to the whistle of the resonance, you will hear the DrunkenWalk in action.


 

 

04. Drunken Note Generator

Similar to the sketch 3, the drunken note generator implements a drunken walk. However, in this case, the outpu is quantized to standard notes, providing melodic output useful for driving oscillators.


 

 


05. Clock Divider

Clock manipulation is an often-used function with modular synthesizers. The clock divider allows you to create more complex rhythms by using subdivisions of a beat. When the clock divider is given incoming clock signals, it produces output of a sub-divided number of clock pulses.

AC05 Clock Divider Example by DarwinGrosse

This example track shows two oscillators whose volume envelopes are controlled from a  clock divider driven from a central clock. You can hear that rhythms, variations and breaks are all part of what this sketch can do.

 


06. Trigger-to-Gate Converter

Many modules produce triggers – a very fast blip of voltage. These are useful for clocking application, but envelope generators often need to see a “gate”: a voltage change that has a hold time. Given input of a short trigger, the trigger-to-gate converter produces a complete gate cycle based on user settings and/or voltage control.


 


07. 8-Step Sequencer

Sequencing is a favorite tool in modular production. This sketch performs a sequence by recording eight discrete steps, then perform playback of these steps when clocked by an external trigger.


 


08. Gate Delay


In order to get interesting melodies from a modular system, many artists will use delayed versions of a melodic line combined with the original. Often this is done using an audio delay device, which produces the well-known echo effect. The gate delay offers a different option: it allows you to delay the gate time of a melody, allowing you to route an alternative melody in time with the original. This sketch allows you to delay a gate based on either manual or voltage control.


09. Trigger Delay

Similar to the gate delay, the trigger delay allows you to delay a trigger based on manual or voltage control. This can be useful for creating complex rhythms, or to drive other clocked modules at alternative timings.


10. Note Delay


Similar to the gate and trigger delays, this sketch assumes that the incoming voltage is a note value that has to be delayed. This is the most useful option for counter-melody production, since it maintains an internal list of note values that it reproduces based on manual or voltage control.

AC06 NoteDelay Example by DarwinGrosse



11. Glissando (w/Gate)


This sketch will extend the transition time between two voltages by a user-selectable amount. This can be used to slide a melody line between notes, or to smooth harsh changes. Both manual and voltage control are supported, and the digital outputs produce a gate outputs that describe the effect’s duration.


12. Comparator


Given a manually set breakpoint, this sketch will provide two gate outputs that represent over and under positions (on digital outputs 0 and 1) relative to the breakpoint.


13. Slope Detector

A slope detector is useful when interfacing with other voltage-producing modules. This sketch will provide gate outputs that show when an incoming control voltage is either moving upward or downward. This can be useful for generative work that requires analysis of an incoming voltage signal.



14. Gate Sequencer

Given a clock input, this sketch will produce 8-bit output that represents a sequence of gate movements. The actual sequence is easily redefined in the code, allowing the user to build percussion track within the code for reproduction in live performance. Unfortunately, this requires the output expander to be useful, since the eight bits of the output are not exposed on the standard ArdCore module.


15. Automatic Switch

The automated switch flips the output between two analog inputs every time a clock pulse is received. For generative situations where there is no external clock, the sketch also provides an internal clocking routine with speed control.


16. Clock Multiplier

Some of the masters of Berlin School synthesis used a particular technique called the “ratchet” in many of their sequences. This effect, as well as others, can be attained using a clock multiplier. The clock multiplier analyzes the incoming clock signal, then calculates subdivisions which allow you to speed up the clocking output. Using the analog inputs, it is possible to defeat the multiplying function, which gives you controllable ratchets.


17. Logic Module

One of the simplest sketches, the Logic Module produces gate outputs based on AND, OR and XOR logic derived from the analog inputs. This can be used for generative sequencing and mixing, or as a simplified multi-way comparator.


18. Variation Generator

The variation generator, specifically created for use with the output expander, uses an internal 8x16 gate sequencer in the sketch. Based on control and voltage settings, individual gate outputs are created for each of the eight output bits. Since the output expander is not yet available, the results of the first two bits are reproduced using the digital outputs.


The code that defines the variations used by this sketch is found at the global section of the program:


 

19. LFO w/Shaping

Although the ArdCore does not have circuitry to create smooth output, creating a low frequency oscillator (LFO) module that produces shaped output provides an alternative to typical analog LFO’s.


20. Stepped Random

The stepped random sketch creates truly random output, but does so with a defined step size. This way, you can force the random output to make large swings in data, or focus on smaller step sizes. This is similar to the drunken walk algorithm, but does not include the band-limiting function of that sketch.


21. Shift Register

A shift register stores a value, and returns it when a clock signal is received. This is useful for creating auto-harmonizing melodies and other generative results. This sketch will store up to 8 values, producing a fifo (first-in, first-out) queue for replication of incoming voltages.


22. Output Standards


The output standards sketch is used to produce standard pitches from the analog output. Using the module’s two knobs, you can produce any note within the 5 octave range of the device.


23. Control Voltage Recorder

One of the stranger sketches, the control voltage recorder will capture a snapshot of an incoming voltage every time that it receives a clock. This voltage is stored in a buffer that can be played back at different rates, with user-controlled loop points. While not exactly a sampler (because it cannot operate at full audio rate), it does allow the capture and playback of arbitrary melodic or modulation lines.


24. Simple VCO

Created more as an exercise than a valuable module, this sketch creates a voltage-controlled oscillator – a VCO. This is the primary sound generation tool in modular system, and is generally thought to be too difficult to implement with an Arduino. This sketch uses some high-speed programming “tricks” to create audio output from simple pin manipulation.


25. Voltage-controlled AD Envelope

A last minute addition to the sketch set, the VC Attack-Decay envelope is another utility module that benefits from the computational core. Creating an envelope from a single trigger, this sketch generates a rise and fall time based on the knob settings – but modified by voltages coming into the analog inputs. This can give any phrase a non-mechanical sound by allowing other modules to alter the rise and fall time.


 

Circuit Diagram for DAC section

You can condition the inputs to the Arduino in many ways; I chose to use a 1K resistor in series to the input, and diodes that sink excess positive and negative voltage to the +5 and GND rails, respectively. However, the DAC section is the more difficult challenge.

Here is a schematic of the output section of the device. I use a TLC7524 DAC chip because it is fast, and because I happened to have access to some. You could use a DAC0800 or something else, I chose this one for convenience.

The TL072 is something I learned from studying the dotcom synthesizer boards; Roger uses TL07n chips everywhere, and in looking them over, I understand why. Nice lil' chip.

[ddg]

updated 03-22-2011