It is, but it works.
You can also use
4.times do
sync :clock
end
It is, but it works.
You can also use
4.times do
sync :clock
end
I think it is worth reading Sam Aaron’s comments in a previous thread
My solution would be to delay the start of the :metronome loop to give the other loops a chance to start and to be waiting for their initial sync, which ONLY applies the first time round (set in the define line of the live loop). Subsequently none of the loops need a sync, apart from the one with the 7 beat pattern. This needs to be delayed on each pass to the start of the next bar.
So applying this to your original code I get this. (Note ALL loops which are an exact number of bars can be synced directly to metronome. You done really need the loops for 8 beats, but you do ned the loop for 1_bar so that you can restart the 7 beat loop correctly.
Your code modified is below
use_bpm 120
beats_per_bar = 4
############################### TOOLS ###############################
live_loop :metronome,delay: 0.01 do #delay start of this by 0.01 to allow other loops to be ready
use_synth :beep
play :a4, release: 0.5
sleep 1
end
live_loop :_1_bar,sync: :metronome do
use_synth :beep
play :as5, release: 0.5
sleep beats_per_bar
# the cue is sent ONLY NOW /:( so sad no ? NOT ANY MORE!!!
end
live_loop :_4_bars,sync: :metronome do #not required here
sleep beats_per_bar*4
end
live_loop :_8_bars,sync: :metronome do #you don't really need this loop here
sleep beats_per_bar*8
end
live_loop :_16_bars,sync: :metronome do #not used here
sleep beats_per_bar*16
end
############################### live_l_o(U)pssssssssss ###############################
# this loop will start once _4_bars has finished once and become free as as bird no synchronicity
live_loop :loop_sans_sync, sync: :metronome do #:_4_bars
sample :drum_cymbal_hard
sleep 4
end
live_loop :loop_8_beats,sync: :metronome do # sync to :metronome not :_1_bar
# après la durée de la boucle _1_bar 4 beats
#sync :_1_bar
use_synth :sine
riff_8_notes = (ring :c3, :d3, :e3, :f3, :g3, :a3, :b3, :c4)
# this pattern last 8 beats
play_pattern_timed riff_8_notes, 1
# oh it's strange i "miss" the cue "/live_loop/_1_bar" why have i wait the next one ?????
#
end
live_loop :loop_7_beats do
# _1_bar last 4 beats
sync :_1_bar #this loop needs to wait EVERY time for the start of the bar
use_synth :pretty_bell
riff_7_notes = (ring :c6, :d6, :e6, :f6, :g6, :a6, :b6)
# this pattern last 7 beats
play_pattern_timed riff_7_notes, 1
end
To summarise.
You need to delay the start of the main metronome to give other time to be ready to receive sync cues.
All loops that last a whole number of bars can be synced to :metronome
You only need a 1_bar loop if (as in this case) you have a loop which is NOT an integral number of bars. In this case it needs to be delayed until the start of the next bar. Here the sync appears INSIDE the loop and applies on each pass.
It’s lovely to see such a great discussion about this. However, please could I ask that you refrain from using negative and potentially confrontational language in post titles such as “X sucks” instead preferring constructive language.
Thanks
I totally didn’t take any offence. I just think it’s inportant to keep the right cultural tone
my english is not perfect as it is not my natural language, i’m a “frog” so i thought the term was not so violent.
may i add just a piece of advice for your health during your set live coding, mind your back !
cheers
Hi again,
as the issue of syncing live_loop
s quite constantly pops up (e. g. in my courses) I made a little sketch, trying to visualise the logic behind it. I am aware of the fact that technical accuracy is not always on good terms with easy-to-understand-clarity; the sketch tries to tackle practical problems of what you can experience while syncing live loops. Anyhow, please let me know if I did missunderstand anything, if I can be technical more precise without making it more complicated or if the sketch could be improved otherwise:
(If this is to small to read please let me know, I’ll upload a A4 PDF and link it here.)
@nlb: Yes, it’s a typo. Fixed that. Thanks for the hint!
@robin.newman, the delay: 0.01
is a nifty trick: Somehow like a conductor raised its stick (allthough timewise just the opposite happens) and everybody knows, now a downstroke will follow and then I will have to start playing my instrument
good idea but isn’t there a typo sync: :red no ?
Exactly Martin. Trying to sync without the delay is like the conductor giving his/her initial downbeat without any warning whilst the players (the other live loops are still getting their instruments ready, so they miss the first bar and start at a later bar start from the conductor. With the delay the subsidiary live loops all start and wait the “conductor’s” cue which comes a little (0.01 beats) later.
There is one (more theoretical) question concerning the technical background, which I would like to be ansered for myself. Is this the correct description in plain words:
A synced live_loop can’t just start together meaning at the same time with the cueing loop. The synced live loop notices the ‘first’ cue (which concerning the runtime of the whole script for it happened to be in the past) and then starts with the next cue. So syncing needs kind of to be announced to actually i. e. audibly to happen.
Yes I think this is a fair statement that you make Martin.
Sam stated this when Ethan raised the sync issue on the Sonic Pi github site.
In v3 I made this deterministic which also meant deciding on a repeatable set of semantics. This in turn means that each cue is totally ordered across all runs and all syncs are also ordered. In v3 syncs will only catch cues after them. Which means that for threads syncing and queueing on the same logical time, their thread ID will determine whether they are before or after.
In other words for a sync to work you should make sure that the cue is sent AFTER the sync is waiting for it. For two live_loops starting at the same time, delay the one you wish to sync to slightly and they will then start together. (The second one waits for the first to send a cue as it starts).
Hi,
I hope any conductor is reading your post… The conductor is the metronome and as a metronome he has to be on the beat and not 0.01 seconde after…
The conductor is of course raising its stick before the beat and not after.
And computers are used because they are kown to be very accurate. so a metronome indicates the correct beat and musicians can rely on it.
According to me there is no valable explanation of this bug, it’s not a feature it’s a sad bug and i understand why you met lot of people not understanding this. It’s not logical as a musical point of view.
So this how it works but it’s a bit sad…
So the code below may help people to clear their mind
# a signal is sent every 1 beat
live_loop :metronome do
sleep 1
end
# this loop last 4 beats.
# metronome are accurate and that's why we can rely on them
live_loop :drums, sync: :metronome do
sample :drum_bass_hard
sleep 0.5
sample :drum_bass_soft, compress: 0, pan: [-1,1,-0.8,0.8].ring.tick
sleep 0.5
sample :drum_snare_hard, compress: 1, pan: [-1,1,-0.8,0.8].ring.tick
sleep 1
sample :drum_bass_hard
sleep 0.5
sample :drum_bass_soft, compress: 0, pan: [-1,1,-0.8,0.8].ring.tick
sleep 0.5
sample :drum_snare_hard, compress: 1, pan: [-1,1,-0.8,0.8].ring.tick
sleep 0.5
sample :drum_snare_hard, compress: 1, pan: [-1,1,-0.8,0.8].ring.tick
sleep 0.5
end
# this loop last 15 x 0.5 = 7.5 + 0.49 = 7.99 beats ! ! !
live_loop :hithats do
sync :drums
15.times do
sample :drum_cymbal_pedal, pan: [-0.8,0.8,-0.1,0.1].ring.tick
sleep 0.5
end
sample :drum_cymbal_open
# sleep 0.50 will NOT WORK it's a bug not a feature :(
# musicians are not accurate and it saves us :-)
sleep 0.49
end
best regards.
Hi @nlb,
try this:
live_loop :metronome do
sleep 1
end
live_loop :drums, sync: :metronome do
sample :drum_bass_hard
sleep 0.5
sample :drum_bass_soft, compress: 0, pan: [-1,1,-0.8,0.8].ring.tick
sleep 0.5
sample :drum_snare_hard, compress: 1, pan: [-1,1,-0.8,0.8].ring.tick
sleep 1
sample :drum_bass_hard
sleep 0.5
sample :drum_bass_soft, compress: 0, pan: [-1,1,-0.8,0.8].ring.tick
sleep 0.5
sample :drum_snare_hard, compress: 1, pan: [-1,1,-0.8,0.8].ring.tick
sleep 0.5
sample :drum_snare_hard, compress: 1, pan: [-1,1,-0.8,0.8].ring.tick
sleep 0.5
end
live_loop :hithats, sync: :drums do
15.times do
sample :drum_cymbal_pedal, pan: [-0.8,0.8,-0.1,0.1].ring.tick
sleep 0.5
end
sample :drum_cymbal_open
sleep 0.5
end
Two more thoughts on this:
You are right, it is not the easiest feature to understand in Sonic Pi.
And in defendance of the conductor-metaphor: Have you ever joined a rehearsal of a Jazz band? There will most surely be someone who counts something like that (in the case of a four-four time): “One… two, you know, what to do!” and then everybody is going to start.
Before you can sync to a metronome someone has to make sure that you listen to it at all.
thanks for your help @Martin
indeed your code is working but still don’t understand why mine is not working. i think i’m dumb
Hi @nlb,
no, if I may say so, you are not dumb at all. This thread did also help me to bring some more clarity. I have these questions during the course I give (and these are probable to pop up at any time) and now I am sure to be able to answer it.
See my grafic, which tries to explain exactly this point (as did the last part of Sam’s explanation). It is all about the fact, that your :hihats
will try to sync every time the loop runs. This is a bit like, as if this loop was a musician, who after every bar needs a new start (“one… two… you know, what to do…”) In my example, it does sync one time and then goes on with its own timing. So it is actually listening to sync just once (and remember: the time rule says: a sync can only be recognised if it has happened in the past).
Hope that helps.
I think you misunderstand how this works. It is EXACTLY what a conductor does. When you press RUN all the live loops start and await a sync pulse from the metronome (the conductor). At the same time the “conductor” starts waiting for 0.01 seconds to give the other loops a chance to be ready (equivalent to him/her raising the stick and checking that all the instruments (other live_loops) are ready and waiting for a cue to sync on. THEN the conductor (the metronome) starts giving the first downbeat and all the other loops start exactly in step with the metronome.
There is nothing magical about the 0.01 it could be 1 in which case there would be a slightly longer pause while the “orchestra” gets ready. However, when they start to play they would all be in perfect sync with each other and the conductor, when metronome starts after the 1 beat deal.
If the conductor started without raising his/her stick to warn the other members of the orchestra then chaos could ensue. I have played in several orchestras and this is how it works!
hello everybody,
ok ok maybe sometimes “i’m lost in translation” or miss something : i’m going to read slower your correct post and start again.
thanks for your help and sorry to waste your time !
No time wasted. This is an important topic. I hope that this thread will help users to get syncing right.
A question while revisiting my own grafic: In the last note shouldn’t it be: “BLUE starts from here, and will listen for the next run of RED” instead of “… every new run …”? Because that is exactly the reason for the gap: With sync :red
in the loop’s body BLUE does need a new sync for each run and will only pick up the sync when it is 1. not running and 2. the sync is not in the past. And if this is not correct is there anyone who can put this into plain English which is technically acurat? I’d be very grateful!