I used my strategy to code some of Clé des Champs.

This is the track

Code:

use_bpm 113
chords = [(chord :Bb, :minor), (chord :F, :major)].ring
c = chords[0] # take the first chord of the ring and save it to a variable
s=1
live_loop :ambiant do
sync :rhythm
use_octave -2
use_synth :dtri
play_pattern c, sustain: 2,amp: 0.5
sleep 4*s
end
live_loop :chord_chooser do
sync :rhythm
8.times do
c = chords.tick
chords = [(chord :Bb, :minor), (chord :F, :major)].ring sleep 4*s
end
4.times do
chords= [ (chord :Eb, :minor), (chord :Db, :major), (chord :Ab, :major), (chord :F, :major)].ring c = chords.tick sleep 4*s
end
end
sleep 4s live_loop :rhythm do sleep 0.5 sample :drum_cymbal_closed sleep 0.5 cue :rhythm end sleep 32s
live_loop :melody do
use_synth :dsaw
play c.choose,attack: 0.1,sustain: 2, sustain_level: 1, release: 1, cutoff: rrand(60, 120),amp: 0.5
sleep s
play c.choose,attack: 0.25,sustain: 2, sustain_level: 1, release: 1, cutoff: rrand(60, 120),amp: 0.5
sleep s
play c.choose,amp: 0.5
sleep s
play c.choose,attack: 0.1,sustain: 2, sustain_level: 1, release: 1, cutoff: rrand(60, 120),amp: 0.5
sleep s
end
sleep 16*s
live_loop :drums do
sync :rhythm
sample :bd_tek
sleep 0.5
sample :drum_cymbal_closed
sleep 0.5
end

Between yesterday and today, I have been experimenting with Sonic Pi to make a nice strategy for the pieces.

My initial plan is to emulate a band and it components.

Rhythm

Just like any band has a mutual timekeeper. I included a virtual one.

This module throws in a cue every beat that different components of the song follow .

cue :rhythm 

Chord chooser

This guy doesn’t actually make any sound. Basically it tells everyone what set of notes they can play at any given moment. He is useful alongside the rhythm so that the music sounds in sync.

Melody and chords

These are written in separate modules so they can be played at the same time and debugged easily.

They play notes from the notes specified by the chord chooser.

Creative programming workshop with Sonic Pi

I found a hands-on tutorial for Sonic pi.

Here is how it goes. We already covered some of t he poonts by sequentially going through the documentation.

Looping

We can loop infinitely by:

loop do
sleep 0.5
play :d4
sleep 0.5
play :e4
sleep 0.5
play :c4
sleep 0.5
end 

Or we can specify the number of repitions

4.times do
sleep 0.5
play :d4
sleep 0.5
play :e4
sleep 0.5
play :c4
sleep 0.5
end

Adding different tracks

Here a live_loop comes into play. basically multiple sounds play at the same time.

use_bpm 100
live_loop :drums do
sample :drum_heavy_kick
sleep 1
sample :drum_snare_hard
sleep 1
sample :drum_heavy_kick
sleep 1
sample :drum_snare_hard
sleep 1
end
live_loop :hihat do
sample :drum_cymbal_closed
sleep 0.25
sample :drum_cymbal_pedal
sleep 1
end
live_loop :bass do
use_synth :fm
play :c2, attack: 0, release: 0.25
sleep 0.25
play :c2, attack: 0, release: 0.3
sleep 2
play :e2
sleep 0.75
play :f2
sleep 1
end

Now that we have the bass and drums, let’s start to worry about the main melody.

Lead track

Instead of typing play, sleep for every single note, we can use the play_pattern_timed method.

live_loop :melody do
play_pattern_timed [:c4, :e4, :f4, :g4, :f4, :e4, :f4, :g4, :f4, :e4, :f4], [0.25, 0.25, 0.25, 1.5, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25]
end

play_pattern_timed [notes],[lengths]

(pseudo-)Randomness

We can play random notes, lengths and anything that can be controlled by numbers really.

• to choose randomly from a list of notes:

play [40,45,50].choose

• To randomly choose an octave

use_octave [0, 1].choose

• To randomly choose a note from a chord:

play (chord :c, :major).choose

You get the point.

We already covered ops, let’s look at effects;

Effects

we change the effects by encapsulating the code with with_fx

live_loop :effects do
with_fx :wobble do
with_fx :slicer do
with_fx :reverb do
play rrand(20,120)
sleep 0.5
sample :elec_plip
sleep 0.5
play rrand(20,120)
end
end
end
end 

This is what this piece of code sounds like:

Ticks and rings

Ticks go through the notes of a progression sequentially in a list. A finite list is bound to end. So we make it a circular list. A ring. Then we are ready to pass it.

Variables

Variables are used to reference a certain object and do operations over it. In the context [of music, we can change the pitch played.

This is a useful tutorial plus it comes with a little cheat sheet:

https://sonic-pi.mehackit.org/exercises/en/10-cheatsheet/01-cheatsheet.html

I got this from the official tutorial: https://sonic-pi.net/tutorial#section-3

Triggering Samples

This is straightforward, type

sample :ambi_lunar_land

Setting the amplitude and the pan

Just like the synths, we can control these parameters in samples

sample :ambi_lunar_land, amp:0.8, pan: -0.3

Stretching

samples can be squashed and stretched, even played backwards. Or better yet, squashed or stretched and played backwards.

sample :ambi_lunar_land, rate: 0.5

Explanation:

“Typically a waveform like this will have 44100 points of data per second (this is due to the Nyquist-Shannon sampling theorem). So, if the sample lasts for 2 seconds, the waveform will be represented by 88200 numbers which we would feed to the speaker at a rate of 44100 points per second. Of course, we could feed it at double rate which would be 88200 points per second. This would therefore take only 1 second to play back. We could also play it back at half rate which would be 22050 points per second taking 4 seconds to play back.”

Sonic Pi Official website

Envelopes

Here we should note the difference with synth ADSR envelopes. It lies in the sustain value.

“In the standard synth envelope, the sustain defaulted to 0 unless you set it manually. With samples, the sustain value defaults to an automagical value – the time left to play the rest of the sample.”

This is the reason why we hear the full length of the samples.

In short: attack times are used for fade ins and release times are used for fade outs.

envelopes can be used with samples to get nice effects on our samples.

More possibilities with the samples can be explored on the website

External samples

Sonic Pi can work with samples stored on the computer.’

for me, I can load a sample by typing

sample /Users/chadiabifadel/Downloads/Fun-Programming-master/processing/04/e100_rhythm/data/2.wav 

If you are interested in more information on samples in Sonic Pi, Go to https://sonic-pi.net/tutorial#section-3-1

This is taken from the official documentation of Sonic Pi: https://sonic-pi.net/tutorial#section-2

Playing around with synths is quite different with Sonic Pi.

Activating A note

Activating a note ca be as simple ,as typi ng

play 60

Changing the number controls the pitch.

Controlling amplitude and pan

amplitude is the computer’s representation of loudness. It’s a value between 0 and 1

Pan controls where the sound is coming from on stereo speakers. It’s a value between -1 and 1.

play 60, amp: 0.8, pan: -1  

Changing synth

“Notice that the use_synth command only affects the following calls to play. Think of it like a big switch – new calls to play will play whatever synth it’s currently pointing to. You can move the switch to a new synth with use_synth.”

use_synth :prophet

play 60

This changes the “instrument” of the notes played after it.

ADSR envelopes

play 60, attack: 0.5, attack_level: 1, decay: 1, sustain_level: 0.4, sustain: 2, release: 0.5

they are best explained with this diagram: