Looper's Delight
Looper's Delight Home
Mailing List Info
Mailing List Archive
Looping Tools Page
Echoplex Page
Looper's Delight!!
Looper's Delight
Looper Profiles
Tools of the Trade
Tips and Tricks
History of Looping
Rec. Reading
Mailing List Info
Mailing List Archive
File Library

Looper's Delight!
In Association with Amazon.com

Frequently Asked Gibson/Oberheim Echoplex Questions

Page 7 - Brother Sync Questions

Echoplex FAQ Contents | Page 1 | Page 2
Page 3 | Page 4 | Page 5 | Page 6 | Page 7 | Page 8 | Page 9

Multiple Echoplexes and BrotherSync

I want to play bass, guitar, and sax loops at the same time. Three echoplex units are needed so that I can start a short loop, build a longer one on another unit, then alter the first or dittle with the third. Also for changing from tune to tune using the reverse of this process. So the ultimate question is, will I be able to sync and close the loops between three units on the fly? Or will I be forced to slave them?

What you are trying to do is exactly what BrotherSync is for. BrotherSync allows you to use multiple echoplexes and have any of the units define the time base, which the others then listen to. The other units can then have loop times that sync up exactly or are some multiple of the original. So you could do a 5 second loop on one to define the base time, and then a 10 second loop on the second, and a fifteen second loop on the third, etc.

Each of the BrotherSynced units can be operated independently, by just you or multiple people. So you can do completely different things on one than you do on the other, for multi-track looping. This is a great way for several musicians to jam together with their loops all synced. BrotherSync is good for that because it lets any one of them define the loop length for the others.

Also, you can sync to midi clock. So an external sequencer or something can generate midi clock, and the echoplexes can set their loop times to that and sync up to it. This doesn't mean they are slaved to anything, they just use the clock.

Echoplex also generates midi clock, so you can have the loop time set the tempo for a sequencer.

Now if you want to slave them together over midi, you can do that too. You could also do a combination. So you could have two units set up as a master/slave pair for a stereo loop, syncing to midi clock from external or BrotherSynced to another echoplex or whatever.

Another idea is to set the 8ths/beat parameter differently between the units, so that the loops are synced to the clock, but have different loop lengths. This way you can get polyrhythmic loops going.

We spent a ton of time making sure this all works, by the way. You definitely want the upgraded software for the best results.

BrotherSync Setup and Usage

How do I set up and use BrotherSync with two (or more) Oberheim Echoplexes?

Is there anything special I should know beyond what it says in the manual to use BrotherSync?

For BrotherSync, first make sure you are using the right kind of cable. It has to be a stereo, or TRS type, and should be plugged into the Brother jack on both units. People constantly say they have encountered some terrible bug with this, and it turns out they just never bothered to read the manual and were using a mono cable! A mono cable definitely causes strange behavior when in the BrotherSync jacks.

Second, make sure you have Sync=out on both units.

Now record a loop on one unit. Once you finish recording you will see the Sync LED begin to flash on the other unit. (the Sync LED is the second "dot" from the right on the number display.) The sync LED will flash each time the first unit passes it's start point.

After the Sync LED has flashed at least once on the second unit, you can press record on that one. The display will show "ooo" until the first unit reaches it's start point again. When that happens, the second unit will begin recording. The "ooo" display means the unit is waiting for an event before it begins the function, or quantizing.

You can let the second unit record as long as you like. (or at least as long as you have memory for.) When you press Record again to end on the second unit, it will show "ooo" until the First unit's startpoint comes by again. When that happens, the loop recording will end automatically on the second unit. The loop will be in sync with the first unit, and will either be the exact same length or an integer multiple.

If you reset one of the units, you have to wait for the other unit to pass it's startpoint and send a sync pulse before you can record another loop in sync. It won't know there is another unit out there sending a sync pulse if it doesn't get a chance to see one....

The reason it is called "BrotherSync" is because any unit can define the sync pulse for the others connected to it. They are in an equal, or "brother" relationship rather than master/slave.

Practice with it some, and you'll get the hang of it.

Does the memory in both Echoplexes need to be the same? (We've got 50 vs. 198 seconds of memory, though soon they'll both be upgraded.)

no, memory size doesn't matter.

BrotherSync In-Depth Tutorial

What is actually going on when BrotherSync is operating? Ideally we are hoping to use BrotherSync to do something like the following:

Set up a basic "pulse" loop on machine 1, for example 1 sec long, then record 3 different loops on machine two, all in some multiple relationship to the loop on machine 1, for example 4 sec, 7 sec and 12 sec loops (I have lots of memory). When switching between these loops, sync seems to be maintained in referrence to Machine 1. (Is this a function of Switch Quantize?) Then we would like to record loops 2 3 & 4 on Machine 1, in sync with loops on Machine 2. However, if after doing this, we switch to other loops on either machine, will there be any sync maintained?

This is a good place for an in-depth BrotherSync Tutorial.

Let's start with the basic explanation of BrotherSync, which you probably already understand, but it never hurts to start at the beginning:

A BrotherSync connection provides two things, synchronization of loop/cycle lengths and synchronization of sample clocks. Sample clock sync is important for keeping audio on multiple units in the same phase relationship, but the thing we really care about for playing is the loop/cycle sync, so that's what I'll be discussing here.

All of the units connected on BrotherSync can either generate or receive a sync pulse, so any of them can define the loop/cycle length for the others. When you record the first loop on one of the units, it generates a sync pulse at the start point of it's loop. It actually generates the sync at the beginning of each cycle, so if you multiply a loop the pulse will be transmitted each time the multiple number changes. So the sync pulse defines the cycle length of the unit generating it.

	basic loop:
	Rec        Rec
	            *          *          *          *          *
		pulse (*) sent at each start point.
	multiplied (x3) loop:
	 *          *          *          *          *          * 
	 | cycle 1  ` cycle 2  ` cycle 3  | cycle 1  ` cycle 2  `
		pulse sent at each cycle boundary.

As soon as the other units detect a sync pulse on the BrotherSync connection, they will go into a synchronization mode that is very similar to the quantize function.

It works like this: You record a loop on the first unit (starting with everything in reset), it starts sending sync. When you press Record on one of the other units, it will show "ooo" at first. As soon as it receives a sync pulse, it will begin recording. You can let it go on recording as long as you like, and then press Record again when you want to stop. It will show "ooo" again until it receives the next sync pulse, and then it stops the recording and starts looping the sample.

		 *          *          *          *          *          * 
	1st unit |----------|----------|----------|----------|----------|.....
	2nd unit     ooooooo|~~~~~~~~~~~~~~~oooooo|---------------------|
	             ^      ^               ^     ^
	             |      |               |     |
	             |      |               |     |---sync pulse, record stops
	             |      |               |
	             |      |               |--press record to end, unit waits
	             |      |
	             |      |
	             |      |---sync arrives, recording starts
	             |--press record, unit waits

Now, the second unit will also be generating a sync pulse according to it's cycle length. In this case the cycle on the 2nd unit is twice the cycle length of the 1st unit, so it's pulses will be generated at 1/2 the rate of the 1st unit's sync pulse. The second unit will be generating it's pulse at the same time as a pulse from the first unit, but this just looks like one pulse. So when the the units from the diagram above are looping, the sync is actually like this:

	1st unit *          *          *          *          *          * 
	2nd unit *                     *                     *

This makes it possible for the first unit to be reset and have a new loop recorded in sync to the 2nd unit. We will still have a sync pulse available from the 2nd unit, based on the 2nd unit's cycle length. So when you reset the loop on the 1st unit, it will see the sync pulse from the 2nd unit coming at 1/2 the rate of the original loop and be able to sync to that. However, that means that the original sync pulse is now gone. (although it is somewhat implicit in the 2nd unit's pulse rate.)

If it is important to maintain the sync pulse from the first loop, there are two general ways you could approach it.

One idea is to have some sort of master sync source that is always available. (This sort of defeats the point of BrotherSync, but anyway....) You could do this with midi clock, where you have an external clock defining a particular tempo. Each echoplex would receive this clock and sync its loops to it. The cycle length that is defined on each unit is determined by the 8ths/beat parameter. By setting 8ths/beat different on each unit, you can develop interesting polyrhythmic relationships between the loops, while still maintaining a relationship to the master clock. If you use another echoplex to generate this clock, you can easily set the clock tempo live according to the first loop you record.

Another method of this clock master approach is to continue using BrotherSync connections, but have the first unit continue running, so that it's sync pulse is aways available to the other units. You could use mute or feedback to kill it's loop audio if you want. This has some flexibility over the midi clock method, since you can decide to let another unit master the clock if you want.

Another approach is to make sure that each unit has the same cycle length, even though they may have different loop lengths. The best way to do this is using the Record-Insert technique for recording loops. Ending Record by pressing Insert causes the Insert function to start immediately, which adds new cycles to the loop. When you get to the full loop length you want, you tap Insert again. The result is one continuous loop of the audio played during this operation, made up of cycle lengths defined by the Record-Insert action at the beginning. If you have BrotherSync connected and do this Record-Insert action with the 2nd unit, the 2nd unit will sync the actions to the 1st unit's cycle. So you get something like this:

	     *          *          *          *          *          * 
	1st  |----------|----------|----------|----------|----------|.....
							 *	    *
	2nd      ooooooo|~~~~~~oooo`~~~~~~~~~~`~~~~~ooooo|----------`.....
	         ^      ^      ^   ^                ^    ^
	         |      |      |   |                |    |
	         |      |      |   |                |    |---sync pulse, 
	         |      |      |   |                |        insert stops
	         |      |      |   |                |
	         |      |      |   |                |--press insert to 
	         |      |      |   |                   end, unit waits
	         |      |      |   |
	         |      |      |   |--sync arrives, insert starts
	         |      |      |
	         |      |      |--press Insert, unit waits
	         |      |
	         |      |---sync arrives, recording starts
	         |--press record, unit waits
	So you end up with:
	1st *          *          *          *          *          * 
	    *          *          *          *          *          * 
	    | cycle 1  ` cycle 2  ` cycle 3  | cycle 1  ` cycle 2  `

So what happens with multiple loops?

The BrotherSync output will follow whatever the current loop is doing. So when

you switch to another loop, that will define the sync. If you switch into a reset loop, no sync will be generated. If another unit is generating sync pulses, you could record a new loop sync'd to that.

When you have SwitchQuant on, the loop switching will occur when a sync pulse arrives. So in this case, a press of NextLoop on the second unit will cause the loop to switch on the next one second pulse from the first unit. Keeping SwitchQuant on is probably a good idea, because without it you switch to the next loop immediately. If you don't time the press of Next well, the BrotherSync pulses generated by the two units will be out of phase with each other, which could make it hard to predict when a sync will occur.

So let's follow your example:

First you record a 1 second loop on unit 1, it sends BrotherSync pulses to the other unit, 1 pulse per second.

On the second unit, you record 3 different loops, each a multiple of the pulses on the first unit. (4 sec, 7 sec, and 12 sec).

So then you go back to the 1st unit, and want to record loops 2, 3, and 4. Let's say you left the 2nd unit in loop 2, which is 7 seconds. You press Next on the 1st unit, it waits to the end of it's current cycle (the next sync point that occurs) and then switches to loop 2. Loop 2 is reset.

Now we have the 1st unit in reset, and the 2nd unit has a 7 second loop. The only sync pulse happening will be from the 2nd unit, occuring every 7 seconds. So if you record a loop on the first unit it will be a multiple of 7 seconds in length.

If that's not what you want it to do, and instead you want the 1 second pulse available still, you can try the techniques I mentioned above for the single loop case. Or, we have one other possibility with multiple loops, called Time Copy. Time Copy is like doing an Insert into the next loop. The cycle length of the loop you are leaving is used as the cycle length in the new loop. You do it like this:

  • Press Next sometime in the middle of the cycle, so you get the "ooo" waiting period.

  • Press Insert before it automatically switches.

  • As soon as the switch happens, you will be recording in the new loop. The multiple counter will be counting up using the cycle length from the loop you switched just left, the same as it would if you did an Insert.

  • Since you basically are doing an insert, you end this loop by pressing Insert again.

In this way, you could record other loops on unit 1 that are multiples of the original 1 second loop, without concern for whether the second unit is generating 1 second pulses.

This is a lot to digest, and goes right to the heart of the most advanced features in the echoplex. It might take a while to grasp it all, but hopefully you see lots of possibilities in there. I think what you are trying to do is exactly why we created all of this!

BrotherSync Trouble Shooting

When leaving the brother sync plugged at power on, the plexes refuses to boot.

That sounds like you are using the wrong sort of cable for BrotherSync. You should be using a stereo (TRS) type of cable.

Not booting like this usually means that you have a mono cable in BrotherSync.

Looper's Delight Home | Looper's Delight Mailing List Info
Copyright 1996-present by loopers-delight.com
contact us

In Association with Amazon.com
Any purchase you make through these links gives Looper's Delight a commission to keep us going. If you are buying it anyway, why not let some of your cash go to your favorite web site? Thanks!!