Creative Technology

1. Networked Sound Ecologies

2018-01-30T08:00:00-08:00

brief

Students explore strategies for creating a networked sound ecology, or a rich environment that evokes a (potentially otherworldly) location, by way of leveraging embedded technologies (Raspberry Pi 3), network communication strategies (OpenSoundControl), and basic sound synthesis techniques (SuperCollider3).

Each student will create 2 sounds: a background sound and a foreground sound. The background sound should productively contribute to an overall jungle or rainforest atmosphere. The foreground sound should mimic an animal or other being that is heard above or in addition to the jungle/rainforest atmosphere. Students are challenged to create a unique background sound that blends well with the group sound as well as a foreground sound that exhibits some distinct personality (for example: a scared pig, a sleepy bird). Students are further challenged to design a structure for rate of message sending that promotes the desired environment (i.e. does not result in pure chaos).

Students will deploy their foreground and background sounds to Raspberry Pi 3 and control them via a Graphical User Interface (GUI) from their laptops over the network (using Open Sound Control). We will demo, or perform, the environment in the gallery as part of our final critique.

requirements

A background sound: textural, sustaining envelope (written in SC3)
A foreground sound: evoking a creature or being with a distinct personality, deterministic envelope (SC3)
Deployed to Raspberry Pi 3 (launches automatically)
Controlled from a Laptop via GUI (SC3)
Message sending protocol reinforces environment (taking pins & splits as an example)

11. Mark Trayle's pins & splits

2018-01-26T08:30:00-08:00

Mark Trayle

Mark Trayle (January 17, 1955 – February 18, 2015), my mentor during Grad School, was an incredibly inspiring musician, composer, and technologist. His work frequently used repurposed consumer products (Wacom Tablets, Credit Card Readers, etc.) to creative ends, and he was a big proponent of designing "computer-native" approaches to improvisation and experimental music. Mark was a pioneer of network-based live electronic music, a technology-driven approach to ensemble improvisation he researched and developed with his colleagues in The Hub as well as in his personal work.

pins & splits was written in 2014 and performed extensively around that time. After Mark passed we continued performing the piece. It is an incredibly strong example of everything I love about Mark's work. It is also a excellent introduction to thinking through approaches to interaction over the network. To begin our discussion of network-based communication for sound ecologies we will spend the rest of the day experimenting with this piece.

pins & splits

What follows is what Mark distributed to performers as the Score to pins&splits (note: I have redacted some things that were instructions to instrumentalists who performed with the laptops). Though he referred to this writing as a "control spec" one can also think of it as a set of instructions for how the piece works as well as what sounds should be designed.

////// PINS & SPLITS!!!!

Mark Trayle, 2014

In pins&splits players alternate between a single 'background' sound and a set of one or more 'foreground' sounds. A player's foreground sound can be triggered by another player at any time, causing the background sound to stop. After a relatively short period of time, say, in the 1 - 10 second range, the foreground sound stops, and the background sound starts again.

Players have no control over their own foreground/background switching, that's done by other players in the group.

Players do have control over certain parameters of the sounds they make.

My intention is to create quickly changing instrumental groupings and sonic textures through a limitation of sonic material and the interruption of the performers' musical flow.

Messaging and Musical Flow

This section is primarily intended for the laptop players. It’s rather technical.

Start by making the background sound. When you receive an OpenSoundControl message of the form… /<yourname> /<sender> /switch /density <float 0…1> /dur <float 1…10>

Check to make sure that <yourname> identifies you, and if it does, start the foreground sound and apply the /density value to it in a way you deem appropriate. After /dur expires the foreground sound should stop and you should return to the background sound. Send /switch messages to anyone in the group at any time you wish. You should have direct control of the timing of the messages and the value of the /density and /dur parameters, i.e., a performer interface rather than an algorithm.

Notes and a Variation (for all)

Background sounds should be relatively quiet (p-pp) and static.
Foreground sounds should stand out from the background.
You could decide to pick a different range of foreground duration, as the occasion sees fit.
You can react to /switch messages with as many different sounds, sound-events, sound-aggregates, etc., as you like.

Specifics for Laptopists

You’re free to use any sounds you like. However, keep in mind that this should be a very active piece, I suggest avoiding sounds that take a long time to develop, anything too “drone-y”, for your foreground palette. Drones are fine for background sounds. Samples are okay, maybe even encouraged as the rest of the concert contains 0% sampled material. Shorter samples would be better, and they can always be stretched out. And samples would be better in the foreground palette.

Code

Note: from a sound design perspective this is definitely the most boring version of this piece possible

/*

pins and splits, Mark Trayle, 2014
code by Casey Anderson


density range = 0.01..1.0
trayle duration range = 1.0..10.0
bitpanic duration range = 5.0..25.0

*/

s.boot;

(
// setup database of IPs

~ips = Dictionary.newFrom(
    List[
        "partner", "",
        "me", ""
    ]
);

~names = ~ips.keys;

~listofnames = ~names.as(List);

~states = ~listofnames.collect { |name|
[name, Color.white, Color.grey]
};

~addresses = ~listofnames.collect { |name|
NetAddr(~ips[name], 57120)
};


// control bus

~density = Bus.control(s, 1).set(0.25);
~duration = Bus.control(s, 1).set(5.0);
~backAmp = Bus.control(s, 1).set(0.0);
~foreAmp = Bus.control(s, 1).set(0.0);

)

///////// SYNTHS /////////

(

/*background sound
(this is too boring for use in this piece
but enough to demonstrate the structure)
*/

SynthDef( \background, {| amp = 0.0, out = 0, trig = 0 |
    var env, sig;

    env = EnvGen.kr( Env.asr( 0.1, 0.9, 0.1 ), trig,  doneAction: 0 );
    sig = PinkNoise.ar( amp ) * env;
    Out.ar( out, Pan2.ar( sig ) );

}).add;


/*foreground sound
(also too boring for use in this piece
but different enough to be a noticeable
change upon receiving a switch message)
*/

SynthDef( \foreground, { | amp = 0.0, dur = 4, freq = 300, out = 0, trig = 0 |
    var env, sig;

    env = EnvGen.kr( Env.linen( 0.01, dur, 0.01 ), trig, doneAction: 2 );
    sig = SinOsc.ar( freq, 0.0, amp ) * env;
    Out.ar( out, Pan2.ar( sig ));

}).add;


// switcher function

~switcher = { | msg, tm, addr |

    var dens = msg[1], dur = msg[2], rPos, bufNumber;
    postln( "pins and splits "++msg );

    ~back.set(\trig, 0 ); // turns background off

    // foreground goes here

    Synth(\foreground, [\amp, ~foreAmp.asMap, \dur, dur, \trig, 1, \freq, { rrand(200.0, 500.0).asFloat }.value ]);

    SystemClock.sched(dur, {

        // turn the background synth back on after dur

        ~back.set( \trig, 1 );

    });
};


)


// GUI

(

~window = Window.new("pins&splits", Rect(0,0,470,280))
    .onClose_({
    "CLOSING".postln;
    OSCdef.freeAll;
    ~back.free;

});


// background sound controls
~button = Button(~window, Rect( 10, 10, 50, 50))
        .states_([
            ["OFF", Color.white, Color.black],
            ["ON", Color.white, Color.red]
        ])

.action_({ arg butt;
    if( butt.value == 1,
        {
            "START THE SWITCHER".postln;
            OSCdef(\whatever, ~switcher, \switch );
            "RUN BACKGROUND".postln;
            ~back = Synth( \background, [ \trig, 1, \amp, ~backAmp.asMap ]);
        },
        {
            "STOPPED BACKGROUND".postln;
            ~back.set(\trig, 0);
            ~back.free;
            "KILLED SWITCHER".postln;
            OSCdef(\whatever).free;
        }
    );
});

~backAmpSlider = Slider.new(~window, Rect(65, 10, 50, 200))
.action_({ |slider|
    var val = slider.value;

    ~backAmp.set(val);
    ~backAmpVal.value_(val); // show slider value in number box
});


~backAmpVal = NumberBox(~window, Rect(65, 215, 50, 25));
~backAmpVal.align = \center;
~backAmpVal.value = 0.0;

~backAmpLabel = StaticText(~window, Rect( 65, 245, 50, 25));
~backAmpLabel.align = \center;
~backAmpLabel.string = "back";
~backAmpLabel.background = Color.white;


~foreAmpSlider = Slider.new(~window, Rect(120, 10, 50, 200))
.action_({ |slider|
    var val = slider.value;

    ~foreAmp.set(val);
    ~foreAmpVal.value_(val); // show slider value in number box
});


~foreAmpVal = NumberBox(~window, Rect(120, 215, 50, 25));
~foreAmpVal.align = \center;
~foreAmpVal.value = 0.0;

~foreAmpLabel = StaticText(~window, Rect( 120, 245, 50, 25));
~foreAmpLabel.align = \center;
~foreAmpLabel.string = "fore";
~foreAmpLabel.background = Color.white;


// network control

//select person to send to

~sendto = Knob.new(~window, Rect(185, 10, 50, 50))
.action_({ |knobval|
    var maxval, val;
    maxval = (~listofnames.size) - 1;
    val = [0, maxval, \lin, 1].asSpec.map(knobval.value);
    { ~whom.value_(val) }.defer;
});


// display sendto's hostname

~whom = Button(~window, Rect( 245, 10, 100, 50))
.states_(~states);


// send the message!

~sendNow = Button(~window, Rect( 185, 65, 160, 50))
.states_([
    ["SEND", Color.white, Color.grey],
    ["", Color.red, Color.red]
])
.action_({ |val|
    var num = val.value;
    if( num == 1, {
        // send here
        var addr = ~addresses[~whom.value];
        ("//send to " ++ ~listofnames[~whom.value] ++ "!!").postln;
        ~duration.get({ |durValue|
            var dens, dur = durValue, ip;
            ~density.get({ |densValue|
                dens = densValue;
                addr.sendMsg(\switch, dens, dur);
                SystemClock.sched( 0.25, {
                    { ~sendNow.value_(0) }.defer; // resets sendNow
                });
            });
        });
    });
});


// density

~densSlider = Slider.new(~window, Rect(355, 10, 50, 200))
.action_({ |slider|
    var val = [0.01, 1.0, \lin, 0.01].asSpec.map(slider.value);
    //set bus
    ~density.set(val);
    ~densNumber.value_(val); // show slider value in number box
});

~densNumber = NumberBox(~window, Rect(355, 215, 50, 25));
~densNumber.align = \center;
~densNumber.value = 0.0;

~densLabel = StaticText(~window, Rect( 355, 245, 50, 25));
~densLabel.align = \center;
~densLabel.string = "dens";
~densLabel.background = Color.white;


// duration

~durSlider = Slider.new(~window, Rect(410, 10, 50, 200))
.action_({ |slider|
    var val = [5.0, 25.0, \lin, 0.01].asSpec.map(slider.value);
    //set bus
    ~duration.set(val);
    ~durNumber.value_(val); // show slider value in number box
});

~durNumber = NumberBox(~window, Rect(410, 215, 50, 25));
~durNumber.align = \center;
~durNumber.value = 0.0;

~durLabel = StaticText(~window, Rect( 410, 245, 50, 25));
~durLabel.align = \center;
~durLabel.string = "dur";
~durLabel.background = Color.white;

~window.front;

)

11. SC on RPi

2018-01-26T08:00:00-08:00

Fredrik Olofsson is my hero and has an incredibly convenient SuperCollider standalone to run SC on our Pi's. It's worth bookmarking his repo on the off-chance that something changes later or you need to revisit some instructions in the future. You should have two versions of this installed on your rpi: 1 under the pi user and the other under the user you created on Tuesday.

Running SC on RPi

Interactive

The most basic way to run SuperCollider on RPi is the method you used to confirm that SC works on your new user in Fix Things for New User:

cd supercolliderStandaloneRPI2
xvfb-run --auto-servernum ./sclang -a -l sclang.yaml

Once Jack and SC are done booting you should see something like this:

If you wanted to run code line-by-line, or troubleshoot why something is leading to problems on the Pi specifically, this would be a logical way to start SC.

Running a Specific File on Boot

Frederik's SC Standalone Repo has one example .scd file in it called mycode.scd. Click here to view it in the browser.

Here we see a previously unfamiliar Server method: .waitForBoot. If one wants to boot Jack, SC, and run a particular .scd file one needs to wrap one's code in s.waitForBoot. For more information on this method see the Documentation.

Running a File on Boot with SC is only slightly different than the way one launched the program for Interactive Programming. Try the following to run the mycode.scd example included with the SC Standalone:

cd supercolliderStandaloneRPI2
xvfb-run --auto-servernum ./sclang -a -l sclang.yaml mycode.scd

Note that the only difference between these two methods for starting SC on your Pi is the presence of a particular filename in the latter example.

Communicating with SC from Your Laptop

Interestingly enough the example we were using to play sound on a partner's laptop via OSC can be repurposed, with some minor changes, to control sound playing on one's RPi from a laptop. First the code:

Receiver

// receiver on a pi example

s.latency= 0.05;

s.waitForBoot{

    // the example synth that will be controlled. note the standardized arguments: amp, freq, trig

    SynthDef( \sin, { | amp = 0.0, freq = 440, out = 0, trig = 0 |
        var env, sig, finalSig;
        env = EnvGen.kr( Env.asr( 0.001, 0.9, 0.001 ), trig, doneAction: 0 );
        sig = SinOsc.ar( freq, 0.0, amp );
        finalSig = sig * env * 0.6;
        Out.ar( out, Pan2.ar(finalSig) );
    }).add;


    // receive messages from another computer to change Synth at ~x

    OSCdef(\sinResponder, { | msg |

        msg.postln;

        switch( msg[1],
            '/run',{
                "starting the synth".postln;
                ~x = Synth( \sin, [ \freq, 400, \amp, 0.8]);
            },
            '/play', {
                "play sin".postln;
                ~x.set(\trig, 1);
            },
            '/stop', {
                "stop sin".postln;
                ~x.set(\trig, 0);
            },
            '/vol', {
                ("vol "++msg[2]).postln;
                ~x.set(\amp, msg[2].asFloat );
        },
            '/free', {
                "freeing synth".postln;
                ~x.free;
            });
}, '/sin');

};

Sender (Line-by-Line Version)

s.boot;

// setup

(
~ip = "";
~x = NetAddr(~ip, 57120);
)

// sending messages

// make the synth

~x.sendMsg('/sin', '/run');

// turn the other computer's sin on

~x.sendMsg('/sin', '/play');


// turn the other computer's sin off

~x.sendMsg('/sin', '/stop');


// change the other computer's sin's volume (try different numbers between 0.0 and 1.0)

~x.sendMsg('/sin', '/vol', 0.99 );

Sender (GUI Version)

To control a remote synth from your laptop via GUI one can repurpose our example from GUI Basics to the following:

// sending messages via GUI


// setup

(
~ip = "";
~x = NetAddr(~ip, 57120);
)


(

// run the remote synth first

~x.sendMsg('/sin', '/run');

// the GUI

~window = Window.new("my window", Rect(0,0,150,220))
    .onClose_({
    "GOODBYE".postln;
    ~x.sendMsg('/sin', '/free');
});

~button = Button(~window, Rect( 10, 10, 50, 50))
        .states_([
            ["OFF", Color.white, Color.black],
            ["ON", Color.white, Color.red]
        ])

.action_({ arg butt;
    if( butt.value == 1,
        {
            "PLAYING".postln;
            ~x.sendMsg('/sin', '/play');
        },
        {
            "STOPPED".postln;
            ~x.sendMsg('/sin', '/stop');
        }
    );
});

~number = NumberBox(~window, Rect(10, 10 + 60, 50, 50));
~number.align = \center;
~number.value = 0;

~slider = Slider.new(~window, Rect(65, 10, 50, 200))
.action_({ |slider|
    var val = slider.value;

    ~x.sendMsg('/sin', '/vol', val.asFloat );
    ~number.value_(val); // update the gui

});

~window.front;
)

6. Fix Things for New User

2018-01-23T11:00:00-08:00

Welcome to Linux, where it is easy to break things and the benefit is that fixing them involves learning something new about how all of this works. Huzzah! Here are some steps that you need to perform before the beginning of class on Friday. I would strongly recommend tackling this process in groups.

Fix Autocorrect

Gotta be totally honest: I have not experienced this problem where we make a new user on our Pi and then lose the ability to autocomplete when logged in as that user. Since everyone had this symptom in common I had a feeling that something needed to be done differently to get autocomplete functioning again, and turns out you have to do the following:

log in to your new user and run the following command: sudo chsh -s /bin/bash [USERNAME]
reboot your pi: sudo reboot now
Log in and confirm that you can use autocomplete with [TAB] again

Installing SuperCollider

Note: this section relies heavily on all of the great work done by Fredrik Olofsson on this standalone version of SC.

I have already done most of the installation work for you, but we need to do a few more things to make sure your new user can access SC:

git clone https://github.com/redFrik/supercolliderStandaloneRPI2 --depth 1
mkdir -p ~/.config/SuperCollider
cp supercolliderStandaloneRPI2/sc_ide_conf_temp.yaml ~/.config/SuperCollider/sc_ide_conf.yaml

git clone git://github.com/jackaudio/jack2.git --depth 1
cd jack2
./waf configure --alsa
./waf build
sudo ./waf install
sudo ldconfig
cd ..
rm -rf jack2

nano ~/.jackdrc
add the following in ~/.jackdrc: /usr/local/bin/jackd -P75 -dalsa -dhw:1 -r44100 -p1024 -n3
save and exit the file
sudo reboot

Confirm Functionality

log back in, plug headphones into your USB Audio Adapter
cd supercolliderStandaloneRPI2
xvfb-run --auto-servernum ./sclang -a -l sclang.yaml mycode.scd

If you did everything correctly you should hear a throbbing sine tone play once SC has launched. KeyboardInterrupt to stop and then sudo shutdown now to turn you Pi off.

You will get credit for having completed the assignment if we do not have to repeat any of these steps as part of Friday's class. Please contact me if you are having problems and please do not wait until Thursday evening to try this process.

5. WIFI Networks

2018-01-23T10:30:00-08:00

WiFi Networks

Let's say that I want my Raspberry Pi to connect to wifi networks both at home and at school. wpa_supplicant.conf allows multiple network blocks in the same file so it's simply a matter of adding information for each network the pi needs access to. Navigate to /etc/wpa_supplicant/ and then hit ls to see wpa_supplicant.conf. We want to open that file in Nano: sudo nano wpa_supplicant.conf. It should look something like this:

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

network={
   ssid="SCHOOL_WIFINETWORKNAME"
   psk="SCHOOL_WIFINETWORKPASSWORD"
}

network={
   ssid="HOME_WIFINETWORKNAME"
   psk="HOME_WIFINETWORKPASSWORD"
}

Procedure

Configure the above example for your needs and then save the changes
Reboot your pi (sudo reboot now) and log back in
Use ping to see if you are actually connected to the internet: ping wikipedia.org

If you see something like this in the terminal everything is working:

PING wikipedia.org (198.35.26.96): 56 data bytes
64 bytes from 198.35.26.96: icmp_seq=0 ttl=52 time=16.948 ms
64 bytes from 198.35.26.96: icmp_seq=1 ttl=52 time=17.714 ms
64 bytes from 198.35.26.96: icmp_seq=2 ttl=52 time=16.952 ms

Assignment

In order to get credit for this assignment, you must:

pick a website to ping from the terminal on your Raspberry Pi from your home wifi network
email me a screenshot of the results of your ping command (hint: it should look vaguely like the ping example above) prior to the beginning of Friday's class

10. Introduction to OSC

2018-01-23T09:00:00-08:00

Overview

Open Sound Control, frequently referred to simply as OSC, is a communication protocol for sending information across a computer network of some sort. OSC is an incredibly important component of SC, as SC is comprised of two separate applications (sc-synth and sc-language) that communicate with each other over OSC via your computer's internal network. Fortunately one can communicate via OSC with any other computer on the same WIFI network provided we know that computer's IP Address. What follows is a brief example of sending a message from one computer to another followed by a quick sound making example.

OSCdef

Intro

To receive messages via OSC one typically uses one of two UGens in SC: OSCdef or OSCfunc. Note that the structure in SC that we looked at extensively last week, the SynthDef, has a similar ending to OSCdef. In both cases def is short for definition and refers to the ability to reference the Synth, or OSC, objects by name. This naming feature is an important tool for our organizational purposes so I strongly urge you to focus on OSCdef for all message receiving purposes over a network.

Format

OSCdef(\sine, { | msg, time, addr, recvPort|

    msg.postln;

    }, '/sin');

Above is the basic format for an OSCdef. Note the following:

Similar to a SynthDef, the first important piece of information we need to give to SC is the name of this OSCdef, which must be prepended with a \. In this example the name, or definition on the server, of the OSCdef is \sine
The name of the OSCdef is followed by a comma and then a function block (remember, anything between {...} is a function and we often refer to a complete function as a block) which defines what this particular OSCdef does when it receives a message. This structure still closely resembles the structure of a SynthDef.
Next we define arguments between bars. The argument to focus on here is msg, the others you probably will not need to actively use.
Currently the only thing that happens in the function block is a .postln statement. In other words, all this OSCdef does currently is display whatever message it received in the post window.
Finally we have the path, a symbol that defines the label for this particular message. Here our OSCdef will only respond to messages that begin with '/sin'. Note that the path contains both single quotes and a /.

NetAddr

Format

~x = NetAddr([IPADDRESS], 57120);
~x.sendMsg('/sin', '/play');

In the above example I define a NetAddr, or a destination computer on the network, and then send a message to it. Note that the values in parens are both strings prepended with a /. As we have it above, the full message will be: /sin/play.

Simple Network Communication

Get into groups of 2 for the next demos.

Demo 1: General Message Communication

// receives the message
OSCdef(\hello, { | msg, time, addr, recvPort|

    msg.postln;

    }, '/greeting');

// sends the message
~x = NetAddr([IP ADDRESS], 57120);

// try this one first
~x.sendMsg('/greeting', "hello");

// then try this one

~x.sendMsg('/greeting', '/hello');

// and finally this one (multiple times)

~x.sendMsg('/greeting', { rrand(20, 50).asFloat }.value);

Demo 2: Sound Control Over the Network

Receiver Example Code

// setup

s.boot;


// the example synth that will be controlled. note the standardized arguments: amp, freq, trig

SynthDef( \sin, { | amp = 0.0, freq = 440, out = 0, trig = 0 |
    var env, sig, finalSig;
    env = EnvGen.kr( Env.asr( 0.001, 0.9, 0.001 ), trig, doneAction: 0 );
    sig = SinOsc.ar( freq, 0.0, amp );
    finalSig = sig * env * 0.6;
    Out.ar( out, Pan2.ar(finalSig) );
}).add;


// run the synth (note that the envelope is still set to 0 so we hear nothing

~x = Synth( \sin, [ \freq, 400, \amp, 0.5]);


// receive messages from another computer to change Synth at ~x

OSCdef(\sinResponder, { | msg |

    msg.postln;

    switch( msg[1],
        '/play', {
            "play sin".postln;
            ~x.set(\trig, 1);
        },
        '/run', {
            ~x = Synth( \sin, [ \freq, 400, \amp, 0.5]);
        },
        '/stop', {
            "stop sin".postln;
            ~x.set(\trig, 0);
        },
        '/vol', {
            "vol"++msg[2].postln;
            ~x.set(\amp, msg[2].asFloat );
        });
}, '/sin');

Sender Example Code

s.boot;

/*

step 1: get the other computer's IP Address,
store it in a global variable (FYI these are
technically called Environment Variables in SC)

*/
~ip = "";

// pass the IP to a Net Address Object, store it to the variable ~x

~x = NetAddr(~ip, 57120);

// sending messages

~x.sendMsg('/sin', '/run');


// turn the other computer's sin on

~x.sendMsg('/sin', '/play');


// turn the other computer's sin off

~x.sendMsg('/sin', '/stop');


// change the other computer's sin's volume (try different numbers between 0.0 and 1.0)

~x.sendMsg('/sin', '/vol', 0.1 );

9. Workflow Test Drive

2018-01-23T08:30:00-08:00

workflow

parallel development environments

In this class we will work across two environments to complete prototypes:

a laptop: your primary work space, you should always start exploring/testing your idea by writing code on your laptop to confirm general functionality
a Raspberry Pi: move your generally-functional code to your Raspberry Pi for platform-specific tests and, eventually, deployment.

In other words, I recommend doing most of your programming on your laptop and moving to the pi only after you have confirmed basic functionality.

SCP

To Test Drive this workflow process let's assume we have already tested a file on our laptop and now want to send it to our Raspberry Pi. We will then rename the file and send it back to our Laptop. Prior to beginning, remember that the general format for scp is as follows:

 scp [FILENAME] [USERNAME]@[HOSTNAME]:/home/[USERNAME]

On your laptop create an empty text file: touch test.txt
Now send it over to your user's home directory: scp test.txt pi@creativetech.local:/home/pi
Enter the password for the user. After a moment the file transfer should finish.
On your Raspberry Pi verify that the file is where it should be with ls
On your Raspberry Pi rename that file to something different: mv test.txt sendback.txt
On your laptop run the following command to get your IP Address: ipconfig getifaddr en0
On your laptop select and copy the address to your clipboard
Back on your Raspberry Pi format your scp line to send the renamed file back to your laptop: scp sendback.txt [USERNAME]@[IP ADDRESS]:/Users/[USERNAME]
Enter the password for your user. After a moment the file transfer should finish.
Confirm that sendback.txt made it back to the right place on your laptop.

8. Final RPi Setup Steps

2018-01-23T08:00:00-08:00

Overview

The Micro SD card you purchased for the Raspberry Pi operates as your Pi's hard disk. Frequently programmers will distribute an image file, or a fully configured Operating System, for others to duplicate as necessary. Using someone else's image often involves a three-step process:

downloading a .zip file from somewhere
unzipping that file (resulting in a .img file)
writing the .img file to a Micro SD card from your laptop

If you completed HMWRK #1 and #3 you should have already completed this process with the image I prepared for this class.

Personalizing Your Pi (pt. 1)

We need to perform a few extra steps in order to more easily distinguish one person's Pi from others on the WIFI network. I have brought an external PC monitor into the classroom, and given it a keyboard and mouse, to facilitate this.

Changing Your Hostname

A computer's Hostname is label a device is given on a WIFI network for easy reference. Right now all of the Pi's have the same Hostname: creativetech. Using a unique hostname will allow us to connect directly to our Pi without accidentally connecting to someone else's.

Plug your Pi into the PC Monitor, Keyboard, and Mouse I brought into the classroom
Plug the Pi's power adapter into the wall. After a moment you should see lots of text appear on the screen
At the login prompt, enter the following credentials:
- username: pi
- password: adventures
Execute the following command: sudo raspi-config. You should see something like this:
Using the arrow keys scroll to Network Options and click [ENTER]
Select Hostname and click [ENTER]
Select OK and click [ENTER]
Change your hostname to something unique (note: you can only use letters and numbers in hostnames, no symbols), hit [ENTER]
Using the arrow keys click [RIGHT ARROW] twice to select Finish, click [ENTER] to reboot your Pi
When the login prompt appears again you should see your newly entered hostname appear

Connecting to Your Pi (via SSH)

The most convenient way to go back and forth between your Laptop and the Pi is connecting your laptop to the Pi over WIFI. In order to do this, we need to use a tool called ssh, which stands for secure shell. In order to do this one needs to check a few things first:

The Raspberry Pi and Laptop must be on the same Wifi Network
The hostname or IP Address of the Raspberry Pi
The username of the Raspberry Pi
The password for the user in step 3

Here is what the command should look like (replace words in caps between brackets with information to suit your situation):

ssh [USERNAME]@[HOSTNAME].local

If your information is correct you should see a prompt to enter the user password in the terminal. Click [ENTER] once you have done so and you should be able to interact with your Pi from your laptop.

Personalizing Your Pi (pt. 2)

I generally recommend creating a new user on your Raspberry Pi in addition to the general pi user. This way you have a user you can load with all kinds of personal information in addition to a generic user you can revert back to in a worst-case-scenario.

Make a New user

Issue the following command in the terminal: sudo useradd -m -G pi,sudo,gpio,audio,video [NEWNAME]

using -m with useradd checks to see if there is already a home directory for user [NEWNAME] and creates one if there isn't one.

-G specifies which groups the new user will be added to by default. If you want to be able to install things (sudo), access the general-purpose input/output (gpio), or use audio or video, you have to add your user to each of the relevant groups to do so.
Next change the password of your new user by issuing the following command sudo passwd [NEWNAME]
When you are done restart your raspberry pi with the following command sudo reboot now and login to confirm that your new user exists.

4. GUI Basics

2018-01-19T10:30:00-08:00

Below is a basic example GUI (Graphical User Interface), please run it in SC before proceeding:

(
~window = Window.new("my window", Rect(0,0,150,220));

~button = Button(~window, Rect( 10, 10, 50, 50))
        .states_([
            ["OFF", Color.white, Color.black],
            ["ON", Color.white, Color.red]
        ])

.action_({ arg butt;
    if( butt.value == 1,
        {
        "PLAYING".postln;
        },
        {
        "STOPPED".postln;
        }
    );
});

~number = NumberBox(~window, Rect(10, 10 + 60, 50, 50));
~number.align = \center;
~number.value = 0;

~slider = Slider.new(~window, Rect(65, 10, 50, 200))
.action_({ |slider|
    slider.value.postln;
});

~window.front;
)

Try interacting with each part of the GUI. Note that postlns are used extensively to provide feedback, as well as help you deduce how this could be used to control Synths. postln, SC's version of what is called print or console.log in other languages, is a mission-critical part of our troubleshooting toolkit.

Get in groups of two and choose 4 synths from your homework assignment to connect to this GUI. Note that this will involve three steps in the following order:

reverse engineer this example and connect it to one of the Synths from your homework. The button should turn your Synth on and the slider should control volume.
duplicate your set of GUI elements for three more Synths, expanding the overall size of ~window to accommodate 4 sets of the above example, each controlling a different synth.
after completing step 2., add a second slider for each Synth that allows you to change the frequency.

3. Writing Raspbian to an SD Card

2018-01-19T10:00:00-08:00

Note: this information is very similar to the information on this page.

download the Raspbian jessie lite image I prepared for the class (it's called sc_raspbian_stretch_01152018.img.gz) from dropbox to your computer (look for the link via email)
download and install the SDFormatter from here
plug your microSD card into an SD card adapter and insert into your laptop
open SDFormatter, which should automatically identify your SD card, and select Overwrite Format, then click the Format button. After a while the application will tell you that it is done erasing all data from the SD card

with SD card plugged in to your computer enter diskutil list in the terminal to locate the 8GB SD card

example output:

/dev/disk0 (internal, physical):
   #:                       TYPE NAME                    SIZE       IDENTIFIER
   0:      GUID_partition_scheme                        *500.3 GB   disk0
   1:                        EFI EFI                     209.7 MB   disk0s1
   2:          Apple_CoreStorage HD                      499.4 GB   disk0s2
   3:                 Apple_Boot Recovery HD             650.0 MB   disk0s3
/dev/disk1 (internal, virtual):
   #:                       TYPE NAME                    SIZE       IDENTIFIER
   0:                  Apple_HFS HD                     +499.0 GB   disk1
                                 Logical Volume on disk0s2
                                 F0EE8AE2-966C-4461-8AB7-DAC4A66164B5
                                 Unencrypted
/dev/disk2 (internal, physical):
   #:                       TYPE NAME                    SIZE       IDENTIFIER
   0:     FDisk_partition_scheme                        *8.0 GB     disk2
   1:             Windows_FAT_16 RECOVERY                1.2 GB     disk2s1
   2:                      Linux                         33.6 MB    disk2s5
   3:             Windows_FAT_32 boot                    66.1 MB    disk2s6
   4:                      Linux                         6.7 GB     disk2s7

unmount the SD card so we can do write our new image to it by entering the following command into the terminal:
```
diskutil unmountDisk /dev/disk<disk# from diskutil>
```
for example:
```
diskutil unmountDisk /dev/disk2
```
next, uncompress and copy the data from the .img.gz file to your SD card by entering the following in the terminal:
```
gunzip --stdout nameofimage.img.gz | sudo dd bs=1m of=/dev/disk2
```
for example:
```
gunzip --stdout rpi_fieldwork.img.gz | sudo dd bs=1m of=/dev/disk2
```
this takes a VERY LONG TIME, so go get a cup of coffee or take a walk or something.
Eventually you should see something like this in the terminal confirming that dd is done writing the.img file to the SD card:
```
3833+0 records in
3833+0 records out
4019191808 bytes transferred in 1642.354445 secs (2447213 bytes/sec)
```
eject the SD card from your computer with the following command:
```
sudo diskutil eject /dev/disk2
```
put the SD card into your pi, plug power cable in, and confirm that it boots up (if the ACT LED is flashing green than it has successfully booted up)

7. The Command Line

2018-01-19T09:00:00-08:00

Navigate to the Command Line on Mac OSX (Applications > Utilities > Terminal).

You should see something that looks like the window with a white background at the top of this page. That is the Terminal, a name for a command line interface (often abbreviated as CLI) that is already installed on your computer. Though other aspects of computers have changed drastically over the last fifty years, this has not. In other words, you can see back in time, in a sense, at this level of your computer. Read more about the history of the command line here.

In the above photo you will notice a semi-transparent black window that looks fairly similar to the Terminal. This is iTerm2 and I prefer it to the Mac OSX Terminal. I do not really care which you use (it's a matter of personal preference), and not particularly interesting to talk about right now, just be aware that the same commands work across all CLIs.

Open a new terminal window with COMMAND-N. You should see something like [HOSTNAME]:~ [USERNAME]$ followed by a rectangle. The rectangle is your cursor and demarcates where you can enter text commands for the Terminal to execute.
Unix commands, and really anything used in the command line, should be shipped with some sort of manual. Typically this is accessed by typing man [NAME OF COMMAND] in the Terminal and hitting enter. Let's start by checking the manual for the next command we will use, ls. Type man ls and hit enter. You should see something that looks like this:

This is the manual for ls, which opens automatically in a text editor called Vi (also known as Vim, short for Vi Improved). Vim has a radically different approach to how a text editor works than Microsoft Word or Apple Pages, which you can read about in detail here.

There are two modes in Vim: Normal and Insert, and toggling between the two modes exposes different features of the application. Normal is typically reserved for navigating through a file or reading. To navigate the file you can use the j (down) and k (up) keys. In order to quit a file you simply type q.

We will discuss how to use Insert mode, and other commands, in the future. Right now its more important to take some time to read through the manual for ls. It is considered standard practice for developers to include a man file for virtually everything that you use in the terminal, making man a very important command to commit to memory.

Note: google vim vs emacs to see an example of how passionate people get about their tools (these arguments are frequently referred to as "religious").
Type ls and then hit ENTER. ls lists the contents of the directory you are currently in. When you open a new Terminal window you will default to your user's home directory. We can confirm this by running the command pwd (print working directory), which will return /Users/[USERNAME].
To move to a different directory, type cd at the command line and then the name of the directory. Terminal has autocomplete, so type the first two characters of the directory, for example, and then hit the TAB key, which is less work (yay!). On my machine I can move to a directory named git by running the following command: cd git/ where cd means change directory to the directory named git.
You can move around on the command line with arrow keys, but there are also shortcuts like CTL-A to go to the beginning of the line and CTL-E to go to the end of the line. If you make a bunch of mistakes and just want to start over you can issue a KeyboardInterrupt by hitting CTL-C, which will result in a new line.
Check to make sure you are in your home directory (pwd) and then make a new directory by typing mkdir NEWDIRECTORY, where NEWDIRECTORY is the name of your folder (name it whatever you want).
In the next sequence, we will move into our NEWDIRECTORY and create a text file named test.txt:
1. cd NEWDIRECTORY
2. pwd
3. touch test.txt
4. ls
Next lets write something in our text file using a text editor called Nano (which is already installed on your machine, just like Vim):
1. nano test.txt
2. this is my text
Save your changes with Ctl-O, hit Enter to confirm the file name, then Ctl-X to exit.
In the following sequence we will use the Unix command grep, which searches plain-text data sets for lines matching a regular expression (definition sourced from here):
1. Click here to go to the .txt version of The Project Gutenberg EBook of Alice in Wonderland, by Lewis Carroll.
2. Click anywhere on that page, Command-A to select all, Command-C to copy to clipboard.
3. Back in your terminal, make a new text file called alice.txt: touch alice.txt
4. Open the file with Nano: sudo nano alice.txt (don't forget about autocomplete with the TAB key!), you should enter your password and then hit Enter
5. Click anywhere in the window, Command-V to paste the contents of the .txt version of Alice in Wonderland into the file, Ctl-O to save, Enter to confirm file name, Ctl-X to Exit.
6. Now you can search all of Alice in Wonderland for every line that contains some regular expression (which you specify between quotes), which could be a word, or a string of words, but is by default case sensitive.
  
  Example 1: grep 'home' alice.txt results in:
  
  "Why, Mary Ann, what are you doing out here? Run home this moment and this creature, when I get it home?" when it grunted again so violently
  
  Example 2: the words 'hello', 'sorry', and 'god' do not occur in the entire text of Alice in Wonderland. In other words, grep 'god' alice.txt returns nothing.
  
  Note: in the future our goal would be to eliminate the steps that required the use of mouse and a web browser.
Let's go ahead and delete the example files we made. rm removes files. When you need to delete a file, run rm NAMEOFFILE. If you try to use rm on a directory, like the one you made for the test.txt and alice.txt files, the Terminal will stop you (as a safety measure) because Unix thinks that directories should only be removed when they are empty. So, there are two approaches to getting around this kind of an issue:
1. manually rm every file in the directory (this sucks because its repetitive, error-prone, and time-consuming) and then use rmdir NAMEOFDIRECTORY to remove the empty directory.
2. ALTERNATELY, the cooler (lazier) way to do this is to use rm -r NAMEOFDIRECTORY to recursively remove all contents of the directory.
Note: Sometimes, in order to do certain things in the terminal, you may need to prepend a command with sudo. "Sandwich," from the web comic series XKCD, sums sudo up nicely:

sudo means super user do and forces the computer to let you do something. The standard practice is to avoid using sudo unless you know you have to, which often takes some guessing the first time.

For example: I normally try a command without sudo first and, if I get a permissions error as a response, then run the following on a new line: sudo !!.

Note: The command !!, which is pronounced bang bang, is a shortcut to repeat the previous command entered into the terminal. In other words, this command prepends sudo to whatever you ran in the terminal previously.

ls -l

The Unix command ls can do a lot more than just list the contents of a directory. If you run ls -l you can see a full list of the following information (sourced from here):

total files in the directory and subdirectories
the names of the files in the current directory
their permissions
the number of subdirectories in directories listed
the size of the file
and the date of last modification

Go ahead and try running this command in a few different directories. Try home, Applications, and a new directory, made by you (mkdir), on the Desktop expressly for this purpose.

Renaming = Moving

If you need to rename a file with Unix, use the mv command. mv renames/moves the SOURCE to the DESTINATION. For example, in the next sequence we will make a new file on the Desktop, rename it, and then move it to our home directory. Follow along in the Terminal:

cd Desktop/
touch test.txt
mv test.txt mv_demo.txt
mv mv_demo.txt ../mv_is_fun.txt Note: .. is short for up one directory level
cd ~ Note: ~ is a shortcut for your home directory (so many shortcuts!)
ls Note: confirms that mv_is_fun.txt has been moved/renamed

Copying Files and Directories

The cp command allows one to copy files/directories from a SOURCE to a DESTINATION. In other words, standard usage tends to look like this: cp ORIGINALFILE NEWFILE. If you need to copy a directory, though, and want to copy the entire directory structure inside of it, you can tell cp to recursively copy the directory and all of its contentscp -R OLDDIRECTORY NEWDIRECTORY.

Note: in either of the previous examples, one could also change the name of NEWFILE or NEWDIRECTORY by simply using a different name at the end of the NEWFILE/NEWDIRECTORY path.

When you need to copy files over a network you can use scp, which is virtually the same as cp but copies files or folders over a secure, encrypted network (preventing the possible interception of sensitive data via what is referred to as a Man-in-the-middle attack). You will use this command extensively when working with the Raspberry Pi 3.

Note: Though you will begin to memorize some of these commands through frequent use, it is normal to bookmark an online cheat sheet for reference.

6. Additive, Subtractive, & Modulation Synthesis

2018-01-19T08:30:00-08:00

SC has a built in spectrum analyzer that is a useful tool for monitoring your sound design work, particularly during the development stage. Run the following line:

FreqScope.new;

and then proceed through the rest of this lab.

Additive Synthesis

Additive Synthesis is the technique of combining multiple sounds to create more complexity. We went over a simple example as part of this lab on Tuesday:

{ SinOsc.ar( 440, 0.0, 0.5 ) + PinkNoise.ar( 0.1 ) + Crackle.ar( 1.5, 0.4 ) + LFTri.ar( 200, 0.0, 0.2 )}.play;

Here we "sum," or add, signals together to create a complex sound from two oscillators (SinOsc and LFTri) and two noise generators (PinkNoise and Crackle).

Another example of additive synthesis can be seen below:

{SinOsc.ar(800,0,0.1) + SinOsc.ar(880,0,0.1)}.scope;

Here we sum two Sine tones to simulate the busy sound heard on old telephones. This is a good example of another additive synthesis technique: summing multiples of the same sound to create more complex sounds.

SC has a nice shortcut for the above, so one can rewrite it as follows:

{SinOsc.ar([800,880],0,0.1)}.scope;

This takes advantage of a cool feature of Supercollider: Multichannel Expansion. When the Server sees an argument with an Array as input it duplicates the Synth for every item in that Array, explaining why the two previous examples are effectively the same (though one requires less typing!).

Mix

Mix can be used to combine an Array of sounds and mix them down to Mono. For example:

SynthDef( \addSynth,    { | amp = 0.0, freq = 440, out = 0, phase = 0.0, trig = 0 |
    var env, sig, finalSig;
    env = EnvGen.kr( Env.asr( 0.001, 0.9, 0.001 ), trig, doneAction: 0 );
    sig = Mix( [ SinOsc.ar( freq, phase, 0.5 ), PinkNoise.ar( 0.1 ), Crackle.ar( 1.5, 0.4 ), LFTri.ar( freq/2, phase, 0.2 )]);
    finalSig = sig * env * 0.6;
    Out.ar( out, Pan2.ar(finalSig) );
}).add;

x = Synth( \addSynth, [\amp, 0.5, \trig, 1]); // instantiate and play the synth

x.set(\trig, 0); // stop playing the synth when you have had enough

Another application of Mix, and also an example of using many SinOscs to create a complex sound, is provided by Mix.fill: one can generate and fill an array of signals. For example, the following Synth creates 16 instances of SinOsc and then mixes them down to one Mono signal:

SynthDef( \addSynth, { | amp = 0.0, freq = 440, out = 0, phase = 0.0, trig = 0 |
    var env, sig, finalSig;
    env = EnvGen.kr( Env.asr( 0.001, 0.9, 0.001 ), trig, doneAction: 0 );
    sig = Mix.fill(16, {SinOsc.ar(rrand(100, 3000), 0.0, amp)});
    finalSig = sig * env * 0.6;
    Out.ar( out, Pan2.ar(finalSig) );
}).add;

x = Synth( \addSynth, [\amp, 0.5, \trig, 1]); // instantiate and play the synth

x.set(\trig, 0); // stop playing the synth when you have had enough

Which looks like this in the FreqScope:

Subtractive Synthesis

Subtractive Synthesis is analogous to sculpting something out of marble with a hammer and chisel: we start with a complex sound and carve out parts of it to produce a different sound. In general Subtractive Synthesis relies on various Filters to accomplish this transformation. For example, let's start with a PinkNoise generator (remember to run FreqScope again if you turned it off):

x = {| amp = 0.1 | PinkNoise.ar(amp) }.play;

Free the synth (x.free;) and then run this:

x = {| amp = 0.1, freq = 1000 | LPF.ar(PinkNoise.ar(amp), freq, amp) }.play;

Here we run the PinkNoise generator from the previous example through a Low Pass Filter (LPF in SC), which will only allow parts of the sound below a set frequency through. Free the Synth and run again with a few different frequencies, noting the difference in sound.

A High Pass Filter (HPF in SC) is the opposite of a LPF. Compare the previous example with the following:

x = {| amp = 0.1, freq = 1000 | HPF.ar(PinkNoise.ar(amp), freq, amp) }.play;

Here we only allow parts of the sound with frequencies above 1000Hz through. Note that because we are filtering out the lower, stronger sounding frequencies our resulting sound ends up seeming low in volume. It is normal to scale all other sounds down accordingly to achieve balance if the low volume of the filtered audio is problematic.

A Band Pass Filter (BPF in SC) can filter an input by defining the quantity of frequencies, below and above, allowed to pass around a center frequency. To hear the effect, first run our dry PinkNoise Synth:

x = {| amp = 0.1 | PinkNoise.ar(amp) }.play;

Free the synth (x.free;) and then run this:

x = {| amp = 0.1, freq = 1000, rq = 0.1 | BPF.ar(PinkNoise.ar(amp), freq, rq, amp) }.play;

The lower the rq the less frequencies are allowed to pass around the center frequency. To experience this difference try running the above example a few times with different rq values (note: rq can be a number between 0.0 and 1.0 but setting it to 0.0 is equivalent to turning the Synth off and setting it to 1.0 is equivalent to not using the filter at all).

Modulation Synthesis

Modulation Synthesis refers to the technique of using a time-varying signal, called the modulator, to influence or change the behavior of another time-varying signal, called the carrier. Interestingly enough, we can use this technique to modulate the frequency, phase, or amplitude of a time-varying signal to produce different effects.

A classic example of this technique, called Ring Modulation:

SynthDef( \ringMod, { | amp = 0.0, out = 0, trig = 0|
    var carrier, carrfreq, env, modulator, modfreq, sig;

    env = EnvGen.kr( Env.asr( 0.001, 0.9, 0.001 ), trig, doneAction: 0 );
    carrfreq = MouseX.kr(440,5000,'exponential');
    modfreq = MouseY.kr(1,5000,'exponential');
    carrier= SinOsc.ar(carrfreq,0,0.5);
    modulator= SinOsc.ar(modfreq,0,0.5);
    sig = carrier * modulator * env;
    Out.ar(out, Pan2.ar(sig))
}).add;

x = Synth( \ringMod, [ \amp, 0.5, \trig, 1 ]);

An example of Amplitude Modulation:

SynthDef( \ampMod, { | amp = 0.0, out = 0, trig = 0|
    var carrier, carrfreq, env, modulator, modfreq, sig;

    env = EnvGen.kr( Env.asr( 0.001, 0.9, 0.001 ), trig, doneAction: 0 );
    carrfreq = MouseX.kr(440,5000,'exponential');
    modfreq = MouseY.kr(1,5000,'exponential');
    carrier= SinOsc.ar(carrfreq,0,0.5);
    modulator= SinOsc.ar(modfreq,0,0.25, 0.25);
    sig = carrier * modulator * env;
    Out.ar(out, Pan2.ar(sig))
}).add;

x = Synth( \ampMod, [ \amp, 0.5, \trig, 1 ]);

Since we are modulating amplitude, in the above, we can only use positive numbers. This is done by adding 0.25 to the input, so the modulator never drops below 0.0.

And finally (for now), Frequency Modulation:

SynthDef( \freqMod, { | amp = 0.0, out = 0, trig = 0 |
    var env, modfreq, modindex, sig;

    env = EnvGen.kr( Env.asr( 0.001, 0.9, 0.001 ), trig, doneAction: 0 );
    modfreq = MouseX.kr(1,440, 'exponential');
    modindex = MouseY.kr(0.0,10.0);
    sig = SinOsc.ar(SinOsc.ar(modfreq,0,modfreq*modindex, 440),0,amp) * env;
    Out.ar( out, Pan2.ar(sig));
}).add;

x = Synth( \freqMod, [ \amp, 0.5, \trig, 1 ]);

5. Arguments & Controlling Synths

2018-01-19T08:00:00-08:00

Arguments in Functions

Arguments allow one to pass information to a function when the function is evaluated. For example:

f = { arg a, b;
    a - b;
};

In the above function we declare two arguments, a and b. This enables us to pass in two values every time we evaluate the function like so:

f.value(3,2);

Which returns 1. We could run this repeatedly with different values and expect similar results: the first argument will be subtracted by the second one.

There is a syntax shortcut for writing arguments which we can use to rewrite our function above to:

f = { | a, b|
    a - b;
};

So one can declare arguments for a function in one of two manners:

arg nameofargument1, nameofargument2;
| nameofargument1, nameofargument2|

While this may sound esoteric, it's important to understand that many aspects of Supercollider, like arguments, allow a programmer multiple stylistic options in terms of how he or she writes their code.

Arguments in UGens

There are three strategic opportunities provided by deliberate use of arguments in SC:

arguments provide helpful labels to different parts of a UGen (a kind of memory aid)
arguments set default values for a UGen (example: every time I run this Synth the volume starts at half its total signal strength [0.5])
arguments reserve a way to change a particular part of a UGen once it is running (example: I start my Sine tone playing a frequency of 440Hz but will change it to 200Hz later)

In general I think of arguments as things I need to control or change in UGens when I am using them.

Relevant Argument Names

In order to come up with relevant argument names one often references the Documentation. Go to the help file for SinOsc as an example (note: to access the help you select the reserved word and hit Command + D) and scroll down to the section labeled Class Methods. It should look like this:

The first argument in SinOsc is frequency, the second phase, and the third mul (short for multiply).

Using this information one can rewrite this:

{ SinOsc.ar(440, 0.0, 0.5) }.play;

to this:

{ | freq = 440, phase = 0.0, amp = 0.5| SinOsc.ar( freq, phase, amp) }.play;

Note: I prefer to use amp instead of something like mul or multiply.

Controlling Synths

If we store the SinOsc from above in a variable like x:

x = { | freq = 440, phase = 0.0, amp = 0.5| SinOsc.ar( freq, phase, amp) }.play;

we can control it using the .set method of Synth:

x.set(\freq, 200);

One can .set any argument declared as part of the function once the Synth is running, and can even make changes to multiple arguments simultaneously like so:

x.set(\freq, 300, \amp, 0.2 );

To clear the Synth from the server one can simply .free it:

x.free;

2. SynthDefs: Sustaining, Deterministic

2018-01-16T10:30:00-08:00

As discussed in class, there are two basic types of SynthDef patterns: sustaining and deterministic. Using the examples provided here, design two new sets of sustaining and deterministic SynthDefs. Make a "noisey" sounding sustaining and deterministic SynthDef (each should sound unique), and then make a "clear" sounding sustaining and deterministic SynthDef. This should result in 4 unique sounding SynthDefs.

Submit your code online but be prepared to demo your SynthDefs for your colleagues at the beginning of class on Friday.

1. Required Materials

2018-01-16T10:00:00-08:00

The following items are required components for this class:

Raspberry Pi 3 - Model B - ARMv8 with 1G RAM
5V 2.4A Switching Power Supply w/ 20AWG 6' MicroUSB Cable
8GB microSD Card
USB Audio Adapter
Breadboard (400-points)

Be sure to have all of these by the 10:00am on 1/23 to receive full credit.

4. SynthDefs & Envelopes

2018-01-16T09:30:00-08:00

SC has an optimized way of taking in information about UGens and their interconnections: SynthDefs. A SynthDef tells the server how to generate audio and translates that information to byte code. More specifically, a SynthDef is the blueprint that defines a particular instance of a playing Synth. Or, if you prefer, a SynthDef is a cake recipe and a Synth is the cake you end up with by following the recipe.

What follows are two versions of the same instrument: one that sustains until receiving an off message and another which has a specific duration.

sustaining synth

SynthDef( \sin, { | amp = 0.0, freq = 440, out = 0, trig = 0 |
    var env, sig, finalSig;
    env = EnvGen.kr( Env.asr( 0.001, 0.9, 0.001 ), trig, doneAction: 0 );
    sig = SinOsc.ar( freq, 0.0, amp );
    finalSig = sig * env * 0.6;
    Out.ar( out, Pan2.ar(finalSig) );
}).add;

x = Synth( \sin, [ \freq, 400, \amp, 0.5]);

x.set(\trig, 1);
x.set(\trig, 0 );
s.scope;

Here we define a SynthDef named \sin with a sustaining envelope, or an envelope that plays continuously until receiving an off message. Variables are used to organize the code into chunks: env, short for envelope, is the portion of our code that allows us to toggle the sound on and off; sig, short for signal, is the portion of our code that defines what the sound is. Multiplying the env by the sig is what results in the "on/off" functionality above and occurs in the finalSig line.

The resulting signal is written to a Bus (in this case, our speakers) in the Out.ar line, which also converts our Mono signal to Stereo. We will revisit this line in the future so for now don't spend too much time paying attention to it. Note: I reuse the above general structure for all sustaining sounds unless something special/unusual is needed.

To hear the \sin we need to create and play an instance of it, which we accomplish using Synth. In order to turn this instance of \sin off in the future we store it to the variable x. After running the Synth line, we can turn the envelope on by setting the \trig argument to 1. Later we can turn our synth off by setting \trig to 0. Think of these two lines as a metaphorical toggle button for \sin.

deterministic synth

SynthDef( \sin, { | amp = 0.0, freq = 440, out = 0, sus = 1, trig = 0 |
    var env, sig, finalSig;
    env = EnvGen.kr( Env.linen( 0.001, sus, 0.001 ), trig, doneAction: 2 );
    sig = SinOsc.ar( freq, 0.0, amp );
    finalSig = sig * env * 0.6;
    Out.ar( out, Pan2.ar(finalSig) );
}).add;


Synth( \sin, [ \amp, 0.5, \freq, 400, \trig, 1]);

The primary difference between the sustaining and deterministic synth can be seen in their respective env lines. Here we use a different Env: .linen. Take a moment to compare the two Env (.asr and .linen) by highlighting Env and looking it up in the the Help <Command+D>.

.linen creates Envelopes in a trapezoidal shape. In order to calculate this shape, .linen needs information regarding the duration, in seconds, of each segment of its shape. One commonly refers to each segment of the shape as attack time (segment 1), sustain time (segment 2), and release time (segment 3). In other words, if we want our Synth to play for 10 seconds we would want to set each of our segments such that the total time adds up to 10. In the above Synth we accomplish this by using super tiny numbers for attack and release and setting sus to 10.

The benefit here is that the envelope (and associated Synth) will clean itself up after it is done (this is set by doneAction: 2 in the SynthDef), so we could run the Synth line repeatedly to create, for example, 5 instances of \sin each with a total duration of (approximately) 10 seconds. Note: I reuse the above general structure for all deterministic sounds unless something special/unusual is needed.

3. Making Sound

2018-01-16T09:00:00-08:00

Functions are used to make sound in SC. Execute the line below and, when you want it to stop, just type <Command + .>.

{ SinOsc.ar(440, 0, 0.2) }.play;

The code above plays a Sine Wave with a frequency of 440Hz and an amplitude of 0.2 (amplitude, or what one can think of as volume, is generally kept within the range 0.0 to 1.0 in SC).

SC allows one to plot sounds like this onto a graph with .plot. This is useful if your sound is less deterministic than the above or if you need to check why something you are trying to do is inaudible or whatever.

For Example

{ SinOsc.ar(440, 0, 0.2) }.plot;

SC also has an oscilloscope method (.scope) which will display the changing waveform while playing it:

For Example

{ SinOsc.ar(440, 0, 0.2); }.scope;

While .plot plots the function over time, and .scope shows a real-time plot of the waveform, both of those methods are generally used for testing and not for performance or recording.

.play

.play simply tells the server to start a process. The result of that process depends on the function.

For Example

{ SinOsc.ar(440, 0, 0.2) }.play;

So, { ... } returns a function (which can be killed with .stop), whereas { ... }.play returns a Synth object. Synth objects do not have a .stop method, so one must either .free or .release them in order to stop the sound.

For Example

x = { SinOsc.ar(440, 0, 0.2) }.play;
//lets wait a moment
x.release;

Interestingly enough, one can call .scope on the entire output of the server. Think of this like putting everything that is currently happening in SC through an oscilloscope.

For Example

{ [SinOsc.ar(440, 0, 0.4), LFTri.ar(220, 0.0, 0.2) ] }.play;
s.scope;

Ugens

UGens are objects capable of producing audio (with the .ar, or audio rate, class method) or control signals (with the .kr, or control rate, class method).

For Example

(
{ var ampOsc;
    ampOsc = SinOsc.kr(0.5, 1.5pi, 0.5, 0.5);
    SinOsc.ar(440, 0, ampOsc);
}.play;
)

In the above example, the SinOsc UGen is used both as control rate (to change the amplitude of the sounding SinOsc) and as audio rate (to actually play the Sine tone).

Another example that uses Mouse location (both x and y axes) for frequency and amplitude:

{ SinOsc.ar(MouseY.kr( 50, 2000), 0.0, MouseX.kr( 0.0,1.0 )); }.scope;

Additive Synthesis

Additive Synthesis is a general term that refers to the technique of playing more than one sound simultaneously to create a more complex sound. This is also typically referred to as "summing" signals.

For Example

{ SinOsc.ar( 440, 0.0, 0.5 ) + PinkNoise.ar( 0.1 ) + Crackle.ar( 1.5, 0.4 ) + LFTri.ar( 200, 0.0, 0.2 )}.play;

Be careful with Crackle, it explodes easily (and this especially sucks if you are monitoring SC via headphones).

2. Intro to SC3

2018-01-16T08:30:00-08:00

Download

Go here to download the Current Version of SuperCollider 3 (3.9.0 as of this writing). Once your download is complete, go ahead and install.

About

Supercollider is made up of two applications: a language interpreter and one or more synthesis servers. All communication between the lang (short for language) and the server is done via OpenSoundControl.

Starting the server

In order to make sound the server must be running. Type the following into a new window (<Command+N> makes a new window) and then hit <Shift+Enter> on the same line to execute the code:

s.boot;

Here s refers to the localhost server on your CPU.

s.boot; generally results in something like this in the post window:

booting server 'localhost' on address: 127.0.0.1:57110
Number of Devices: 17
   0 : "Built-in Microph"
   1 : "Built-in Output"
   2 : "After Effects 10.5"
   3 : "After Effects 11.0"
   4 : "After Effects 11.0.1"
   5 : "After Effects 11.0.2"
   6 : "After Effects 12.0"
   7 : "After Effects 12.2"
   8 : "After Effects 13.0"
   9 : "Prelude 1.0"
   10 : "Prelude 2.0"
   11 : "Premiere Pro 5.5"
   12 : "Premiere Pro 6.0"
   13 : "Premiere Pro 7.0"
   14 : "Premiere Pro 8.0"
   15 : "MOTU UltraLite mk3 Hybrid"
   16 : "Aggregate Device"

"MOTU UltraLite mk3 Hybrid" Input Device
   Streams: 4
      0  channels 8
      1  channels 2
      2  channels 2
      3  channels 2

"MOTU UltraLite mk3 Hybrid" Output Device
   Streams: 4
      0  channels 2
      1  channels 8
      2  channels 2
      3  channels 2

SC_AudioDriver: sample rate = 44100.000000, driver's block size = 512
SuperCollider 3 server ready.
Requested notification messages from server 'localhost'
localhost: server process's maxLogins (1) matches with my options.
localhost: keeping clientID (0) as confirmed by server process.
Shared memory server interface initialized

One can quit the server by executing the following code:

s.quit;

Functions

Similar to most other programming language, Functions in SC are denoted by the use of curly brackets. Anything between { } is a function.

For Example

f = { "hello world!".postln; };
f.value;

The first line of code stores the function at f, whereas the second line returns the value (in this case, prints the message "hello world!" to the post window) associated with the function. Here value is short for evaluate. If one needs to use a function simply .value it.

Arguments and Variables within Functions

Arguments allow one to pass values to a function when the function is called.

For Example

(
f = { arg a, b;
    a - b;
};
f.value(5, 3);
)

In the above code, evaluating the f.value(5, 3) results in the number 2 at the post.

And, of course, one can also use variables in functions.

For Example

(
f = { arg a, b;
    var firstResult, finalResult;
    firstResult = a + b;
    finalResult = firstResult * 2;
    finalResult;
};
f.value(2, 3);    // this will return (2 + 3) * 2 = 10
)

1. Overview

2018-01-16T08:00:00-08:00

While designers have traditionally been tasked with the creation of standalone objects there is an increasing demand towards systems-oriented design. In the broadest sense, systems-oriented design refers to the creation of processes and devices capable of interacting and communicating with each other. In this class we will explore systems thinking via the metaphor of creating an ecology of devices, each exhibiting a discernible personality (imagine them as animals, for example). Such a metaphor is a common one employed by designers charged with designing a component of a larger system.

Strategies for creating an ecology will be presented and deployed via the Raspberry Pi 3 platform, simultaneously providing students with basic approaches to embedded computing. Students will be challenged to constrain their exploration of these topics to the medium of sound (within the SuperCollider 3 programming language), ultimately designing a sound-making process capable of sending and receiving messages in order to contribute to a jungle environment.

SuperCollider 3

Supercollider 3, often referred to as simply SuperCollider or SC, is an environment for sound design and composition used by musicians, artists, and researchers. It is a free, open source, high-level programming language.

Raspberry Pi 3

The Raspberry Pi 3 is a single-board computer running the Linux operating system. It is as powerful as an average smartphone and costs about $40 (!!!!!). The Raspberry Pi 3 (often referred to as RPi or Pi for short) is capable of connecting to the internet, creating and manipulating media (video or sound), responding to sensor input, acting as a server, and a variety of other uses. In short, anything you can do with a computer you can do with a Pi.

The Pi, a micro-computer, is a more complex device than the Arduino, a microcontroller. While the Arduino is an excellent device for interfacing with electronics or the real world, it is not capable of manipulating sound/video or connecting to the internet unless one purchases additional equipment (often doubling one's project budget). The Pi, on the other hand, can do all of these things out of the box without additional equipment.

workflow

parallel development environments

We will work across two environments to complete prototypes:

Laptop: your primary work space, you should always start developing your idea by writing code on your laptop to confirm general functionality.
Raspberry Pi: move your generally-functional code to your Raspberry Pi for platform-specific tests and, eventually, deployment.

In other words, I recommend doing most of your programming on your laptop and moving to the pi only after you have confirmed basic functionality.