How do I…?

This is like an FAQ for config files:

What to do if cards are in a different order than Input First 

If there is an output card in the input chain, it must be listed in the input card section of the config file like this:

card_x
card_in ( 1 , 0 )
card_x
card_in ( 2 , 0 )
card_x
card_in ( 3 , 0 )
card_x
card_in ( 4 , 0 )

The above example has an output card before each input card.  The system is now aware of the presence of these cards and will behave correctly.

How do I make an indicator light come on when something happens?

The easiest way is to use stp_ctrl commands:

Stp_ctrl ( ( Cresc_step > 0 ) , 1  , 60 )
Stp_ctrl ( ( Cresc_step > 7 ) , 1  , 61 )
Stp_ctrl ( ( Cresc_step > 14 ) , 1  , 62 )
Stp_ctrl ( ! lvl_up_dn , 1  , 63 )

How do I make reversables affect more than one stop?

The standard Opus-Two Reversable merely toggles a stop when a button is pressed.  If it is on, it gets turned off; if it is off, it gets turned on.

Reversable_tab ( In6_21 | In5-11 , 5 )

There are easy ways to implement toggling stops.  For our two examples, we will toggle all three Swell-to-Great tabs off, but only bring one back on (AGO spec); in the pedal example, we will turn off both 8′ and 4′ couplers, but only bring the 8′ back on:

Assuming Swell-to-great 16 is tab 10
Assuming Swell-to-great 8 is tab 11
Assuming Swell-to-great 4 is tab 12
Assuming Swell-to-pedal 8 is tab 4
Assuming Swell-to-pedal 4 is tab 5

ec_reversable_2 ( in4_31 | in4_47 , stop_4 , 4 , stop_5 , 5 )
ec_reversable_3 ( in4_37 , stop_11 , 11 , stop_10 , 10 , stop_12 , 12 )

As a matter of interest, the two tab reversable (first example) has two input bits that can activate it, one would be a piston, another would be a toe stud.  Any procedure that is looking for a single input pin can use logic statements to allow more than one button to control the feature.

 How do floating divisions work?

Remember that every chamber has unused keyboards, and any of them can be designated as the “floating” division.  Multiple floating divisions can exist per controller, because of the number of keyboards available.  For our example, we will have a floating Solo Division.  First, does the division home somewhere?  It does not have to, but it can.  Our example will have it home to the Swell Division.  This example assumes that you want the intramanual couplers to NOT affect the floating division when it is being played from a keyboard.  This example assumes that there are controls named:

- Solo Off Swell
- Solo On Great
- Solo On Choir

if ! Solo_Off_Swell then 
  Stp_cplr (   Solo_to_Solo_4  , So_k , Sw_k , p_4  )
  Stp_cplr ( ! Solo_Unison_Off , So_k , Sw_k , p_8  )
  Stp_cplr (   Solo_to_Solo_16 , So_k , Sw_k , P_16 )
end if
if Solo_On_Great then 
  Stp_cplr (   Solo_to_Solo_4  , So_k , Gr_k , p_4  )
  Stp_cplr ( ! Solo_Unison_Off , So_k , Gr_k , p_8  )
  Stp_cplr (   Solo_to_Solo_16 , So_k , Gr_k , P_16 )
end if
if Solo_On_Choir then 
  Stp_cplr (   Solo_to_Solo_4  , So_k , Ch_k , p_4  )
  Stp_cplr ( ! Solo_Unison_Off , So_k , Ch_k , p_8  )
  Stp_cplr (   Solo_to_Solo_16 , So_k , Ch_k , P_16 )
end if

These if statements would be placed in the coupler stack.  This is only an example, and can be easily customized to suit any application.

Can Opus-Two couple expression pedals together?

Opus-Two can process expression couplers in either the console or the chamber.  In the console, these commands should be used in the input section, in the chamber, in the output section.  There are four commonly used couplers available:

 

expr_merge ( stop_224 , exprb2 , exprb5 )

When stop 224 is on, expression byte #2 and expression byte #5 are merged.  Moving forward, exprb2 is unaltered, but if it is larger than exprb5, its value is copied to exprb5.  Essentially, exprb5 becomes whichever value is larger.

expr_merg2 ( exprb2 , exprb5 )

This is essentially the same function as above, but it works all the time and is not tied to a stop.

expr_revr ( Stop_6 , exprb3 , exprb1 )

This function (when the stop is engaged), inverts exprb3 and puts the opposite value on exprb1.  If exprb3′s shoe is closed, exprb1′s shades will be open (and visa versa).  Unless modified, this coupler can only OPEN a shoe.  Therefore, if exprb1′s shoe is wide open, the coupler won’t do anything.  This is intentional, so that at the end of an orchestral transcription, the organist can open the inverted shoe for a full organ type effect.

 

expr_replace ( Stop_185 , exprb3 , exprb4 )

This coupler takes exprb3′s value and copies it to exprb4, regardless of what was in exprb4.

How does Opus-Two Pedal Divide work?

The pedal divide is performed in the console input section and  ties up the Pedal 2nd Touch keying buffer.  If you need that, use another keyboard for it, as the pedal divide is pretty tied to the p2_k buffer.  That being said, there are two types of pedal divide, fixed pedal divide, and flexible point pedal divide.

Fixed pedal divide is a walk in the park, this example splits at note 13:

Pedal_Divide ( stop_56 , 13 )

When this feature is on, all keying below the split point is sent down the pd_k buffer.  All keying above the split point is sent down the p2_k buffers.  This means that in the chamber, all manual-to-pedal couplers must couple to p2_k instead of pd_k.  All native pedal ranks must be assigned to get keying from pd_k as normal.  Sometimes an organist will want two pedal divide controls, one for normal function, and one that only takes some of the organ and divides it to the top of the split.  If statements can switch those particular items back and forth from one keying to another.

Adjustable pedal divide is not a walk in the park.  It uses a similar command as above, BUT instead of inputting a number, it uses a variable:

Adjustable_Divide ( Stop_56 , in4_25 , dwrb2 , 12 )

This example will activate when stop_56 is on, and store the numeric value in dwrb2.  This allows the value to be saved in the combination action.  If no value has been set for a particular piston, the last number (12) is the default split point).  If a single pedal key is held and in4_25 is pressed, the saved number will reflect that particular pedal key and can now be saved into a piston.

By default, this value will not save into pistons.  When setting up the console for the first time, set the divide point to the top note (G3).  This will cause the piston ranging to include all pedal divide drawer bits.  To remove all pedal divide drawer bits from a range, set the divide point to low C.

How are expression rollers read?

There are a number of ways to read expression rollers.  The easiest way is to use cascading if statements.  In our example, we know that each expression byte has a value range of 0-255 and it is ideal to use a majority of that range (there is a good reason, see the next question).  If we have an 8 stage roller, we will allow each stage to add a value of 20.  This conveniently works for 10 and 12 stage rollers as well (16 stage rollers need values of 15).

For our example, we will assume that the 8 stage roller is wired to pins 1-8 of input card 5 and assign the value to exprb1:

   if in5_8 then exprb1 = 160
elsif in5_7 then exprb1 = 140
elsif in5_6 then exprb1 = 120
elsif in5_5 then exprb1 = 100
elsif in5_4 then exprb1 = 80
elsif in5_3 then exprb1 = 60
elsif in5_2 then exprb1 = 40
elsif in5_1 then exprb1 = 20
else             exprb1 = 0
end if

 

How can I prevent swell shades from slamming?

A simple filter routine can be applied to any expression to limit the speed at which the values change.  Sometimes this can be used because certain pneumatic ganged-stage engines actually work better if they are activated one stage at a time (allowing only one “pillow” to fill at a time).  Other times this is used with individual pneumatics so that the shades close neatly and in order.  This can keep audible bangs to a minimum.  This procedure can also be used when values are flickering back and forth rapidly (an analog input can’t decide where to rest or a contact can be half-engaged).

The procedure that filters needs the byte name that is being filtered and another byte to keep track of how far along it is in the filtering every time the config runs.  Commonly used bytes are saved_misc, saved_swell, saved_choir, and saved_antiphonal.  There are other bytes, which can be found elsewhere in these documents.

filter_sample_2 ( exprb1 , saved_misc )