Structure of the file

The chamber files are generated in much the same format as the console files.  They can read inputs from connected input cards (tuning keyboards, expression over-rides, stop over-rides, etc.). Prior to entering the code from the config file, they have loaded the data sent over the high speed data line from the console(s).  Every time data is sent from a console, the chamber executes it’s own config file and ports the data to the driver cards.

It stands to reason that in most instruments, it is not helpful to refer to stops by their console stop number.  It is much easier to make an alias table to refer to them by name.  A consistent name scheme should be employed, as the compiler will not proceed if it encounters an unknown name.

Several examples of naming conventions are listed below:

Var Bit PD_16DBO is Stop_1
Var Bit PD_16BDN is Stop_2
Var Bit PD_16GED is Stop_3
Var Bit PD_8VCL is Stop_4
Var Bit PD_16TBN is Stop_5
Var Bit Sw_P_8 is Stop_6
Var Bit Pd_Diapason_16 is Stop_1
Var Bit Pd_Bourdon_16 is Stop_2
Var Bit Pd_Gedeckt_16 is Stop_3
Var Bit Pd_Violin_Cello_8 is Stop_4
Var Bit Pd_Trombone_16 is Stop_5
Var Bit Sw_P_8 is Stop_6

Both types accomplish the same thing – they give alternative names to generic numbers and make the configuration much easier.  The entire stoplist should be set up with alternate names.

Next the couplers are defined using stp_cplr ( control_bit , Source_Key , Dest_Key , pitch ):

Stp_cplr ( Sw_U_O , Sw_k , Sw_k , p_0 )
Stp_cplr ( Sw_S_4 , Sw_k , Sw_k , p_4 )
Stp_cplr ( Sw_S_16 , Sw_k , Sw_k , p_16 )
Stp_cplr ( Gr_U_O , Gr_k , Gr_k , p_0 )
Stp_cplr ( Gr_G_4 , Gr_k , Gr_k , p_4 )
Stp_cplr ( Gr_G_16 , Gr_k , Gr_k , p_16 )
Stp_cplr ( Gr_P_4 , Gr_k , Pd_k , p_4 )
Stp_cplr ( Gr_P_8 , Gr_k , Pd_k , p_8 )
Stp_cplr ( Sw_P_4 , Sw_k , Pd_k , p_4 )
Stp_cplr ( Sw_P_8 , Sw_k , Pd_k , p_8 )
Stp_cplr ( Sw_G_4 , Sw_k , Gr_k , p_4 )
Stp_cplr ( Sw_G_8 , Sw_k , Gr_k , p_8 )
Stp_cplr ( Sw_G_16 , Sw_k , Gr_k , p_16 )

The first coupler of course defines the transition between input and output.  Once the couplers are defined, it is a mere matter of defining Stops, Ranks (segments and full ranks), and where the ranks are wired.

Building Unit Ranks

There are several types of outputs, first we will look at a unit rank:

 Stp_seg ( Sw_Piccolo_2 , p_2 , Sw_k )
 Stp_seg ( Sw_Nasard_2_2f3 , p_2_2f3 , Sw_k )
 Stp_seg ( Sw_Bourdon_4 , p_4 , Sw_k )
 Stp_seg ( Gr_Bourdon_4 , p_4 , Gr_k )
 Stp_seg ( Pd_Bourdon_4 , p_4 , Pd_k )
 Stp_seg ( Sw_Bourdon_8 , p_8 , Sw_k )
 Stp_seg ( Gr_Bourdon_8 , p_8 , Gr_k )
 Stp_seg ( Pd_Bourdon_8 , p_8 , Pd_k )
 Stp_seg ( Gr_Bourdon_16 , p_16 , Gr_k )
 Stp_seg ( Pd_Bourdon_16 , p_16 , Pd_k )
 rank_trim ( 97 , P_16 )
 rnk_seg ( 97 , 8 , 33 )

A unit rank is made up of stops, whose key pitches and source keyboards are cumulatively added together to form one big picture of what should be playing in the rank.  Each line of stp_seg consists of the stop control, the pitch it plays at, and the keyboard it plays from.  Once the segments are all defined, it is conceivable that pipes have been defined that don’t exist.  Opus-Two coupled keying buffers are 128 bits wide, and that entire buffer width is available to drive each and every rank.  A 16′ stop can easily play from an 8′ set of pipes (that would normally be marked TC).  Likewise, a 2′ stop can play from a 97 note Bourdon with no trouble.  The relay needs to know a few pieces of information to know how many of the potential 128 notes are in use for a given rank.  A rank_trim defines the number of notes and the pitch of the lowest pipe in the rank:

rank_trim ( 97 , P_16 )

That particular set of stop segments has now been trimmed to include 97 notes, starting at 16′ C.

The trimmed data now needs to be sent somewhere, and this moves it to a driver card:

rnk_seg ( 97 , 3 , 1 )

The rank segment is a chunk of the rank, defined as:

rnk_seg ( number_of_notes , card_number , pin_number )

Because sometimes different parts of ranks are wired to different locations (or borrowed from other ranks), each rnk_seg line simply tells it where to find the next part of the rank.  It will continue to look until it has filled the number of pipes defined in the trim (or run out of segment definitions).  If they were wired to multiple locations, it would look like this:

rnk_seg ( 12 , 1 , 1 )
rnk_seg ( 36 , 2 , 17 )
rnk_seg ( 13 , 10 , 1 )

The above example has the first octave wired to board 1, pin 1-12.  Next 3 octaves wired to board 2 pins 17-53, and the last 13 notes wired to card 17, pins 1-13.

 

Building Station or Primary Ranks

A primary rank is built similarly to a unit rank:

chest_enable = ( Gr_Diapason_8 | Gr_Octave_4 | Gr_Super_2)
 Stp_seg ( chest_enable , p_8 , Gr_k )
 rank_trim ( 73 , P_8 )
 rnk_seg ( 73 , 7 , 17 )

A primary rank is essentially a single-entry unit rank.  The instructions and details above apply with the addition of the chest_enable.  This simply allows any one of a collection of stops to activate a stop segment.

Stop Actions, Tremolos, Expression Blades

stp_ctrl ( exprb1 > 7 , 10 , 9 )
stp_ctrl ( exprb1 > 15 , 10 , 10 )
stp_ctrl ( exprb1 > 23 , 10 , 11 )
stp_ctrl ( exprb1 > 31 , 10 , 12 )
stp_ctrl ( exprb1 > 39 , 10 , 13 )
stp_ctrl ( exprb1 > 47 , 10 , 14 )
stp_ctrl ( exprb1 > 55 , 10 , 15 )
stp_ctrl ( exprb1 > 63 , 10 , 16 )
stp_ctrl ( exprb1 > 71 , 10 , 17 )
stp_ctrl ( exprb1 > 79 , 10 , 18 )
stp_ctrl ( exprb1 > 87 , 10 , 19 )
stp_ctrl ( exprb1 > 95 , 10 , 20 )
stp_ctrl ( exprb1 > 103 , 10 , 21 )
stp_ctrl ( exprb1 > 111 , 10 , 22 )
stp_ctrl ( exprb1 > 119 , 10 , 23 )
stp_ctrl ( exprb1 > 126 , 10 , 24 )

stp_ctrl ( Sw_Tremulant , 10 , 25 )
stp_ctrl ( Sw_Oboe_8 , 10 , 26 )
stp_ctrl ( Sw_Gambe_8 , 10 , 27 )
stp_ctrl ( Gr_Oboe_8 , 10 , 28 )
stp_ctrl ( Gr_Gambe_8 , 10 , 29 )

The stop_ctrl ( control , card pin ) activates the card/pin if the control is active.  Logic statements can be placed in the stp_ctrl, allowing expression pins to activate at a specific value.

 

Drive Output Cards

drive_output_cards ( 15 )

The controller needs to know how many output cards are connected.  The data is moved from the output card buffers named for this purpose out to the cards.