Lab 2: Sensors => Chuck

In this lab, you'll learn how to control the parameters of a synth running in ChucK using sensors connected to a microntroller (Teensy).

Download this lab's code here.

Electronic Basics

Review this brief introduction to electronics on the CCRMA Wiki.

Sensors and Teensy Basics

A wide range of sensors act as resistors (e.g., Force Sensitive Resistors, photoresistors, SoftPots, flex sensors, etc.) and can be used to dynamically change the amount of current circulating in a circuit.
Microcontrollers such as the Teensy can be used to digitize the signal delivered by a sensor in a circuit (which is the same as measuring the amount of current in the system at regular time intervals).
Mount your Teensy on your breadboard as follows:

Install the Teensy Loader on your system and follow the instructions to test your Teensy: https://www.pjrc.com/teensy/loader.html
Install Teensyduino on your system: https://www.pjrc.com/teensy/td_download.html
Make a circuit connecting a Force Sensitive Resistor (FSR) to the analog input 0 (A0) of the Teensy:

Notice the use of a 10k pull down resistor.
Let's now retrieve the FSR signal on your computer and plot it in the debugger! First, upload this program to your Teensy:

void setup() {
  Serial.begin(9600); // initializing serial port
}

void loop() {
  int sensorValue = analogRead(A0); // retrieving sensor value on Analog pin 0
  Serial.println(sensorValue);
  delay(30); // wait for 30ms
}

Note that we pause the loop for 30ms at every cycle to not overload the serial output. The same approach will be used for MIDI.
Open the serial debugger and make sure that your system is working by pressing the FSR. Note that the output value is a 10 bits integer (value between 0 and 1023).
We now want to transmit the sensor data to ChucK instead of plotting them in the serial debugger. We'll use MIDI for that. If you're not familiar with the MIDI standard, check this tutorial.
MIDI data can be transmitted over USB using the Teensy. For that, Bounce.h must be included in your program:

#include <Bounce.h>

usbMIDI.sendControlChange() can be used to send MIDI control events (CC). This function takes three arguments: the MIDI CC number, the value to send, and the MIDI channel number (0-15). The first two values should be 7 bits integers (0-127), per the MIDI standard.
Since the value to be sent needs to be a 7 bits integer, sensorValue must be scaled down to fit within this range:

int midiValue = sensorValue*127/1024;

The previous code can now be updated to send MIDI values instead of plotting sensor data to the terminal:

#include <Bounce.h>

void setup() {
}

void loop() {
  int sensorValue = analogRead(A0); // retrieving sensor value on Analog pin 0
  int midiCC = 0;
  int midiValue = sensorValue*127/1024; // value between 0-127
  int midiChannel = 0; // doesn't really matter
  usbMIDI.sendControlChange(midiCC,midiValue,midiChannel); // sending on CC 0
  delay(30); // wait for 30ms
}

To summarize, we're sending the signal measured at analog pin 0 to MIDI CC 0 on channel 0 every 30ms. The value of midiChannel doesn't really matter as it will be ignored by ChucK.
We now want to turn the Teensy board into a MIDI device. For that, select Tools/USB Type/MIDI.
Upload the program to the Teensy.
In a terminal window, type:

chuck --probe

This should list the MIDI devices connected to your computer, your Teensy should be one of them.
Open MiniAudicle and write the following program:

// synth algorithm
SawOsc saw => dac;

// synth default params
50 => saw.freq;

// number of the device to open (see: chuck --probe)
1 => int device;
// get command line
if( me.args() ) me.arg(0) => Std.atoi => device;

// the midi event
MidiIn min;
// the message for retrieving data
MidiMsg msg;

// open the device
if( !min.open( device ) ) me.exit();

// print out device that was opened
<<< "MIDI device:", min.num(), " -> ", min.name() >>>;

// infinite time-loop
while( true ){
  // wait on the event 'min'
  min => now;

  // get the message(s)
  while( min.recv(msg) ){
    if(msg.data2 == 0){ // 0 is the MIDI CC number
      // formating sawtooth freq
      msg.data3*10 + 50 => saw.freq;
    }
  }
}

A MIDI input device is created and is selected with the int device variable. Note that it might be different on your computer, make sure int device matches the ID of your Teensy when executing chuck --probe. When the received message is sent on MIDI CC 0 (see msg.data2 == 0), the value of the message (msg.data3, which is a 7 bits integer) is formatted to have the desired range to control the frequency of the sawtooth oscillator.
Run the ChucK program and try to control the frequency of the oscillator with the FSR.
Now you might notice that there are some "clicks" (or steps) when changing the frequency of the oscillator (this would be even more obvious if using a sine wave instead of a sawtooth). This is due to the fact that the value of the frequency is only updated every 30ms and that it is quantized to a 7 bits integer.
This problem can be easily solved by interpolating the values of the frequency parameter using vec3:

// synth algorithm
SawOsc saw => dac;

// oscillator base frequency
50 => float baseFreq;

// the interpolator
vec3 i;
// the interpolation rate
2::ms => dur irate;
// set initial .value, .goal, .slew
i.set( baseFreq, baseFreq, .05 * (second/irate) );

// function to drive interpolator(s) concurrently
fun void interpolate( dur delta )
{
  while( true ){
    // interpolate oscillator frequency
    i.interp( delta ) => saw.freq;
    // advance time by rate
    delta => now;
  }
}

// spork interpolate function
spork ~ interpolate( irate );

// number of the device to open (see: chuck --probe)
2 => int device;
// get command line
if( me.args() ) me.arg(0) => Std.atoi => device;

// the midi event
MidiIn min;
// the message for retrieving data
MidiMsg msg;

// open the device
if( !min.open( device ) ) me.exit();

// print out device that was opened
<<< "MIDI device:", min.num(), " -> ", min.name() >>>;

// infinite time-loop
while( true ){
  // wait on the event 'min'
  min => now;

  // get the message(s)
  while( min.recv(msg) ){
    if(msg.data2 == 0){ // 0 is the MIDI CC number
      // formating sawtooth freq
      msg.data3*10 + baseFreq => i.update;
    }
  }
}

Try to run this code and listen to the result.

Exercise 1: Adding a Lowpass Filter and Controlling Its Cutoff Frequency

Try to add a lowpass filter to your synth algorithm:

SawOsc saw => LPF lowpass => dac;
50 => saw.freq;
100 => lowpass.freq;
7 => lowpass.Q;

and control its cutoff frequency using a different sensor (e.g., a photoresistor). Try to change the mapping of the sensors to come up with interesting interactions.

Exercise 2: Add a Toggle Switch to Your Instrument

Add a physical toggle button to your system. When pressed the first time, it should turn the synth on, when pressed a second time, it should turn it off, and so on.
This can be achieved by adding a Gain unit generator to your synth algorithm and change its value between 0 and 1:

SawOsc saw => LPF lowpass => Gain g => dac;
1 => g.gain; // on
0 => g.gain; // off

Make sure that your system is efficient and that your "on" and "off" MIDI messages are only sent to ChucK when necessary.

Optional Readings

Ed Berdahl's tutorial on sensors: https://ccrma.stanford.edu/wiki/Sensors
Browsing the sensors section of the SparkFun and Adafruit websites can be a good source of inspiration.

Assignment (Due on Jan. 25, 2018)

Make an instrument combining any ChucK synthesizer(s) to any sensor(s).
You should be able to switch it on and off using a physical button used as a toggle.
Make sure your instrument is playable and musical.
Make a video of yourself playing it and post it on YouTube.
Send the link of this video along with the source code of your instrument to by Jan. 25, 2018.