Week 5 lesson 1 - musical notes

Ok we're back with a surprisingly long video about how to play notes, giving them as numbers or names, and controlling samples and synths.. With a sidetrack about how to look at the actual values inside (the first cycle of) a pattern.

  • 0:50 - how to look at event values in the first cycle
  • 2:26 - floating point note values - playing between the notes
  • 3:36 - looking at the timespan of an event
  • 5:43 - sc3plugins - needed for playing synths (if the synths work fine, you have this installed already)
  • 6:14 - writing notes as the letters "a" to "g" in mininotation * 7:33 - using qtrigger to play a sequence from the start
  • 8:54 - note letters are really numbers
  • 9:12 - sharps and flats
  • 11:26 - octaves in note names (e.g. c6, e4)
  • 14:09 - difference between 'note' and 'n' for synths and samples
  • 19:13 - mixing 'note' and 'n' when using samples
  • 19:36 - using sets of recorded note samples, e.g. the 'rash' sample set
  • 22:55 - the difference between pitching up a single sample, and patterning a set of samples of different recorded notes
  • 25:19 - using the 'octave' control

Here's the worksheet:

-- If you 'run' a pattern by itself, without a 'd1' or so, then Tidal
-- will do its best at telling you what's in the first cycle. For
-- example:

note "3"

-- gives:

-- (0>1)|note: 3.0f

-- 0>1 tells you it's an event that starts at position 0 (the start of
-- the first cycle) and lasts up to 1 (the start of the next cycle).
-- note is the name of the 'control' or 'effect' 3.0f is the value
-- ('f' tells you that it's a floating point, decimal number).

note "3 ~ 5"

-- the above gives two events:

-- (0>⅓)|note: 3.0f
-- (⅔>1)|note: 5.0f

-- We can listen to them:

d1 $ note "3 ~ 5" # s "superpiano"

-- Great notes!

-- (.. if you don't hear any, you probably need to install "sc3plugins".)

-- Tidal can also understand note names, and turn them into numbers
-- for you.

-- For example 'c' is the same as '0'

note "c"

-- This:

note "a b c d e f g"

-- is the same as:

note "9 11 0 2 4 5 7"

-- What happened to 1, 3, 6, 8, and 10?
-- You can get to them by adding 's' for 'sharp', to add 1 to a note:

note "cs ds fs gs as"

-- or by using 'f' for 'flat' to subtract 1:

note "df ef gf af bf"

-- In theory, you can get to them all via really sharp 'c'
-- notes. These two notes are identical:
d1 $ note "csssssss g" # s "superpiano"

-- In practice, that surely doesn't make a lot of sense.

-- Normally, there are twelve notes in an octave. The default octave
-- is 5, you can pick notes from other octaves by adding a different
-- number:
note "c5 c6 c4 c6"

-- Lets have a listen
d1 $ note "c5 c6 c4 c6" # s "superpiano"

-- Lets think about the difference between 'note', 'n', synths and
-- samples.

-- There is no folder of samples called 'superpiano', the sounds you
-- hear are being synthesised on-the-fly.

-- With synths, you can use either 'note' or 'n' to specify notes,
-- they mean the same thing.

d1 $ n "c a f e" # s "superpiano"

d1 $ note "c a f e" # s "superpiano"

-- For samples, they mean something different. 'n' chooses a sample,
-- 'note' plays it at a different speed, corresponding to a note.

-- Different sounds:
d1 $ n "0 1" # sound "dsynth"

-- Different notes:
d1 $ note "0 1" # sound "dsynth"

-- If you pick a high note, then you'll notice the sound is a lot
-- shorter, because it's making it higher by playing it faster.
d1 $ note "0 24" # sound "dsynth"

-- You might feel that's not good, because it doesn't sound as natural
-- as a synthesiser
-- You might feel that's great, because nature is a myth and this is
-- how old school 'tracker' music from early rave music and the
-- demoscene works
-- You might change your mind on different days

-- You can still use note names in mininotation:
d1 $ note "c a f e" # sound "dsynth"

-- (Actually you can use do this in any control/effect pattern that
-- expects a number.. Tidal just treats them as numbers)

-- This dsynth sample is in 'c'. If it wasn't, the notes would
-- probably sound out of tune with another synth or samplebank.

-- The 'dbass' sample has three bass sounds, again in 'c', of
-- different lengths.  So it makes sense to use *both* 'note' and 'n'
-- together, to pattern both the pitch and the sample that's used:
d1 $ note "c a f e" # sound "dbass" # n "<0 1 2>"

-- The 'rash' samplebank is organised differently.. There's a load of
-- samples, one for each note of 6 octaves. There's 12 notes in an
-- octave, so that's 72 samples. (actually there's 73, there's an
-- extra one note-084.wav which you could delete..) I sampled these
-- from my lovely Roland JV1080 synth.

-- So you can play notes as numbers using the 'n' instead of the
-- 'note' pattern. This sounds a bit more 'natural' than pitching them
-- up with 'note'.
d1 $ n "20 50" # sound "rash"

-- You can still use note names, but whereas for synths '0' is *middle*
-- c, with these samples that's right at the *bottom* of the scale.
d1 $ n "c a f e" # sound "rash"

-- So in this case you'll want to pick a higher octave
d1 $ n "c7 a7 f8 e7" # sound "rash"

-- I tend to add a few octaves like this:
d1 $ n "c a f e" # sound "rash"
  |+ n 24

-- Adding notes together is fun :
d1 $ n "c a f e" # sound "rash"
  |+ n 24
  |+ n "<0 2 7 12>"

-- You can also do it this way, adding together number patterns
-- 'inside' a single control pattern
d1 $ n ("c a f e" |+ 24 |+ "<0 2 7 12>")
  # sound "rash"

-- There's also an 'octave' control to jump up/down in twelves:
d1 $ note "c a f e" # sound "superpiano"
  # octave "<4 6 3>"
11 Likes

Follow-on video coming soon, and fair warning - I sing in the next one.

8 Likes

is up the same as note?

Yes sorry this is something I meant to mention. note is the new up. The latter is now just an alias for the former.

3 Likes

Thanks Alex!
I seem to be missing the dbass sample though - is that something I can get hold of?

Ah sorry! I'll add them to the samples-extra zip later, but in the meantime you can get them here https://slab.org/tmp/dbass.zip

2 Likes

About the difference between sharps and flats you mentioned, there are two main reasons:

Ignore this post if you don't care about western music theory

  1. The historical one: Before equal temperament (tuning system based on having every note equally spread across an octave), when humans used the just intonation tuning system (based on the simplicity of ratios), sharps and flats were different frequencies. You can find more info on this here

  2. The descriptive one: If you play an F major chord (F-A-C), and you turn it into a minor chord, you would pitch the A -1 semitone, making it F-Ab-C. Calling it F-G#-C is kinda like throwing something out of nowhere. The same happens with scales but even more so, for convention and easy scale recognition, you wouldn't have the F major scale described as F-G-A-A#-C-D. You are having two A's in the same scale, it can be confusing to repeat notes, so we say it's F-G-A-Bb-C-D. This is also why sometimes using a scale with flats or sharps, when you get off the scale playing the regular counterpart of one of those flat notes, you will see it marked as a 'natural' in a music sheet.

But anyway, if you're not interested in documenting your music in music sheets, or don't play classical or jazz or related genres, you don't have to really care about this.

14 Likes

For anyone not aware, the 'rash' samples (and many others) are included in this repo:

(in the 'extra-samples' folder)

Bryan

Those samples are ones I've collected for an album project.

All the additional samples needed for the course examples should be in the samples-extra.zip shared in this lesson:
Week 1 lesson 2 - Loading sample packs

1 Like

Just a fun fact: the letter H was mainly used in the German naming convention (adopted by Germany, Austria and Nordic countries) to indicate the natural B note, whereas B was used for B flat.
As example, the BACH motif had been composed (by Bach himself) on this old notation.

3 Likes

Thanks I'm learning a lot about music theory this week!

1 Like

A post was merged into an existing topic: Week 7 Lesson 3 - Composing tracks with the 'ur' function

I noticed that |+ is equivalent to transposition if applied to 'note', so naturally I'm wondering if there's a quick notation for inversion, where the n pattern

n "0 3 4 5" becomes n "0 -3 -4 -5"

or n "3 6 -2 3" becomes n "3 0 8 3"

1 Like

I've been trying to write some code to play random notes chosen from a scale with a euclidean rhythm, but I've got stuck. Here's what I have so far:

d2 $ struct "t(3,8)" $ note (scale "minor" "[0|1|3|4]") # s "arpy"

But that just seems to choose a single note from the scale and then play it 3 times in a 3,8 rhythm before choosing another. I'd like each note to be chosen from the list of notes. I've tried using choose but scale returns a pattern, and choose needs a list. Any ideas?

The following works, but maybe gives too much control over the random element?

d1 $ struct "t(3,8)" $ note (scale "minor" "0 [1|4] [12|7]") # s "midi" # midichan 0

Yes the [|] notation chooses one value per cycle. This should do it:

d2 $ struct "t(3,8)" $ note (scale "minor" $ choose [0,1,3,4]) # s "arpy"

That's great, thank you both for your help!