Chuck A Day

Day 1

The first ChucK file done, this is mainly a learning exercise for myself as though I have played with Chuck in the past I want to really learn its insides.

As always an immediately unintended outcome is that I ended up writing a php syntax highlight for Chuck which I will use on this page.

/*Number 1
Chuck a day 2009
by Scott Hewitt
www.ablelemon.co.uk/chuckaday */

//Build DSP
SinOsc s => dac;

440 => s.freq;

//Declare
int i;

//Loop
while (i < 50)
{
    //Random frequency
    Std.rand2f(200, 500) => s.freq;
    //Random duration to pass
    Std.rand2f(10, 500)*1::ms => now;
    //Increment Loop
    i++;
}

ChucK file 1.ck

Day 2

Playing with spork-ing today, most challenging issue was getting the main shred to run until all the sporked shreds had finished. int f does this by keeping count of how many shreds are active and keeping time going while f > 0.

If you remove the // on the print lines <<< you can see f's value change over time.

//Number 2
//Chuck a day 2009
//by Scott Hewitt
//www.ablelemon.co.uk/chuckaday

//Declare
int k;
//int used to track if shreds are running
int f;

//main function
fun void valueshift() 
{
    //Build DSP
    SinOsc s => dac;
    //declare freq
    440 => s.freq;
    int i;
    
    f++;
    //<<< f >>>;
    while (i < 50)
    {
        //Random frequency
        Std.rand2f(200, 1000) => s.freq;
        //Random duration to pass
        Std.rand2f(10, 500)*1::ms => now;
        //Increment Loop
        i++;
    }
    f--;
    //<<< f >>>;
}

//sporks shreds off
while (k < 6)
{
    spork~ valueshift();
    2000::ms => now;
    k++;
}

//loop time until all shreds are dead
while (f > 0 )
{
    500::ms => now;
    //<<< "waiting on" >>>;
    //<<< f >>>;
}

ChucK file 2.ck

Day 3

Playing with if statements today and the idea of separating the sonic generation and the score.

The sonic material is contained within the function build() while the score is the the list of function calls separated by lengths of time.

Could not find away to manipulate dsp control parameters outside of there if statements so will revisit that.

//Number 3
//Chuck a day 2009
//by Scott Hewitt
//www.ablelemon.co.uk/chuckaday

//function holds 'instrument'
function void build(int d, dur e){
    0 => int b;
    0 => int a;
while (b < d){
    Std.rand2(1,4) => a;
    <<< a >>>;
    if (a == 1)
    {
        SinOsc s => dac;
        0.3 => s.gain;
        Std.rand2f(440, 800) => s.freq;
    }else{
     TriOsc f => dac;
     0.3 => f.gain;
     Std.rand2f(440, 800) => f.freq;        
    }
    b++;
    e => now;
}
}

//a score?
build(2, 100::ms);
2000::ms => now;
build(2, 400::ms);
4000::ms => now;
build(2, 10::ms);
1000::ms => now;
build(2, 999::ms);
1000::ms => now;

ChucK file 3.ck

Day 4

Experimenting with events mainly today to control the structure of the piece. Also used Envelope and Pan2 within the code.

The event communication seams a great way to communicate between the parent and children shreds and I imagine waiting for something to happen rather than querying to see if it has is more efficient coding.

//Number 4
//Chuck a day 2009
//by Scott Hewitt
//www.ablelemon.co.uk/chuckaday

//Events for note on/off
Event e; Event f; Event g; Event h;

//int represents how many voices are sounding
0 => int stop;
//signals score progression
Event i;

//synth function int set frequency, responds to event
function void synthee (Event event, int xx){
    SawOsc s => Envelope env => Pan2 p => dac;
    0.3 => s.gain;
    100::ms => env.duration;
    xx => s.freq;
    <<< xx >>>;
    while (true){
     event => now;
        0.8 => env.target;
        Std.rand2f(-1.0, 1.0) => p.pan;
        1 => env.keyOn;
        stop++;
        <<< stop >>>;
        event => now;
        0 => env.target;
        1 => env.keyOff;
        stop--;
    }
}

//signal events
function void control () {
    while (true){
    if (maybe){
        g.signal();
        Std.rand2f(100, 800) * 1::ms => now;
    }
    if (maybe){
        h.signal();
        Std.rand2f(100, 800) * 1::ms => now;
    }
    if (maybe){
        e.signal();
        Std.rand2f(100, 800) * 1::ms => now;
}
if (maybe){
    f.signal();
    Std.rand2f(100, 800) * 1::ms => now;
}
}
1::ms => now;
}

//counts 20 seconds and then moves on score
function void timer ()
{
 20::second => now;
 i.signal();
}

//create multiple voices using sporking
spork ~ synthee(e, 500);
spork ~ synthee(f, 800);
spork ~ synthee(g, 1000);
spork ~ synthee(h, 600);

//Score ??
//counts 20 seconds
spork ~ timer();

//changes synthee values
spork ~ control();

//awaits signal to start end
i => now;
<<< "to end" >>> ;

//waits for all notes to be off and ends
while (stop != 0){
1::ms => now;
}
//allows final envelope to end
101::ms => now;

ChucK file 4.ck

Day 5

Experimenting with a high pass filter and then setting the values by using global variables acorss the parent / child relationship.

I can see this dynamic parameter change being useful in FM synthesis and for other stuff.

If your running this code please send me comments or follow me on twitter @scotthewitt.

//Number 5
//Chuck a day 2009
//by Scott Hewitt
//www.ablelemon.co.uk/chuckaday

//dsp chain
SinOsc n => HPF biq => dac;

//randoms and then sweeps freq value
function void freqsweep ()
{
    while (true){
        0 => int dd;
        Std.rand2f(0, 1) => biq.freq;
        while (dd < 10 )
        {
            1000::ms => now;
            biq.freq() - 0.1 => biq.freq;
            dd++;
        }
         Std.rand2f(10, 100) * 1::ms => now;
    }
}

//randoms and then sweeps q value
function void qsweep ()
{
    while (true){
         0 => int cc;
         Std.rand2f(0, 1) + 0.1 => biq.Q;
         while (cc < 10 )
         {
             1000::ms => now;
             biq.Q() - 0.01 => biq.Q;
             cc++;
         }
         Std.rand2f(10, 100) * 1::ms => now;         
     }
 }

//changes frequency and sweeps
spork ~ freqsweep();
//changes q and sweeps
spork ~ qsweep();

//run for 60 seconds
60::second => now;

ChucK file 5.ck

Day 6

Looking at using some of the built in instrument synthesis and arrays within this code.

Also used the Echo Ugen to fill out the sitar sound.

Used the zero values in the arrays to introduce shape to the lines, as they cause a break to occur, though had to add additional if statements looking for them, otherwise they just cause errors.

Any ideas for day 7? @scotthewitt

//Number 6
//Chuck a day 2009
//by Scott Hewitt
//www.ablelemon.co.uk/chuckaday

//Today we play with arrays
[440,400,300,0,600,590,550,520,420] @=> int tune[];
[200,220,210,180,300,240,0,310,200] @=> int tuneb[];
[210,350,400,260,200,320,310] @=> int tunec[];

Event enew;
Event eenew;
Event eeenew;

//DSP (maybe there is a better way of dong this)
Sitar sit => Echo e => dac;
Sitar sitb => Echo ee => dac;
Sitar sitc => Echo eee => dac;

1000::ms => e.max => ee.max => eee.max;
0.1 => e.mix => ee.mix => eee.mix;

//play array
function void mel (){
for (0 => int i; i < tune.cap(); i++){
    if(tune[i] != 0){
        tune[i] => sit.freq;
        Std.rand2f(0, 1) => sit.pluck;
        0.9 => sit.noteOn;
        200::ms => now;
        0.0 => sit.noteOff;
        200::ms => now;
        enew.signal();
        }else{
            400::ms => now;
        }
    }
}

function void accop () {
for (0 => int i; i < tuneb.cap(); i++){
    if(tuneb[i] != 0){
        tuneb[i] => sitb.freq;
        Std.rand2f(0, 1) => sitb.pluck;
        0.9 => sitb.noteOn;
        200::ms => now;
        0.0 => sitb.noteOff;
        200::ms => now;
        eenew.signal();
        }else{
            400::ms => now;
        }
    }
}

function void melb (){
    int kk;
for (0 => int i; i < tunec.cap(); i++){
    Std.rand2(1, (tunec.cap() -1)) => kk;
    if(tune[kk] != 0){
        tunec[kk] => sitc.freq;
        Std.rand2f(0, 1) => sitc.pluck;
        0.9 => sitc.noteOn;
        200::ms => now;
        0.0 => sitc.noteOff;
        200::ms => now;
        eeenew.signal();
        }else{
            400::ms => now;
        }
    }
}

//create echo values
function void echoer (){
    while (true){
         enew => now;
         Std.rand2(100, 900) * 1::ms => e.delay;
     } 
}

function void echoerb (){
    while (true){
         eenew => now;
         Std.rand2(100, 1000) * 1::ms => ee.delay;
     }
}
 
 function void echoerc (){
     while (true){
         eeenew => now;
         Std.rand2(100, 700) * 1::ms => eee.delay;
     }
}

//spork shreds
spork~ echoer();
spork~ echoerb();
spork~ echoerc();
spork~ mel();
spork~ melb();
spork~ accop(); 

//keep parent alive so children complete
4::second => now;

ChucK file 6.ck

Day 7

This ChucK program is a multi delay effect so it requires audio input.

Has more complicated Ugen network with some Ugens feeding back into each other.

I am finding that 'spork~ing' things is the easiest way to modulate multiple parameters.

As always and ideas are welcome @scotthewitt.

//Number 7
//Chuck a day 2009
//by Scott Hewitt
//www.ablelemon.co.uk/chuckaday

//DSP
adc => Delay del => dac;
del => Delay delb => dac;
delb => del;

//Control
Envelope env => blackhole;
Envelope envb => blackhole;
SinOsc s => blackhole;

//Preset values
1000 => s.freq;
0.5 => delb.gain;
5000::ms => del.max;
1000::ms => del.delay;
5000::ms => delb.max;
1000::ms => delb.delay;

//amplitude modulation 
function void feedbackamp (){
    while (true){
        s.last() => delb.gain;
        //<<< s.last() >>>;
        <<< delb.gain() >>>;
        21::ms => now;
    }
}

//change delay value delb
function void delaa (){
    while (true){
        env.value() * 1::ms => delb.delay;
        100::ms => now;
    }   
}

//change delay value del
function void delbb (){
    while (true){
        envb.value() * 0.7::ms => del.delay;
        100::ms => now;
    }   
}

//envelope control
function void envbcontrol() {
    while (true){
         Std.rand2(10, 4500) => envb.value; 
         Std.rand2(10, 4500) => envb.target;
         Std.rand2(10, 4500) => envb.time;
         envb.keyOn;   
         envb.time() * 1::ms => now;  
    }
}

spork ~ feedbackamp();
spork ~ delaa();
spork ~ delbb();
spork ~ envbcontrol();

//main loop
while (true) {
 1000::ms => now;
 Std.rand2(10, 1500) => env.value; 
 Std.rand2(10, 1500) => env.target;
 Std.rand2(10, 4500) => env.time;
 
 env.keyOn;
 env.time() * 1::ms => now;
}

ChucK file 7.ck

Day 8

Kassen suggested that I try to make some sort of melody maker that did not heavily rely on randomness and without a preset scale.

This code sort of does it. Pitches are created based on random choice between movments allowed. The available movments are hardcoded as a percentage of the length of score.

Sort of works - one thing I am sure of is that ChucK seames to handle this kind of thing quite well.