The ArdCore Project - Final

Development of the ArdCore Computation Module
__________
A Project
Presented to
The Faculty of Arts and Humanities
University of Denver
__________
In Partial Fulfillment
of the Requirements for the Degree
Masters of Art
__________
by
Darwin Grosse
April 2011
Advisor: Trace Reddell

©Copyright by Darwin Grosse 2011
All Rights Reserved

Author: Darwin Grosse
Title: Development of the ArdCore Computation Module
Advisor: Trace Reddell
Degree Date: June 2011
Abstract
This project documents the development and construction of the ArdCore module,
an Arduino-based computational device for analog modular synthesizers. In this
document, I place the work within the context of the history of computers, modular
synthesizers and modern microprocessors in music and sound design, and describe the
steps taken to create both the device and the open source manifestation of the project.
ii
Table of Contents
Project Description.............................................................................................................. 1
The ArdCore Module.............................................................................................. 1
Software Development............................................................................................ 1
The Website ............................................................................................................ 2
Literature Review................................................................................................................ 3
Computers in Electronic Music Experimentation................................................... 3
Initial Sound Experiments........................................................................... 3
Microprocessors and Digital Sound............................................................ 4
Integration of Programming in EM Practice............................................... 6
Modular Analog Synthesis in EM Development .................................................... 8
Modular Synthesis Development................................................................ 8
Modern Modular Synthesizers.................................................................. 10
Modular Synthesizer Roles in Sound Design ........................................... 10
Open Hardware and Software Production ............................................................ 11
Background Learning and Experience.............................................................................. 16

Research of Existing Systems............................................................................... 16
Modular Synthesis Standards................................................................................ 18
Modern Panel Formats.............................................................................. 18
Modern Voltage Standards ....................................................................... 19
Other Standards......................................................................................... 20
Design Choices for this Project................................................................. 20
Electronic Design.................................................................................................. 21
Basic Electronics....................................................................................... 21
Choosing an Arduino Device.................................................................... 21
Selecting Supporting IC Chips.................................................................. 22
Power Supply Interface............................................................................. 23
Circuit Board Design ............................................................................................ 24
Initial Breadboard Designs ....................................................................... 24
Initial Tests............................................................................................................ 25
Circuit Board Production ...................................................................................... 26
Faceplate Production............................................................................................. 28
Software Development.......................................................................................... 30
The Reference Device....................................................................................................... 32

The ArdCore 001 Module..................................................................................... 32
The ArdCore Arduino Shield................................................................................ 33
Software Sketches................................................................................................. 33
Other Peripherals and Formats.............................................................................. 34
Open Source Production ................................................................................................... 35

Website Expansion................................................................................................ 36
iii
Hardware Specification......................................................................................... 37
User Feedback....................................................................................................... 37
Future Plans ...................................................................................................................... 39

Expanders.............................................................................................................. 39
Different Formats.................................................................................................. 40
Conclusion ........................................................................................................................ 41
References......................................................................................................................... 42
Appendix A – The Final ARdcore Specification.............................................................. 44
Appendix B – Mechanical Drawings................................................................................ 48
Appendix C – Description of Ardcode Sketches .............................................................. 50

1. Template ........................................................................................................... 50
2. Note Quantizer .................................................................................................. 51
3. Drunken Walk Generator.................................................................................. 52
4. Drunken Note Generator................................................................................... 53
5. Clock Divider.................................................................................................... 54
6. Trigger-to-Gate Converter ................................................................................ 55
7. 8-Step Sequencer .............................................................................................. 56
8. Gate Delay ........................................................................................................ 57
9. Trigger Delay .................................................................................................... 58
10. Note Delay ...................................................................................................... 59
11. Glissando (w/Gate) ......................................................................................... 60
12. Comparator ..................................................................................................... 61
13. Slope Detector................................................................................................. 62
14. Gate Sequencer ............................................................................................... 63
15. Automatic Switch............................................................................................ 64
16. Clock Multiplier.............................................................................................. 65
17. Logic Module.................................................................................................. 66
18. Variation Generator ........................................................................................ 67
19. LFO w/Shaping............................................................................................... 68
20. Stepped Random ............................................................................................. 69
21. Shift Register .................................................................................................. 70
22. Output Standards............................................................................................. 71
23. Control Voltage Recorder ............................................................................... 72
24. Simple VCO.................................................................................................... 73
25. Voltage-controlled AD Envelope ................................................................... 74
Appendix D: An Interview with Dan Snazelle ................................................................. 75
Appendix E: An Interview with Grant Richter ................................................................. 80
Appendix F: An Interview with Brian Crabtree ............................................................... 84

iv
v
PROJECT DESCRIPTION
The ArdCore Module
The physical device created for this project is a sub-component module for a
monolithic analog synthesizer. This type of synthesizer, unlike popular keyboard
synthesizer, is a large-format system that breaks down the elements of sound creation into
discrete, self-contained modules. The ArdCore module is a first for these systems: it is a
general-purpose computational platform that provides the opportunity to use embedded,
end-user programmed microprocessors within these large – and largely analog – systems.
Software Development
This device is built using the popular Arduino microcontroller platform, and uses
available open source development tools to create programs to run on the device. As part
of this project, I have created a large number of “personality” sketches that enable the
module to perform an array of typical (and sometimes atypical) sound creation functions.
Unlike other computer interfaces, the ArdCore module works as a stand-alone device,
allowing the synthesizer (and our computational module) to work without being tethered
to a user’s computer. Additionally, the software and tools provide a way for the end-user
to work with a simplified programming system that can allow them to realize new
module functions without any hardware redesign.
1
The Website
All of this work, both hardware and software, is available as open source
information through a website. 20objects.com, a website (and business entity) maintained
by Andrew Pask and me, is the hosting location for this material and supports the effort
by providing centralized downloads, information pages, video documentation and user
forums dedicated to the use and programming of the ArdCore modular platform.
2
LITERATURE REVIEW
Since this project involves computer sound experimentation, analog sound design
technologies and open source hardware development, it is useful to contextualize it
within the histories of each. Much of the literature regarding computational and analog
sound design is focused on music creation, but it is the inherent experimentation that is
important to understand this project’s historical positioning.
Computers in Electronic Music Experimentation
Initial Sound Experiments
Max Matthews, a researcher at Bell Labs who developed both sound development
hardware and sound-oriented computer languages for sound production, led early
experiments in computer sound and music. The first computer-created composition, In
the Silver Scale, was created in 1957 by Newman Guttman using Matthews’ MUSIC I
program. Updates to the program (and the related hardware) allowed the system to
provide more compositional complexity, leading to work by composers like James
Tenney, Charles Dodge and Vladimir Ussachevsky. The system progressed through many
versions (MUSIC II through MUSIC 11), with the series eventually becoming known as
the MUSIC-N system. The evolution of this line of programs has evolved into the
CSound composition environment that is still active today (Chadabe 1997, 108-110,
Manning 187-189).
3
The MUSIC-N system was unique in that it separated the development of
instruments from the development of the composition. Both parts of the performance
were maintained as a single program, but the separation allowed instruments developed
for one score to be used in another. Describing the result as “instruments” may lead one
to think of modern electronic emulations of pianos or woodwinds; this would be
misleading, since many of the instruments were little more than digital sound waves or
experiments with computer-produced noise (Théberge 1997, 223). But composer/sound
designers like Dodge and Ussachevsky combined their background as tape music
explorers with digital programming techniques to create new soundscapes within these
new computer-based systems.
The process of creating sounds using these programs was excruciating. Larry
Austin described working for hours in creating a composition, then trying to hear the end
result:
…the Play command didn’t mean you’d get the sound back right away. The
program would go through the three passes of Music V and the music would be
output to digital computer tape. Then you made an appointment to get your digital
tape converted to audio tape. The sounds were converted on the main machine
down on campus (Chadabe 1997, 116).
Thus, the process of working with computers was far from an interactive process.
It was the development of small and more accessible computers that would make
computer media development an interactive experience.
Microprocessors and Digital Sound
The use of microprocessors built into standard keyboard instruments introduced
digital technique into interactive sound design. Sequential Circuits, an electronic

4
instrument developer, built a digital interface to their analog synthesizer circuitry using a
microcontroller to control all of the device settings. This made it possible to store a group
of settings as a “preset” – an approach conceptually similar to Matthews’ MUSIC-N
separated instruments design and which allowed the users to recall their work at any
point. This was very important when using synthesizers in both performance and studio
environments, with favorite sounds recalled at the push of a button (Chadabe 1997, 156-
157).
These hybrid synthesizers, including the Sequential Circuits Prophet 5, Roland
Jupiter 6 and 8, Oberheim OB-8 and Korg Poly 6, became staples of musicians and sound
artists because of their relative simplicity, lower cost and greater stability. However,
these instruments still suffered from some limitations – particularly the number of notes
that could be played (polyphony) and the complexity of the analog sound generation
engines. With the release of the Yamaha DX-7 and Ensoniq Mirage, digital synthesis
(built off the work of Matthews and researchers like John Chowning) quickly replaced
analog systems as popular sound creation tools (Théberge 1997, 59-69; Chadabe 1997,
197-201).
As digital control (and eventually, digital sound synthesis) became ubiquitous, the
use of computers naturally followed. Prior to the availability of hybrid and digital
synthesizers, most computer music was focused on both sound generation and
compositional playback within the machine, using the process described by Austin. With
this new generation of digitally-controlled synthesizers, and especially the development
of the MIDI networking specification, these two functions were split between systems:
5
the synthesizer generated the sound, while the computer produced the notes and timbre
changes developed by the user (Chadabe 1997, 202-212).
While some first-generation microcomputing systems (particularly the KIM-1 and
the Apple II) offered opportunity for audio experimentation, it was the second generation
of microcomputer – led by the Atari ST 520, Commodore Amiga, IBM PC and Apple
Macintosh – that led to widespread use of computers in music and sound development.
As the available computer systems got faster and more powerful, they began to usurp the
role of sound generation as well. With the advent of Steinberg’s VST (Virtual Studio
Technology) system, digital synthesis moved “inside the box”, and the use of dedicated
synthesizer modules began to wane (Chadabe 1997, 201-204; Théberge 1997, 83-90;
Holmes 2008, 275-280).
Integration of Programming in EM Practice
While the MUSIC-N systems provided programming-like control over the digital
sound systems, much of the development in computer music and sound design revolved
around creating a “better tape recorder” or “new synthesizer”. It was the work of Miller
Puckette at IRCAM that moved programming from the research institution and into
electronic music practice. Using ideas garnered from Max Matthews, Puckette developed
a real-time programming environment (eventually named Max as a nod to Matthews) that
allowed programmatic access to IRCAM’s 4X hardware system. While the hardware
never became popular (largely due to its high cost), the Max language became the first
6
widely available computer language for electronic music production (Chadabe 1997, 183-
184).
Early versions of Max (and other programming systems, like Keykit and CAL)
primarily produced MIDI output for the control of synthesizer hardware. Csound, an
updated variant of MUSIC-N, continued the traditional computer music role, with both
sound generating and compositional mechanisms maintained within the computer. As
microcomputers became more powerful, so did these languages: Max and its variants (Pd,
Generator/Reaktor, AudioMulch) offered real-time graphical programming tools for
audio creation, while textual languages like Csound, Chuck and Cmix became capable of
interactive audio output (Manning 2004, 399).
As a result, programming languages have become a mechanism for the creation of
personalized, idiosyncratic electronic sound design tools. While there was once a
differentiation between programmers and artists, this gap is quickly being closed by
artist-friendly (or less adverse) programming languages and development environments.
The ArdCore computational module is an attempt to provide this sort of environment to
musical practice.
In many ways, the ArdCore is a return to MUSIC-N/CSound like tools, where the
compositional tools are separate from the sound generation tools (or instruments).
Although the ArdCore can produce a limited number of sounds, it is primarily focused on
the generation of compositional data: melodic line development, timing alterations or
musical phrase generation and storage. By creating an environment that simplifies access
7
to these functions (through basic programming techniques), it gives interested users a
chance to develop code that works within their existing music-making environment.
Early ArdCore user Dan Snazelle (see Appendix D) describes his approach to the
platform as “a tool for learning programming”. He further points to the significant body
of example programs as a launching point for creating something that would represent his
own creative work. Because the platform is well documented, freely available and works
within a musical context, he and others are excited to try programming when they
previously had no motivation to do so. Thus one of the project goals – to create a device
that would draw people into programmatic practice – appears to have been adequately
met.
Modular Analog Synthesis in EM Development
Computer sound creation was developed within academic and research centers,
but the modular synthesizers came straight from the commercial world. These systems
were created as devices for musicians and sound designers to use as a primary
instrument, which lead to a different progression in their design.
Modular Synthesis Development
While the beginning of the electronic synthesizers can be traced to Thaddeus
Cahill’s Telharmonium (Holmes 2008, 6), it was the work of Robert Moog and Don
Buchla that ignited interest in analog electronic synthesis. These pioneers created systems
that were modular in nature: the user could select synthesis components based on their
8
process, with each user’s system being a unique expression of their work. By combining
modern production techniques (such as standardized module formats and the use of
standardized parts throughout their systems) with direct artist interaction and support, the
early creators quickly established analog modular synthesizers as a popular option for
adventurous musicians and sound designers. Early modular synthesizer users included
Wendy Carlos, Keith Emerson, Susan Ciani and the members of Tangerine Dream
(Chadabe 1997, 140-149; Pinch & Trocco 2002, 74-77, Vail 2000, 105-155).
While the Buchla and Moog systems were very different, they both shared a
similar concept – the use of analog voltages to both generate the sounds and control the
settings. While Buchla’s systems were more complex, it was Moog’s developments that
set industry norms, particularly the use of 1 volt per octave as a system control standard.
Most analog modular systems (by such companies as ARP, Aries and Roland) took up
this standard, leading to broad interoperability among systems (Jenkins 2007, 36).
The most significant problem with these analog modular systems was their
complexity; they were expensive to manufacture and there was no way to store work that
had previously been done. There were also stability problems; analog systems were
massive, hard to maintain and very sensitive to temperature variations. This led
manufacturers to try simplifying the systems and attempt engineering-focused methods
for improved stability. Eventually, modular analog synthesizers fell out of favor with
musicians that preferred more portable (and less expensive) keyboard instruments, and
eventually into computer-based synthesizers (Manning 2004, 296-304).
9
Modern Modular Synthesizers
In the early 2000’s, there was a strong backlash against software synthesis,
causing cutting edge electronic musicians and sound designers to search for older analog
systems. Among the most desired synthesizers were the modular analog systems from the
60’s; these units provided unsurpassed flexibility of sound generation while maintaining
an analog sound path (Vail 2000, viii-ix). As such, a significant group of enthusiasts
began to form around modular systems, and a new set of vendors began to create updated
analog modular synthesizers. These modular systems allowed musicians to have access to
this method of sound creation without the extraordinary costs of the (now collectible)
original devices.
In order to capitalize on this market, this generation of modular system developers
have focused on analog methods pioneered by Moog and Buchla – to the exclusion of
almost any digital interaction. As these systems became more widely used, some
developers created basic digital modules, generally using digital techniques to “warp” the
audio path or to interface with computer gear through MIDI interconnection (Robair
2001).
Modular Synthesizer Roles in Sound Design
Use of modular synthesizers is now a part of experimental electronic music
creation, but there is no preset role for these devices. They can be used for percussion
synthesis, bass line production, quirky lead lines or even manipulation of digitally
recorded samples. One primary reason they are increasing in popularity is that they have
10
the perception of removing limitations between the artist and the production of sound.
However, some of the limits of analog-only modular systems can also inadvertently
reduce the capabilities of the artist-producer.
These limits include difficulties with storage and replication of work, the
difficulty of introducing precise algorithmic functions into generative work, and
difficulty with interfacing into the now ubiquitous computer systems without resorting to
MIDI. It is within this context that my project introduces a programmable, modular-
centric computational device that can solve many of these problems.
The module created by this project is designed to work within an analog modular
system, but also works beyond its typical boundaries. It has (and even features) a USB
connection for a computer, but also uses standard knobs, jacks and LEDs for its user
interface. When connected to a computer, it can either function as a repository for
programming, or as a connection between modular and computer.
This last statement is important, because some modular users actively avoid using
their computer during composition or performance, while others attempt to create a
deeply integrated hybrid of computer and modular. By creating a system that can either
work in conjunction with or completely independent of the computer, I have created a
module that can operate within most people’s workflow.
Open Hardware and Software Production
The third context in which this project is situated is the open source hardware and
software movement, and its relationship with DIY (Do It Yourself) and industry outsider
11
development. Perhaps the earliest efforts in the area of DIY music hardware creation
were the articles and books written by Craig Anderton. His seminal text, Electronic
Projects for Musicians (1975), along with his work for the Synergy and Electronic
Musician magazines, offered simple circuits and basic electronic teaching, along with the
option to purchase kits from various suppliers. Anderton’s projects were simple but
concise, and allowed non-engineers to create their own effects and noise-making devices.
A more significant milestone was the publishing of Hal Chamberlin’s book
Musical Applications of Microprocessors in 1985. This introduced microprocessing
techniques for almost every musical application, with a specific focus on synthesis
techniques. Unlike Anderton’s book, this was a more technical book, but was still within
the capability of the interested hobbyist to explore. The result of this work was the broad
integration of microprocessors in DIY and kit-based instrument creation.
But it wasn’t until the development of cheap and readily available microcontroller
platforms that DIY instrument development exploded. With reduced barriers to entry
(particularly in lower microprocessor prices and elimination of dedicated programming
hardware), platforms such as the Basic Stamp, PIC processor and Arduino platform
opened the door for non-industry, non-engineering individuals to create their own
instruments and musical controllers.
The ArdCore project uses the Arduino microcontroller system – an open-sourced
combination of hardware specifications and software tools that allow individuals to
develop hardware-centric devices at a modest cost and with a modest level of dedication.
12
The use of the Arduino is central to the computational focus of this project as well as its
openness to user development.
The Arduino platform was created by Massimo Banzi, David Cuartielles and
others in Ivrea, Italy, and first began receiving attention when it received honors at the
2006 Prix Ars Electronica. It combines a very simple microprocessor (the Atmel AVR
microcontroller) with a few basic components on a standardized board layout. This layout
has allowed a wide range of developments, with accessory boards (called shields)
becoming a popular way to expand the functionality of the basic Arduino device (Gibbs
2010, 6).
The hardware component of the Arduino is completely open-sourced, with both
the schematic and the circuit layout available from the Arduino home page. This has led
to many variations of Arduino boards that are fine-tuned for specific functions. These
variations have not detracted from the popularity of the system, primarily because the
common software base keeps any single developer from straying too far from the
standard.
The Arduino software is a combination of a bootloader (software that is loaded
onto the chip and helps load other programs) and a development environment. This
environment, built off an earlier open source hardware/software platform called Wiring,
uses a variation of the Processing software development system. This makes the system
especially valuable to artists and novice programmers, since the Processing environment
is widely used and taught as a form of introductory programming (Gibbs 2010, 6).
13
Interestingly, the Arduino comes with no default program; rather, the user is
expected to write (or download) every program that they run on their system. This has led
to the expansion of programming interest among users, with more excitement being
shown for people “making things work” rather than for computational efficiency. It is this
open source/open programming system that is perfect for this project: the creation of a
system that provides few barriers to experimentation.
This is a significant change over a very short time; most texts on music- or sound-
based programming assume the use of a high-speed computer/OS system. There is
information on creating effects units, sequencing programs or sound manipulation plug-
ins, but are all focused on computer systems that vastly outpace most hobbyist
microprocessors. It has been the internet-based microprocessor development community
that has led the way for new musical applications of these devices and the development
of a completely new (albeit small) industry.
A simple search on the main Arduino site for “music” returns dozens of tutorials,
forum postings and external site links to projects by people trying to link their favorite
music-making processes to hand built electronics. This is further enhanced by companies
such as SparkFun, CuteDigi and Adafruit that provide simplified access to the parts and
kits necessary to create useful hardware. The combination of low hardware costs,
hobbyist-friendly component retailers and easily accessed information all combine to
support any individual willing to try their hand at hardware development.
These same factors have also led to the growth of new organizations, like
Handmade Music and Crash Space, to help users experiment with instrument-building,
14
basic electronics and software interface. In the interview listed in Appendix E, Grant
Richter describes musical engineering as having a tribal nature, since the practice
requires information from so many disciplines. These organizations are fulfilling both the
education and support roles necessary for new hardware developers and software
programmers to attain the knowledge necessary for creating personalized instruments.
By placing this project within the informal parameters of a DIY-supportive
environment, the ArdCore project is able to build upon the work of the existing
community while adding to its knowledgebase. The ArdCore hardware is priced
reasonably, with kits and bare circuit boards made available for the DIY builder.
Additionally, all of the software source code is provided for free use (subject to the
Creative Commons Non-Commercial license) by anyone willing to build his or her own
unit that supports the project specification. Finally, reference circuit designs are provided
for the primary subsections of the system, so inexperienced hardware developers can
create “hacked together” versions of the system for their own use. These efforts allow the
ArdCore to be a ground-breaking platform for those individuals interested in creating a
low-cost, high-value module for any synthesis environment.
15
BACKGROUND LEARNING AND EXPERIENCE
Research of Existing Systems
To date, nobody has created general-purpose computing tools for modular
systems. Two companies – Silent Way and MOTU – have created systems to integrate
computers into analog systems via audio interfaces, while other companies have created
interfaces that allow computer-source MIDI data to be translated into control voltages.
But each of these approaches has limits because the computer must remain ‘tethered’ to
the synthesizer. It is here that this project innovates – I will place general-purpose
computing resources inside the analog modular system; an option that offers stand-alone
computational processes within an analog system.
Microcontrollers are currently being used in a number of commercial modules;
sometimes they are part of the sound generation mechanism, but most often they are used
as part of the control system. A good example is the MOTM-650 MIDI-CV Converter.
This microcontroller-based system is used to receive MIDI commands from an external
device and produce control voltages for a modular synthesizer. The microcontroller is not
only used to convert the serial MIDI data to analog signals, it also can be used to create
sequences (repeating patterns) and other musical figures
(http://www.synthtech.com/motm650.html).
This module, like all similar commercial modules, is hidden behind a device-
specific front panel, and uses the microcontroller for a specific function. It also does not
16
include the source code (which developer Paul Schreiber states is not available for release
due to licensing issues), so further modification or bug fixes are not possible (Schrieber
2010). Thus, the MOTM-650, like other commercial products, is not a platform for
experimentation – it is simply a musical instrument interface that happens to use a
microcontroller.
To find a more open environment for exploration, one needs to look to the
modern microcontroller maker/hacker community. While some microprocessor platforms
have been developed based on other CPU subsystems, it is the Arduino that has emerged
as the most popular microprocessors for the experimenter. Thus, despite its limitations,
the Arduino was the clear choice as a computational core for this project.
These limitations are quite significant in comparison to other available computing
systems. For example, the amount of memory space available for the program is limited
to 4-8 K (kilobytes), while variable space is limited to less that 1 K (Pablo 2008). As a
result, projects that use the Arduino are often paired with additional hardware for
expanded functionality. An example is the Fluxamasynth, which combines an Arduino-
compatible platform with a commonly available synthesizer-on-a-chip component to
create a programmable synthesis device (Modern Devices 2010). While this is a
convenient way to add stand-alone synthesis to an Arduino package, it doesn’t provide
any way to interface this synthesizer with other modules in an analog system – and
therefore it cannot not provide useful functionality to the modular user.
A more interesting approach is being taken by ADDAC systems
(http://andregoncalves.info/addac/), which provides an Arduino core for a computational
17
device – opening the door for user programmability. However, this system is also limited
by the use of function-specific faceplates, and only has greatly-reduced access to
programming resources; thus, as with the MOTM-650, it is a single-purpose device rather
than an experimenter’s platform.
Users have attempted to integrate the Arduino as a part of their modular systems
on their own with varying degrees of success. Some have taken the approach of building
audio-generating modules (such as oscillators), while others have focused on attempting
to use the digital pin outputs of the Arduino for triggering or gating purposes. The largest
problem, as seen in DIY forum postings, is that people who are capable of dealing with
the hardware (developing such add-ons as digital-to-audio converters or input
conditioners) develop rather simplistic software sketches, while hardware issues
overwhelm more experienced software developers (Muff’s Modules & More 2010).
As a result, there are no instances of readily available hardware/software
examples for people that want to use an Arduino system as an experimental tool within
their modular system. This is the issue that I chose to address with this project.
Modular Synthesis Standards
Modern Panel Formats
Perhaps the easiest way to classify the various standards in use is by the size of
their panels. The two most popular formats are the Eurorack system (developed by Dieter
Doepfer: www.doepfer.com) and the 5U system, an extension of Moog’s original design
18
and format. While the Eurorack system has more users (and more companies creating
modules), it is less widely used among DIY enthusiasts due to its small size.
The 5U system - so named because it is 5 rack spaces high - was originally
designed by Robert Moog in the late 60’s. Although Moog Music is no longer involved in
modular manufacturing, Roger Arrick of Synthesizers.com is maintaining the format
through the creation of high-quality complete systems. Because of the large size of these
modules, it is easier to develop user-created modules, with a widespread DIY community
as well as many small manufacturers supporting the format.
Modern Voltage Standards
While the front panel is the most obvious way to differentiate systems, it is
electrical standards that are at the heart of creating any modular system. In the early days
of commercial modular systems, there were many voltage standards. Luckily, almost all
modular systems have settled on the Moog 1 volt-per-octave standard. This voltage
standard states that with each increase of a volt within a system, pitch-tracking system
will increase by 1 octave.
Having a ubiquitous standard for voltage tracking is helpful in being able to create
a device that can work with a variety of systems. Whether operating within Eurorack or
5U systems, or other less common systems (like Frac or Serge), the core circuitry of this
device will be compatible with only minor changes.
19
Other Standards
Less important to the design (but still important for the project artifact) is the
standard for the connection jacks between modules. The two main systems use different
types of connectors, with Eurorack modules using 3.5mm mini-jacks, while 5U systems
use the 1/4” jacks used by Moog’s design. While there is no operational value in the jack
sizing, the use of 1/4” jacks add to the overall “large” size of 5U systems.
The other important standard to be considered is the power supply systems found
in these formats. Eurorack systems use power supplies with +/- 12 volt power supplies,
while 5U systems use +/- 15 volt supplies. Each supply system also uses a unique power
connector – another consideration for a multi-purpose device.
Design Choices for this Project
To create the reference module that is the artifact of this project, I decided to use
the 5U-1/4” jack standard. As part of the project design phase, I had done some
preliminary work with all of the major (and most of the minor) formats, and I found that
the 5U systems were more conducive to my style and the easiest for module
development.
However, I did not want to prevent people from using the core computational
device with other systems, so the circuit was designed to be small enough to fit behind
the typical Eurorack faceplate. I chose to follow the 1 volt/octave standard, and to
provide a power support system that could work with both 12- and 15-volt power
supplies.
20
Electronic Design
Once the overall design choices were made, I needed to create the circuit using
standard breadboards. This required two things: learning a modicum of electronics, and
experimenting with different components to create a system that would work as expected.
Basic Electronics
Learning electronics was an intimidating process; I had tried to understand it in
the past, and was always stymied by the variety of details necessary to make even basic
projects work. The growing interest in DIY electronics as epitomized by Make Magazine
offered an opportunity to learn electronics in an entirely new way – with practical
information taught by projects, and project design as an integral part of creating work.
The book that helped me overcome my intimidation was Make:Electronics (Platt
2009), which encapsulated electronic learning and interesting project designs with a
Make Magazine aesthetic. After working through many of the examples in this book, I
felt much more at ease with electronics design.
Choosing an Arduino Device
The popular Arduino microprocessing platform offered an option for me to
incorporate a computing core into the project without having to build all of the necessary
supporting circuitry and software tools required for a complete project. This system also
21
allowed me to create a device that would be easily programmed by the end user and had
an active online community for providing support to both end users and me.
There are many variations of Arduino boards, from the current Uno development
board, through the Mini boards that are little larger than the average IC chip. After
researching all of the available options, I decided to use the Arduino Nano, a very small
device that had an integrated USB connection. In addition to the convenience of having a
small unit, the Nano also has eight analog inputs (rather than the typical six for a standard
Arduino implementation); this was an important consideration, since the analog inputs
are a valuable control mechanism in modular synthesizer integration.
Selecting Supporting IC Chips
The Arduino, however, is not able to directly integrate with modular systems. In
order to create a standard analog voltage, digital pin signals need to be converted into a
single analog voltage. There are two ways used to send values to an analog output: either
through serial interface using a pair of pins, or a parallel interface through a larger
number of pins.
Since I wanted to create an easy-to-understand programming interface to the
modular system, I chose to use the parallel interface mechanism. This uses most of the
digital pins of the Arduino, but it is clear within the code how you set individual bits for
output. I chose to use an 8-bit digital signal to describe the output signal, and used an 8-
bit digital-to-analog converter, the Texas Instruments TLC7524, to create a single
variable voltage out of the eight pin outputs.
22
The output of the TI chip doesn’t provide a useful voltage for the modular system
(in that it doesn’t output a strict 1 volt per octave range), so some amplification needs to
be applied to the signal in order to scale it correctly. After closely examining the modular
equipment I had available, I chose to use a TL072 dual op amp, which let me create 1
Volt/octave output scaling with a minimum of external parts. This op amp also provides a
feedback system to the DAC chip that greatly improves the accuracy of the voltages
created, making the entire system more stable.
Finally, I also designed the system with a pair of “digital” outputs that would
provide either HIGH or LOW values – either 0 volts or 5 volts. These outputs can be
gates, triggers or clocks, but require high current output (meaning that it requires a
significant amount of electricity to drive the connected module and components). Since
the Arduino can be damaged if the current draw is too great, I found a chip – the Texas
Instruments SN74ALS541, which allowed me to use an external power supply to drive
the these high-current outputs without taxing the Arduino power regulators.
These three chips, the TLC7524, TL072 and SN74ALS541, are the heart of the
circuitry necessary to create a modular-to-Arduino connection, and form the core of the
actualization of the ArdCore specification.
Power Supply Interface
Since I intended my device to work within a 5U system, I also chose to use one of
the power supply connections common in that system: the Synthesizers.com connection.
Since this company provides well-documented power systems, it proves to be the easiest
23
way to integrate with an existing modular system. It is also generic enough to be useful
for non-5U users to consider.
Circuit Board Design
Initial Breadboard Designs
The development of a final circuit was an incremental process; I had to first
design the specification of how the Arduino was going to be used, then I built slowly
from the Arduino outward. I started with the analog inputs, since these were the easiest to
interface with my existing equipment.
Since the Arduino only accepts 0-5 volts on each input, I had to make a decision
about input scaling. Since most modular systems work off of a bipolar voltage (as much
as a -10 to +10 volts range), I would either have to scale the inputs or eliminate some of
the voltage range. Since my primary goal was to make this system easy to program, I
decided to forego support of negative voltage – this allows the number range of 0-1023
(the input range of the Arduino) to represent a 0-5 volt range, with an input value of 0
representing zero volts. In practice, this means that some attached modules would have to
be scaled externally, but it would offer the best experience for beginning programmers.
I also wanted to have a clock input, but the analog inputs were too slow for this
purpose. In reviewing the Arduino programming documents, I found that some of the
digital pins could be used with interrupts, which stop the running program temporarily
whenever a signal is seen on that pin. This is perfect for clocking applications, so I
moved the clock inputs from the analog to digital pins.
24
The outputs were more difficult, since they required designing the DAC circuit.
Although I had identified the TLC7524 as the appropriate chip for this task, I found few
examples in the chip’s data sheet that were not overly inflexible. A key discovery, found
through experimentation, was that I could ignore the timing inputs and keep the DAC
“open” at all times, giving me continuous voltage output whenever I changed the output
values.
When I first worked with the TL072 op amp, I was surprised to find that the
output was not scaled correctly for my 1 volt per octave output. This is where the vast
array of searchable information came in handy: a few online tutorials showed that one
should not expect a 1-to-1 amplification since there was always an internal voltage loss.
By adding a trimmer to the amplifier stage, I was able to increase the scaling of the
output, giving me a true 1 Volt/octave range.
Digital and LED outputs are all buffered through the SN74ALS541 chip, allowing
me to control the amount of current draw from the ArdCore power supply. Based on
information I got from synthesizer designer Grant Richter (Appendix E), I chose to add
1K resistors across all of the outputs to prevent any damage in case a user placed voltage
into a module’s outputs (and potentially causing a reverse voltage spike).
Initial Tests
In order to test the circuit, I added jacks and a power connector my breadboard
circuit, then rewired my personal modular system to run the breadboarded circuit directly
from the system power supply. I also created a simple Arduino program that would
25
produce octave outputs and loaded that into the circuit. The circuit worked appropriately,
and with some adjustments of the trimmer I was able to get a stable, 1 volt/octave output.
One of my concerns was that the digital pins might not produce voltage at a rapid enough
rate, but I was pleased to find that the entire circuit was fast and stable as values changed.
Circuit Board Production
There are two processes necessary to move a circuit from breadboard to printed
circuit board: creating a board layout, and getting a manufacturer to produce it. There is
relatively little practical information for board layout; most of the available books are
either focused on highly technical aspects of high-speed layout (i.e., ultrasonic and RF),
26
or are tied to a specific commercial layout package. My interest was in separating the
design from any single software package, and was specific to working in the domain of
audio processing.
While purchasing parts on a vendor site (Small Bear Electronics), I happened
upon a self-published book called PC Board Layout for Musical Effects. This sounded
like a decent option for this project, and review of a purchased copy revealed it to be a
good assumption. The book has a very practical way to deal with the power, crosstalk and
other issues that are common with guitar effects pedals and audio processors – all issues
that I was facing with this project.
Using this book as a guide, I next needed to find software that could provide me
with an appropriate layout. The most popular software is CadSoft’s Eagle, but I found it
very complicated, and the board size limitations on the free version meant it was
unusable for this project. The freeware/open source Fritzing package was easy to use, but
it crashed very often and had some user interface quirks that made it unusable for me.
The breakthrough in board design came when looking for possible small run
board manufacturers. One company, ExpressPCB, advertises a service where they will
create 3 commercial-quality PC boards for $51 – a reasonable sum in comparison to
many manufacturing services. My experience with creating my own PC boards indicated
that I needed to find a small run board service, so I reviewed this interesting option. As
part of their production, they offered a free software package that could be used for
circuit board layout. It is a Windows-only product, and is limited in that it can only be
27
used for creating boards using their service. Since I was already sold on that, I tried their
software and found it both simple to use and robust enough for this project.
Using a Windows installation on my Macintosh, I was able to prepare the first
version of the printed circuit board in only a few hours. Within a week, ExpressPCB
delivered my first example board – which identified several problems. In a last-minute
change, I added one trace that crossed over a ground path. When I hooked up my first
circuit using this board, it not only didn’t work – it actually burned out several of the
digital pins of the Arduino board.
Subsequent changes to the boards (and several three-board production runs)
allowed me to fine-tune the boards until I had the final version, labeled Revision F, that is
stable, provides many test points for the user to access during building, and fit the
dimensions of the physical package I was developing. Version F of the board is the
version that is now available, and I had 50 boards of this version manufactured.
Faceplate Production
Possibly more difficult than creating the printed circuit board was the process of
making faceplates for the finalized module. The 5U format has a pretty specific aesthetic:
aluminum faceplates with bent sides, black facing with either uncolored or white lettering
and black Moog-like knobs. In order to create temporary mounting for the controls while
working on the module, I drilled holes in a standard “blank” faceplate; but with no way
of adding good-quality white labeling, this was not an option for creating the final
product.
28
Discussions with Phil Petchke (from Megaohm Audio, another 5U developer)
informed me of a company named MetalPhoto of Cincinnati. This company produces a
special kind of aluminum plating that is photosensitive; you expose the plate to a negative
of your faceplate labeling, process it to create a positive of the image embedded in the
aluminum, then bend and cut it as necessary. Working with the company allowed me to
get a very professional plate with only modest design problems.
Of course, working with a third-party company like this has its difficulties. The
first set of plates created was wrong: I had discussed the positioning of the USB port
mounting with their artist/engineer, he assured me that they could do the proper layout.
Their artwork appeared to be exactly as needed, but when I received the first set of plates,
the mounting holes were rotated about 20 degrees, making them unusable. The company
took back the defective merchandise and created new ones, but this caused a significant
delay in finishing the construction.
The resulting faceplates, with all hardware mounted, are as attractive as any
modules being commercially created. I has since learned that this process is being used
by several of the other 5U developers, and provides a precise means of labeling and
marking without the cost and trouble of screen-printing.
29
Software Development
Although creation of the hardware (circuit board and faceplate) was time-
consuming because of all the learning required, it was the software development that has
taken the most time. I wanted to create a significant quantity of sketches for the Arduino
core of the module – in essence, creating “personality” modules for the device – so I
decided to create 25 different sketches to support the ArdCore platform.
This required creating a usable prototype, which I did by drilling the necessary
holes into a blank faceplate and creating a simple mount of the circuit board on the
30
temporary plate. This was a fairly messy installation, but it operated fine as long as the
circuit board was isolated from any other metal surfaces. This prototype module allowed
me to work with the module as a stand-alone device, and helped me verify the usefulness
of each of the sketches.
I also received a lot of help from some of the early testers of the system –
especially from the first serious user, Dan Snazelle (see interview in Appendix D). Dan
had stumbled across the ArdCore page in an attempt to create his own Arduino-based
module, and decided to use our specifications and sketches to build his own system.
Dan not only tried each sketch, but also was active in providing feedback about
problems or improvements that he thought would help improve the work. He decided to
use the sketches as a means of learning Arduino programming, so he was educating
himself on programming at the same time that he was working on creating the hardware.
The result of my software development is a library of code that shows much of
the processing that can be accomplished with the ArdCore. While some of the sketches
are meant to be finished products, others are provided as starting points for end-user
experimentation. Combined with the video contents, it should be easy for users to find
out which sketches to use and which ones they might want to modify.
31
THE REFERENCE DEVICE
The ArdCore 001 Module
The final version of the ArdCore module supports its general-purpose role: the
front panel features the USB jack (so it is clear that it is meant to be hooked up to a
computer), and has generic labeling throughout. The module has two knobs for user
settings (connected to the Arduino analog 0 and 1 inputs), two analog input jacks for
automated control (connected to the Arduino analog 2 and 3 inputs), two digital outputs
(connected to the digital 3 and 4 pins), a clock input (connected to the interrupt-ready
digital pin 2) and the analog output (connected to the DAC output). This set of controls,
inputs and outputs is similar in breadth to most analog modules, so the layout and
connections (except for the USB port) will feel familiar to most users. Details on this use
of the Arduino is provided in the device specification, provided as Appendix A.
The generic labeling is not only non-intrusive, it is also placed differently from
normal modules; rather than being above the control, it is either below or to the side,
allowing the user to create labels for the specific functions without interfering with the
programmer-oriented text. This will be important when users are attempting to program
the device, since it allows the user to view the programmatic connection without having
to refer to the specification or documentation.
One design element that is oriented toward adventurous users will be the ability to
swap switches or potentiometers for the analog inputs; these were designed with a special
32
connector that allows them to be swapped out without any circuit board changes. Thus,
for programs that are best used with a switch or a knob, these can be interchanged with
the existing analog input jacks.
The ArdCore Arduino Shield
Initial attempts to create an Arduino shield proved impossible, since the chosen
DAC and op amp chips all require bipolar power supplies. Since many people using a
shield with a standard Arduino would want to be able to use computer power from the
USB port, it appears difficult to create a shield that would operate to the module
specification. I hope to find a useful external power system that can work for this
application, but most power supplies are not appropriate for this type of circuit.
Software Sketches
Creating the device without any software would have been pointless – in order for
people to get excited about the platform, it needs to be able to perform useful functions
out of the box. Thus, from the beginning of the project, I planned to create a significant
body of examples for the ArdCore. The result is a library of 25 sketches, each providing
useful functionality as well as offering the user examples of the programming that makes
it work.
A complete listing of this work is provided as Appendix B.
33
Other Peripherals and Formats
As stated previously, the design of the circuit board allows for user-replaceable
options to be added to an unmodified device. The two analog inputs, which are the
primary means of controlling the programs, are provided with input jacks by default.
However, I will also provide optional replacement subassemblies that allow for either
switches (useful for on/off or active/inactive state settings) or potentiometers (useful for
fine tuning controls) to be used in place of the input jacks. This will give the end user a
chance to add programmatic functionality that is reflected in the user interface with the
module.
34
OPEN SOURCE PRODUCTION
The open sourcing of both the design and the software is modeled after Brian
Crabtree and Kelli Cain’s development of the Monome musical controller (see Appendix
F). They created a hardware device that is very desirable, but chose to publish both the
hardware specification and the software implementation as open source documents. They
also developed an initial set of programs that were the basis for their users to craft both
performance technique and additional programs.
The result of this open sourcing was that an active community grew around the
device. Some people purchased their device from Brian and Kelli, some purchased kits,
while others used the specification to create “clone” versions (often made with Arduino
microcontrollers at their core). Many of their users created software to extend the
functionality of the device, using this opportunity to create idiosyncratic
hardware/software hybrids that represented their personal vision.
This is the model for the release of the ArdCore module. I have published the
specification for the hardware (built on the development software provide by the Arduino
community), created an initial suite of software for the device, and have clearly listed the
process necessary to create a user-sourced version of the module. It is my hope that a
community can develop around this device, and that users will contribute their own work
in order to make the ArdCore module series even more robust that it currently is.
35
This model, however, is not necessarily a pattern for success. For example, Jeff
Snyder’s Manta (also open in both hardware implementation and software development)
has seen difficulty in garnering an active community. Some of this can be attributed to
the difficulties in creating his device, which requires specific and difficult metal
fabrication. It also suffers from a lack of developer support; Jeff created few applications
that could inspire programmers, so there was no foundation for the users to build from
(www.snyderphonics.com).
Therefore, this model is not a guarantee of success, but it does provide a good
launching point for community interaction and a stable platform for programmatic
practice to be added into the synthesist’s artwork. In order to support the development of
a potential community, I took several specific steps.
Website Expansion
The most important of these steps – and possibly the easiest – was to create a
web-based location for user interaction. Andrew Pask, a Los Angeles-based software
developer (and adept metal worker) and I had been working together on a variety of
projects over the years, and created “20 Objects, LLC” as a supporting business structure
for our work together. Andrew was willing to help support the distribution and
manufacturing of the module, so we decided to produce the ArdCore as our first
hardware offering.
This entailed creating an ArdCore-specific section of our website, and providing
information about the module even before it was manufactured. I put up initial sketches
36
of the module programs, and also published a basic specification for the device. Almost
immediately, people stumbled over the site (since the combination of “Arduino” and
“modular synthesizer” doesn’t provide many useful hits when entered into Google), and I
started getting feedback from users.
Hardware Specification
The hardware specification is the portion of the project that people have found
difficult to understand. Initially, I described the use of pin outputs on the Arduino
connected to a generic DAC chip, but few people could comprehend this: they were
artists or sound designers, and didn’t want to figure out how to make a DAC chip work.
Therefore, I updated the site to include a basic circuit wiring for the DAC that I use, and
several people found it appropriate for their device creation.
Other people found it difficult to condition the inputs and output appropriately for
the Arduino’s input. Again, putting together a simple diagram (based on a diode-sink
concept described to me by Grant Richter) helped the initial users get the voltages
necessary from their modular systems into their hand-built device. The results were
uniformly positive, leading to a new set of feedback from users.
User Feedback
Perhaps the most active user has been Dan Snazelle (Appendix D), a New York-
based artist and effects pedal designer. He started working with the system, and used the
software sketches that I’d developed to learn programming of the Arduino. His feedback
37
was very valuable, leading to significant changes in the first iteration of the sketches, and
also leading me to remove some modules that provided duplicative functionality. His
feedback subsequently led to several new and more interesting modules.
In the end, this one user had a tremendous impact on the workability of the
device; this occurred before I had even begun to publicize the project to media
technology writers. It is my hope that once people understand the power of having an
easily programmable synthesizer module at their fingertips, this device will prove to be
an enabling device for the entire community.
What is clear is that the shield version of the module will be a very important
development. Since many users will want to test their device before committing to the
expense of front panels and input/output expanders, a shield will allow them to use the
system before building the end device. Additionally, using the shield version of the
device will help them to determine if the compromises made on the ArdCore (0-5 volt
limits, 8-bit output limits) will be useful for their work. It remains to be seen if the
ArdCore shield can be produced, but this is among the most important future plans for the
platform.
38
FUTURE PLANS
In addition to the module planned for this project, I expect to create ancillary
modules, reformatted versions of the ArdCore and extensions to the specification to allow
for growth in the platform.
Expanders
The first and most important addition to the ArdCore platform is the creation of
input and output expanders. The support for this has been built into the circuit board, but
additional boards and faceplates will be required for these to become available.
The input expander allows the user to add four more analog inputs (jacks,
potentiometers or switches) to the main ArdCore module. This will allow for more user
controls, easier entry of sequencer information and greater flexibility with multi-modal
control. Some enhancements that I am considering are the ability to use bipolar voltages
for input, create independent utility controls (switches that could be plugged into other
modules) and display input state changes.
The output expander exposes the outputs in a different way: rather than treating
the eight data pin output as a single value (as with the DAC on the main ArdCore unit),
this expander will provide eight separate bits as individual gate values: useful for
clocking or percussion sequencing roles. This has already been successfully created on a
breadboard, and will be the first available expansion. In fact, some of the existing
software sketches assume availability of the output expander to get maximum use of the
program.
39
One area of expansion that is outside of our control is improvements in the
Arduino platform itself. In designing the circuit, I used standard header connections for
the Arduino Nano so that it can be swapped out for faster or more capable future
versions. Assuming that the pin configuration stays the same, upgraded Arduinos should
be able to work without any circuit changes.
Different Formats
There are two ArdCore formats we will directly support: the 5U (Moog-style)
module and, if possible, the ArdCore shield. Other formats (including Euro, Frac, Buchla
and others) will be left for third parties to create; there will be no limits to other
implementations, and we would be available to consult on specifics of any production of
these devices.
Currently, Dan Snazelle is discussing the option of creating a Euro version of the
module; he was inspired by the software sketches, and wants to take his example board
and create commercial units. The discussions of this are at an early stage, but it is another
example of the value of creating an open source hardware platform.
40
CONCLUSION
This project has provided a wealth of opportunities for me to learn electronic
theory, electronic design, circuit board layout, advanced Arduino programming and
module faceplate layout. In the process, I was also able to explore some new areas of
modular synthesis, and have created an easily programmed computational device for
using in an otherwise computer-free environment. It remains to be seen if the ArdCore
system can develop into the community-driven platform that I hope for, but initial
experience points to a high likelihood of success.
41
REFERENCES
Anderton, Craig. 1975. Electronic Projects for Musicians. New York: Amsco.
Arduino. “What is Arduino?” Accessed April 19, 2011.

http://www.arduino.cc/en/Guide/Introduction.
Chadabe, Joel. 1997. Electric Sound – The Past and Promise of Electronic Music. Upper
Saddle River, NJ: Prentice Hall.
Chamberlin, Hal. 1985. Musical Applications of Microprocessors. Indianapolis: Hayden

Books.
Gibb, Alicia. 2010. “New Media Art, Design, and the Arduino Microcontroller: A
Malleable Tool.” (Masters thesis, Pratt Institute, 2010).
Holmes, Thom. 2008. Electronic and Experimental Music, Third Edition. New York:
Routledge.
Jenkins, Mark. 2007. Analog synthesizers: understanding, performing, buying.

Burlington, MA: Focal Press.
Manning, Peter. 2004. Electronic and Computer Music. New York: Oxford University
Press.
Modern Devices, 2010. Fluxamasynth development site.

http://shop.moderndevice.com/products/fluxamasynth-rev-1. Accessed Dec 6,
2010.
Muff’s Modules & More, 2010. Discussion of Arduino Projects in DIY section.
http://www.muffwiggler.com/forum/viewtopic.php?t=21053, Accessed Dec 6,
2010.
Pablo, Gian, 2080. “Making the Most of Arduino Memory.”

http://itp.nyu.edu/~gpv206/2008/04/making_the_most_of_arduino_mem.html.
Accessed Dec 5, 2010.
Pinch, Trevor and Trocco, Frank. 2002. “The Social Construction of the Early Electronic
Music Synthesizer.” In Music and Technology in the Twentieth Century, edited by
Hans-Joachim Braun, 67-83. Baltimore, MD: John Hopkins University Press.
Platt, Charles. 2009. Make:Electronics. San Francisco: Make Publications.
42
Robair, Geno. 2002. “Something Old, Something New.” Electronic Musician April 2001.
http://emusician.com/elecinstruments/emusic_something_old_something/index.ht
ml. Accessed Dec. 2, 2010.
Schrieber, Paul, 2010. Forum posting to Muff Modules & More modular synthesizer
forum. http://www.muffwiggler.com/forum/viewtopic.php?t=16297. Accessed
Dec. 4, 2010.
Théberge, Paul. 1997. Any Sound You Can Imagine – Making Music/Consuming
Technology. Hanover, NH: Wesleyan University Press.
Vail, Mark. 2000. Vintage Synthesizers: Pioneering Designers, Groundbreaking

Instruments, Collecting Tips, Mutants of Technology. San Francisco: Miller
Freeman Books.
43
APPENDIX A – THE FINAL ARDCORE SPECIFICATION
Specification for Arduino-base General Computational Music Module – the ArdCore
synthesizer module.
Created: 01-01-2011 ddg
Modified: 03-31-2011 ddg Updated pin usage, describe inputs and outputs.
Overview
The creation of this device is a method to provide simplified (and generalized)
programming functionality to the world of analog synthesis. To date, most computational
modules have been purpose-specific (MIDI-to-CV conversion, sequencing); while this is
useful, it does not provide an adequate opportunity for the artist that includes
programming/coding in their practice.
This specification provides the analog modular community with a standardized
use of the Arduino microcontroller system, and will include a large number of example
sketches (programs) that accomplish tasks within the modular world. Any Arduino user
can utilize these specifications to create modules, control systems or computer interfaces,
and will be able to use any programs that others may come up with.
Arduino Use
The most important definition for the use of an Arduino in this environment is to
define the pin attachments. The ArdCore model will use the pins in the following way:
Analog Pins:
Analog In 0 Analog input 0 – knob or voltage
44
Analog In 6 (nano and mega) Analog input 6 – knob or voltage
Analog In 7 (nano and mega) Analog input 7 – knob or voltage
Digital Pins:
Digital Pin 0 Unused (avoids conflict with TX function)
Digital Pin 1 Unused (avoids conflict with RX function)
Digital Pin 2 Clock Input (interrupt-driven)
Digital Pin 3 Digital Output 0 – gate/trigger use
Digital Pin 4 Digital Output 1 – gate/trigger use
Digital Pin 5 8-bit Analog Output - LSB
Digital Pin 6 8-bit Analog Output – 2nd bit
Digital Pin 7 8-bit Analog Output – 3rd bit
Digital Pin 8 8-bit Analog Output – 4th bit
Digital Pin 12 8-bit Analog Output – MSB
45
Digital Pin 13 Unused (avoiding conflict with load display) – OK to
use as indicator, but not used for signal output.
Input Handling
Inputs into the ArdCore module must support the 0-5 VDC range expected by the
Arduino inputs. These will be exposed as the numbers 0-1023 within Arduino sketches.
All of the sketches created assume unipolar inputs; thus, a value of 0 represents zero volts
on the input.
Support for bipolar input will require scaling and offsets to limit the incoming
voltages to support the 0-5V range.
Output Handling
Individual outputs (defined as the “digital outs” on digital pins 3 and 4) will
produce either 0 or 5 volts, and will always be defined in our sketches as outputs. It
would be wise to buffer these two outputs so that current draw on the Arduino is not
excessive.
The DAC (analog) output of the ArdCore is an 8-bit output created by bit-
collecting digital pins 5 through 12, with pin 5 representing the LSB of the output. No
latching of the DAC is provided; rather, the DAC is left “open”, and the bit writing
procedure is on-going. By using a fast DAC and efficient output routines, the slewing of
output is limited.
46
USB Connectivity
It is assumed that the USB port will be available at the device’s front panel. The
ArdCore platform is meant to be a computationally rich, programmer-friendly module, so
having immediate access to the USB connection is vital.
In addition to standard Arduino sketch development, the ArdCore system can use
the Firmata/Maxuino combination to create live interaction between the synthesizer and a
standard computer. Examples are available on the website.
Conclusion
To date, we have created example versions of the circuit boards that support this,
and also have developed many sketches based on this specification, including a stable
quantizer, trigger delay, drunken-walk CV and other useful functions. These are posted
on the 20 Objects site (http://www.20Objects.com/ardcore/) and are completed and
tested.
47
APPENDIX B – MECHANICAL DRAWINGS
48
49
APPENDIX C – DESCRIPTION OF ARDCODE SKETCHES
The 25 available sketches are:
1. 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
a user wants to hand build a version of the ArdCore hardware, the template sketch can
serve as a reference implementation test, proving that the user’s device is meeting the
module specification.
50
2. 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 voltages and make them melodic. Since
quantizers are often very expensive (and inflexible with regards to available scales), this
quantizer is expected to be one of the more inspiring modules for new users of the
platform.
51
3. Drunken Walk Generator
The drunken 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 relatively simple to create digitally. This sketch
will produce a drunken walk at full 8-bit resolution, providing a useful option for non-
pitched modulation.
52
4. Drunken Note Generator
Similar to sketch 3, the drunken note generator implements a drunken walk.
However, in this case, the output is quantized to standard notes, providing melodic pitch
voltages useful for driving oscillators.
53
5. Clock Divider
Clock manipulation is an often-used function with modular synthesizers. The
clock divider allows the creation of 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.
54
6. 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.
55
7. 8-Step Sequencer
Sequencing is a favorite tool in modular production. This sketch performs a
sequence by recording eight discrete steps, then performs playback of these steps when
clocked by an external trigger.
56
8. 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 a delayed gate time to be used, allowing an alternative melody
in time with the original. This sketch allows a delayed gate based on either manual or
voltage control.
57
9. Trigger Delay
Similar to the gate delay, the trigger delay allows delay of a trigger based on
manual or voltage control. This can be useful for creating complex rhythms, or to drive
other clocked modules at an alternative timing.
58
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.
59
11. Glissando (w/Gate)
This sketch extends the transition time between two voltages by a user-selectable
amount. It can be used to slide a melody line between notes, or to smooth otherwise harsh
changes. Both manual and voltage control are supported, and the digital outputs produce
a gate signal that defines the effect’s duration.
60
12. Comparator
Given a manually set breakpoint, this sketch provides two gate outputs that
represent over and under positions (on digital outputs 0 and 1) relative to the breakpoint.
61
13. Slope Detector
A slope detector is useful when interfacing with other voltage-producing modules.
This sketch provides 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.
62
14. Gate Sequencer
Given a clock input, this sketch produces 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. Since the output expander is not
yet available, the results of the first two bits are also reproduced using the digital outputs.
63
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.
64
16. Clock Multiplier
Tangerine Dream, the hallmarks of Berlin School synthesis, used a particular
technique called the “ratchet” in many of their sequences. This effect is used during a
metronomic sequence, where the timing will burst forward for a fraction of a measure,
then return to normal. The clock multiplier produces a timed set of interval outputs on top
of a steady clock, controlled by one of the analog inputs.
65
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.
66
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.
67
19. LFO w/Shaping
Although the ArdCore does not have the necessary circuitry to create smooth
output, creating a low frequency oscillator (LFO) module that produces shaped output
provides an alternative to typical analog LFO’s. There is a mechanism that allows
“warping” of the output waveform, varying between sawtooth, triangle and ramp waves.
68
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
reverses the application to be oriented toward larger swings with more random output.
69
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. This can be used for variations on an echoing effect, and lets a single
stream of data create a complex, multilayered output.
70
22. Output Standards
The output standards sketch is used to produce standard pitches from the analog
output. Adjusting the module’s two knobs can produce any note within the 5 octave range
of the device.
71
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.
72
24. Simple VCO
Created more as an exercise than a useful module, this sketch creates a voltage-
controlled oscillator – a VCO. This is the primary sound generation tool in a 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 of the ArdCore.
73
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 both the knob settings
and by voltages coming into the analog inputs. This can give any phrase a non-
mechanical sound by allowing other modules to alter the envelope activity.
74
APPENDIX D: AN INTERVIEW WITH DAN SNAZELLE
Dan Snazelle is one of the first people to work with the ArdCore system as it was
published on the website. He has a self-taught “hacker’s” background in electronics, and
was trying to learn Arduino programming without much success. He has been tireless in
testing the specification, trying all of the software sketches and providing feedback on the
spec. I felt it would be useful to include a short interview that I conducted via email; it
sheds a little light on how people may find out about this project, and how it can add both
computational and programming aspects to their work.
Q: Dan, could you give me a brief background on who you are and what kind of work
you do in the electronic music realm.
A. My name is Dan Snazelle. I have been a professional musician for many, many years.
I have done everything from soundtrack work, to television music, 12”’s, albums, music
for theatre, playing in bands, and recently, building synthesizers and effects. In 2009, I
started SNAZZY FX. My musical output is very large but for the last couple of years all
of the electronic music I have been recording has been with my hand-made modular
synthesizer.
Q: You've been working with the open source ArdCore specifications and Arduino
sketches. How did you find it, and why did you decide to try using it?
A. I found ArdCore one night out of pure luck. I put in ARDUINO as the search term on
a popular music forum called MUFFWIGGLER and it came up. I immediately contacted
Darwin and began utilizing and studying the sketches. It only took me a few seconds on
the ArdCore site to realize that I wanted to utilize ArdCore. There is such a wide array of
sketches and they are all so obviously focused on electronic music.
75
Q: Which sketches are you most interested in using for your own work?
A: At the moment, I have been using ArdCore for two purposes. One of those uses is as a
tool for learning programming. So for that reason I have focused on a few of the sketches
that I think are going to teach me a lot.
The voltage recorder is significant, because it has the ability to actually store data; the
LFO is helpful, because it is helping me learn how to create waveforms with the Arduino.
I also use the Quantizer a lot. However as far as what I am using for the other purpose –
which is making music – I am using the voltage recorder, the AR envelope, the quantizer,
the two drunken sketches, the oscillator, and the shift register. Every day I play with a
few of the sketches, and most days I make changes to the sketches to see what I can do
with my new programming knowledge.
Q: This is, as far as I know, the first open source, open functionality computational
module that's been created. What about this platform is attractive to you?
A. ArdCore has been allowing me to figure out a lot of things. First off, I have only
recently begun programming. I was not sure how far I could really go with the Arduino,
what it is capable of. ArdCore has provided me with sketches that I can understand more
as I study them. And from day one they have provided great results.
Q: How difficult was it for you to create your own hardware to run the ArdCore
sketches?
A. I found the process of creating the ArdCore hardware quite easy. All I had to do was
hook up a few op amps, a trimmer, some jacks and a DAC. Compared to building a VCO
or a filter it was quite easy.
Q: This sounds like you are pretty familiar with electronics (as would be implied by your
76
use of a hand-made synthesizer). How difficult do you think it would be for a less
experienced person to build a suitable module?
A: I don’t think it would be too bad. If you compare the ArdCore hardware requirements
to most other Arduino projects, it really isn’t too tough of a project.
At most you need a few pots, some jacks, a few op amps, and a DAC.
Keep in mind; all of my electronics knowledge was self-taught. The first thing I ever
built, I built straight from a schematic and it had far more parts than this!
Q: You've been using the sketches to learn programming yourself. How long have you
been working on programming, and why did you choose this approach?
A. I have been learning to program for, at most, three or four months. Before I found the
ArdCore I was mainly learning out of books and by looking at the forums for Arduino.
This method was nowhere near as beneficial as looking at the ArdCore sketches, testing
them, playing with them, and then asking Darwin questions. I feel that I know a lot more
than I did at the beginning of February when I first found the ArdCore specification.
Q: Do you imagine that you will add to the software that is available for the ArdCore, or
will you just use existing sketches?
A. I hope that as soon as my programming skills are good enough that I will be able to
add sketches. I have already saved quite a few “modified” versions of the sketches.
Modifying the existing sketches has been a good way to teach myself what is going on in
the programs.
Q: How important is it to you that the ArdCore system is open source, and is built off the
open source Arduino platform?
77
A. I think it is very important. I think it will encourage people to add more sketches, and
to form a community around ArdCore.
Q: Developing a community for anything is difficult because there are a lot of ideas
competing for people's attention. Do you think the ArdCore system has a chance of
developing a following?
A: I think one of the really nice things about ArdCore is the way that Darwin has
included a template in addition to the sketches. People in the user community can look to
this for a model of how to do their own sketch and he has provided enough examples that
you can get a clear idea of some places to take the system. I have told a few people about
ArdCore and they were immediately excited by just how many modular synthesis-
specific sketches there were. There really is nothing else like it out there. I think by
starting with so many sketches, Darwin has built in some guaranteed excitement!
Q: The Arduino is a notoriously slow microprocessor in comparison to many other

options. Does this concern you for your planned uses?
A. This is something I am trying to learn more about. I know that using the analogRead
function is a sure way to slow things down and I know there are ways around it like using
BitClear and BitSet. Speed is important for some situations but since Arduino can
understand C, I don’t see it as a big problem.
Q: Are there any issues that you've run across with the ArdCore specification or software
that you wish was different?
A. I would like to see more extensive commenting. I think this is something that could
help people learn. It may come out of more people using ArdCore and adding their own
comments. Since more people may be using these sketches that have little programming
experience, the more information there is the better.
78
Q: Are there any ArdCore sketches that you would like to see? How likely is it that, at
this stage, you could program them yourself?
A. I would like to see an ADSR and more oscillators. I think an ADSR is too advanced
for me at this point so for now I will most likely try to learn to make an oscillator.
Another thing I would like to try and do is combine a few ARDCORE sketches. I feel
like the sky is the limit with this system!!
79
APPENDIX E: AN INTERVIEW WITH GRANT RICHTER
Grant Richter was very helpful in the initial designs of the ArdCore circuitry, and
has been helpful throughout the modular synthesizer community by providing completed
circuits and other designs for DIY use. He is also the creator of the Wiard Synthesizer
system, one of the earliest “modern” modular systems.
Q. Your design of the Wiard Miniwave was the first time I'd seen the use of digital
waveform files within an analog modular system. What made you want to design this
circuit, and were you aware of any earlier designs?
A: After the first generation of music synthesizers which generated waveforms, all of
which were computed in a continuous time/continuous level domain, there was a class of
instrument developed whereby waveforms were stored in a quantized time/quantized
level form necessary for the technology of the time. Some examples would be the
Ensoniq Mirage and Ensoniq ESQ-1. The musical tambours produced by the quantization
effects and aliasing were unique to that type of instrument and were found to be
musically useful.
The earliest example of this technology appearing in a modular analog format was the
Digisound-80 VCDO. This was implemented using a high-speed exponentially
responding analog VCO core clocking a counter which was used to address the address
lines of a digital read-only memory. The difficulty in this type of design is designing an
80
accurately tracking exponential core at ultrasonic and low radio frequency ranges needed
for the division produced by the address counter.
In the early days of analog computing there was a device known as a lookup table,
wherein an input voltage pointed to a stored digital value that was then converted to an
analog output voltage.
I had the realization that an ascending analog ramp into this lookup table would act
identically to the address generation used in the first implementation of a voltage
controlled digital oscillator (wavetable) without the over-clocking required by that type
of design. This produced the desired result.
An additional benefit of this was the lookup table with voltage input and voltage output
could be used for non-linear synthesis. Non-linear synthesis starts with a waveform of
low harmonic content and by selective distortion adds harmonic content. This is one of
the least explored of the known synthesis methodologies, and my design provided both
the benefits of a wavetable oscillator and a non-linear transform generator.
Q. You have experimented with analog computing within sound productions systems.
Could you explain how this works, and how useful you found it?
A: The answer requires a short digression into set theory.
81
A theoretical set "c" is believed to exist which has a cardinality (number of elements)
equivalent to the real numbers. This set is referred to as the continuum.
Quantum mechanics would suggest that the universe as a whole is quantized, but the
probabilities of quantum events rise in a discrete time period to a continuous function and
therefore this does not contradict the existence of the continuum set called "c". This is
equivalent to the mathematical computing basis of so-called analog computing, and refers
to continuous time/continuous level computing.
In an informal sense, this is equivalent to the mathematics of "reality".
Computers do not have sufficient capacity to store the amount of information generated
by "reality". Therefore, they operate on reduced information sets which are quantized
both time-wise and level-wise. There are audible artifacts produced by the process of
restricting the information of the set. The reason this effect occurs is not completely
understood, but it must be related to some evolutionary process.
The use of computing in the continuous level/continuous time domain does not produce
the artifacts of information reduction generated by digital technology, therefore some
people consider the musicality to be superior. One could theorize that the reason for the
82
apparent musicality of this method is that it uses the same mathematical basis as acoustic
instruments.
Q. You have been very helpful to me (a beginner) in getting a circuit designed, and you
have been helpful with others over the years. How do you think this has changed modular
synthesizer design? Do you feel like sharing has helped you, hurt you or not affected you.
Musical engineering, or the effort to develop electronic circuitry which possesses musical
qualities, is the intersection of a large number of fields of knowledge, including
engineering, musicianship, acoustics, and physiology. Until very recently it was not
possible to study this in a concentrated form in a university environment. Therefore, this
compound information existed in essentially a tribal form. The dissemination of tribal
knowledge is a time-honored practice of mentorship, and applies directly to the very wide
scope of information required for the design of electronic musical instruments.
The health of an ecosystem is measured by its biodiversity. If we were to use Richard
Dawkins' idea of memes, or a biological model of information transmission, then the
memetic diversity of a system is an indication of the robustness of that system.
83
APPENDIX F: AN INTERVIEW WITH BRIAN CRABTREE
Brian Crabtree and Kelli Cain are the two principals for the company monome,
which creates musical controllers for the performing artist. The way that he developed his
company, the approach he has taken with sustainable development and the openness of
both his hardware and software were all an inspiration when developing the concepts
behind the ArdCore module.
Q: To begin with, could you describe the monome organization, what you
do and what you produce?
A: after five years monome continues to be only two people, myself and my wife kelli
cain. we produce an adaptable grid controller which is principally used in music made
with computers.
Q. How did you become interested in making a control device for music creation, and to
what extent did you think that it would be as widely embraced as it has been?
A: in my early days of making electronic music (90's) i went through a lot of commercial
gear, seeking a versatile way to perform live. after discovering max/msp i realized that a
dynamic physical controller was the missing element. a decoupled grid seemed to match
the countless possibilities of the music programming environment, and the journey
began.
84
the idea was very hard to sell. two years later when i had a working prototype it was quite
the opposite-- the performance capability mesmerized audiences. recall around 2004
there weren't a lot of alternative interfaces available. i lent the prototype to my friend
alfred darlington (who goes by daedelus) who promptly went on world tour and achieved
substantial fame. internet video was just appearing, and my early demos quickly filled my
inbox with requests to purchase. kelli and i had been collaborating on mechanical art
installations and were getting better at building things, so we decided to produce a small
edition.
the initial success was sufficient to cover our expenses. it was not instantly adopted as the
use was unclear, the paradigm new and foreign. but acceptance accelerated quickly.
eventually a DIY clone became popular, then larger corporations started noticing the
"grid controller market."
i'm surprised we've gotten this far, but only because i was so busy and freaked out in the
early days that i didn't even have time to envision where we were going.
Q: One of the things that intrigues me about the monome is that it allows for
idiosyncratic application creation; in fact, each of the programs developed for the
monome has a unique interface/interaction. How is this important for the users of the
monome, and how has it helped with the creation of a supportive community?
85
A: each unique program ends up being a sort of artwork in itself, while also being a tool.
i've become very attentive to tools and how they shape my work. by using some huge
corporation's idea of an instrument, you're subscribing to their idea of what sort of music
or kinds of sound to make. monome devices allow the user to cut to the lowest level of
logical function, which may be at first daunting, but ultimately allows a freedom and
flexibility that encourages what i feel to be the most sincere process of creation.
i think the monome community enjoys the collective exploration. it's encouraging to see
people sharing ideas. it's rewarding for users who share their applications to hear music
made using their tools, in addition to the endless thanks.
the minimal interface encourages tactile, playful applications. most of these inspire a lot
of joy-- i've seen countless videos of community members' kids using the device.
positivity seems to radiate around this design.
Q: As a business entity, you and Kelli made some radical (at the time) decisions: you
would make the entire framework open-sourced, and would focus on creating an
attractive implementation of the ideal. What led you to make this decision, and how has it
affected your business?
A: the nature of the device required a fairly detailed description of the communication
86
protocol. the best way to show people how to use this was with example applications, and
many of these examples were fully-functional performance tools. i wanted other people
to be able to modify and improve these, in hopes of encouraging the same attitude.
the circuit and firmware included some open-ended auxiliary features (pins to read
encoders, pots, tilt, etc), and some of the early adopters i knew were very tech-savvy, so
open-sourcing the hardware seemed to make sense. i figured if someone were to steal the
design, they'd do it no matter what. i couldn't afford legal expenses. we didn't bother
copyrighting anything. so we gave everything away and hoped it'd create good energy.
i do think open-sourcing everything has encouraged further sharing which is central to
the monome community. it's a fundamental part of our business model (though we never
formally planned it), so that i'm not frantically releasing new applications to attract users
or keep existing users interested. it's an avalanche that i helped start, but largely drives
itself now.
Q: Beyond the business aspects of monome, the monome device also seems to represent
your personal design aesthetic. You recently released a new product, the arc, which
shares many of the design and performance aspects of the monome. How important do
you think the designs are to people's approach to these devices?
A: people respond to good design. details are important. as a dedicated minimalist i try to
87
strip everything away, and whatever remains must approach a sort of perfection. the
blank-slate nature of the design i find liberating and unimposing, and i hope that it invites
users to embrace the surface as their own, rather than simply subscribing to a logo.
Q: One of the things that seemed to catch people's interest when the monome was first
available was the ‘mlr’ application that you designed. Was the program primarily
developed for your performance work, as a demo of the monome - or for some other
reason?
A: mlr was designed for performance and as a compositional tool, just before the
monome prototype was finished. it was instantly clear that mlr was a perfect fit for the
physical grid, allowing me to get my hands inside a max patch like never before. the
visual grid correlation made intuitive sense, improvisation felt completely natural.
i've never really written a patch exclusively as a demo. my method of promotion is to turn
on a video camera whenever i'm working on something i think is exciting. though
sometimes getting a good take is a lot of work.
Q: To what extent did you work on community development? Was it an active process, or
were you just the recipient of good luck in this regard? Do you think that a community
can be "generated" (something that seems to be at the heart of a lot of commercial social
interaction marketing right now)?
88
A: i don't believe a community can be generated. it took a lot of work, and takes a lot of
over-enthusiastic encouragement, behind-the-scenes moderation, and boundless amounts
of positivity (people who know me in real life will confirm that i can be pretty grumpy).
but cynicism aside, some very fantastic things have happened in the community, and it's
full of talented, giving people.
Q: What question(s) did I forget to ask that might be important within this context?
A: we're deeply dedicated to sustainable practice. not just using recycled packaging,
either. we acknowledge the great responsibility that comes with the choices we make
regarding materials, sources, and manufacturers. our parts are locally made, at small
companies that we've visited and have good working relationships. the wood we use is
sustainably harvested nearby. we don't operate with bank debt. we're engaging in an
economy that we can feel good about at every step.
89

The ArdCore Project - Final

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

The ArdCore Project - Final

Uploaded by

Copyright:

Available Formats

Development of the ArdCore Computation Module

The Faculty of Arts and Humanities

of the Requirements for the Degree

Advisor: Trace Reddell

All Rights Reserved

an Arduino-based computational device for analog modular synthesizers. In this

Background Learning and Experience.............................................................................. 16

The Reference Device....................................................................................................... 32

Open Source Production ................................................................................................... 35

Future Plans ...................................................................................................................... 39

Appendix A – The Final ARdcore Specification.............................................................. 44

Appendix B – Mechanical Drawings................................................................................ 48

Appendix C – Description of Ardcode Sketches .............................................................. 50

Appendix D: An Interview with Dan Snazelle ................................................................. 75

Appendix E: An Interview with Grant Richter ................................................................. 80

Appendix F: An Interview with Brian Crabtree ............................................................... 84

The ArdCore Module

monolithic analog synthesizer. This type of synthesizer, unlike popular keyboard

general-purpose computational platform that provides the opportunity to use embedded,

module functions without any hardware redesign.

information through a website. 20objects.com, a website (and business entity) maintained

by providing centralized downloads, information pages, video documentation and user

technologies and open source hardware development, it is useful to contextualize it

important to understand this project’s historical positioning.

Computers in Electronic Music Experimentation

Initial Sound Experiments

experiments in computer sound and music. The first computer-created composition, In

provide more compositional complexity, leading to work by composers like James

to think of modern electronic emulations of pianos or woodwinds; this would be

experiments with computer-produced noise (Théberge 1997, 223). But composer/sound

new computer-based systems.

computer media development an interactive experience.

Microprocessors and Digital Sound

The use of microprocessors built into standard keyboard instruments introduced

digital technique into interactive sound design. Sequential Circuits, an electronic

of settings as a “preset” – an approach conceptually similar to Matthews’ MUSIC-N

These hybrid synthesizers, including the Sequential Circuits Prophet 5, Roland

this new generation of digitally-controlled synthesizers, and especially the development

changes developed by the user (Chadabe 1997, 202-212).

While some first-generation microcomputing systems (particularly the KIM-1 and

Holmes 2008, 275-280).

Integration of Programming in EM Practice

a real-time programming environment (eventually named Max as a nod to Matthews) that

allowed programmatic access to IRCAM’s 4X hardware system. While the hardware

sound generating and compositional mechanisms maintained within the computer. As

Generator/Reaktor, AudioMulch) offered real-time graphical programming tools for

interactive audio output (Manning 2004, 399).

As a result, programming languages have become a mechanism for the creation of

artist-friendly (or less adverse) programming languages and development environments.

The ArdCore computational module is an attempt to provide this sort of environment to

the generation of compositional data: melodic line development, timing alterations or

Modular Analog Synthesis in EM Development

instrument, which lead to a different progression in their design.

Modular Synthesis Development

While the beginning of the electronic synthesizers can be traced to Thaddeus

manufacturers to try simplifying the systems and attempt engineering-focused methods

eventually into computer-based synthesizers (Manning 2004, 296-304).

In order to capitalize on this market, this generation of modular system developers

Modular Synthesizer Roles in Sound Design

Use of modular synthesizers is now a part of experimental electronic music

reduce the capabilities of the artist-producer.

difficulty of introducing precise algorithmic functions into generative work, and

MIDI. It is within this context that my project introduces a programmable, modular-

centric computational device that can solve many of these problems.