More About Consoles | Opus Two ICS

A Closer Look At Console Configurations

In this section, we will actually break apart an in-service config file and look at each line, one line at a time.  It will be explained, and anything that can be changed will also be explained.

Common Opening Header Statements

Header statements change things (controls, features) from their default value to the value you would like.  They generally could appear anywhere in the files, but putting them in the header ensures that the changes are applied as soon as possible.

Opus_Remote = low 
Opus_Remotes = high

Mostly self explanatory.  First line indicates that this is NOT a chamber and does not need to receive supporting data/material from other controllers to function.  Second line indicates that it needs to generate said data so that other controllers can be synchronized with it and receive the data that is read here.

comb_mem_bytes = 13 
pistons_per_level = 80 
combination_action = high
Opus_uSD_card ( 8 )

In PIC-based controllers, combination pistons and internal sequencer data is stored in an external memory module (FLASH or uSD).  Have a memory map set up ahead of time assures that the system always looks in the same spot for the same thing.  Adequate preparation at this stage for the size of the instrument (including any future additions) is critical to making sure organists NEVER lose combinations.

The comb_mem_bytes is determining how many bytes should be set aside for each piston on each memory level.  This is important to get right the first time – a byte holds 8 bits (or stops).  There is no shortage of memory – the combination actions are stored on the external uSD/FLASH card (lots of room).  Make this big enough that you never have to change it again.  If an organ has 35 stops, the number needs to be at least 5 (35 / 8 = 4.something).  On a 35 stop organ with no anticipated growth, it would be appropriate to make it at least 8.  This allows for storage of the state of any under the hood features that are created later that require memory storage, or any stop expansions.

pistons_per_level is the same sort of thing as comb_mem_bytes where you never want to guess too low.  A common way is to count the amount of room for pistons, so that if any are added later, space is allowed for them.  These do not take up much memory, and any reformatting of either of these two variables later will make pistons above memory level 1 scramble.  If an organ has 10 generals and 5 divisionals on each of 3 divisions, that is a total of 25 pistons (coupler reversables and the like do not count).

combination_action = high is merely activating the routines that store and process piston presses.  Without this (or with it set to =low), pressing pistons will not move any stops.  This mode can be helpful when trying to get a console up and running (forcing the combination action off prevents it from trying to move things before its known that they are wired correctly).

opus_uSD_card tells the config how big the uSD option card is (leave at 8 regardless of the card size)

piston_transposing = high

This (when high) allows transposer settings to be stored with pistons.  This setting defaults to low/off.

use_new_display ( high )

There are two types of displays that have been used on Opus-Two systems, one of which has a rather large backplane board (with built in control buttons), and the other has a thin backplane board and wiring headers for pistons.  use_new_display is for the thin backplane board.  The (high) determines whether the piston inputs are read from the backplane board or not.

crescendo_enable = low

As it appears, this line enables or disables the crescendo, including the display appearance.

use_reits = low

When high, enables a special menu to adjust reit timer values.

use_digital_tuning = low

When high, enables a special menu to enable fine tuning of Hauptwerk digital voices.

use_midi_selects = low

When high, enables a special menu to select MIDI voices for an external expander.

Common Modifications To Home Screen

if ! lvl_up_dn
   then show_transposer = high
   else show_transposer = low
 end if

Hides the transposer unless it is active.

if cresc_step == 0
  then show_cres_step = low
  else show_cres_step = high
end if

Hides the crescendo indicator unless the crescendo is activated.

Reading Input Cards

read_input_cards ( 6 , 0 )

The controller needs to know how many input cards are connected.  The data is moved from the input cards to buffers named for this purpose and can be moved to final destinations any time prior to the first coupler.

Mapping, Moving, and Manipulating Data

There are a number of ways to move data, either in large groups, or individual bits.  Think of this as copying and pasting:

map ( 4 , 1 , 61 , Swell )

map ( card_number , pin , # , destination )  – This example will copy data from card 4, pins 1-61 to the Swell keying buffer.  The # variable is not the last pin to move, but the number of bits to move so…

map ( 4 , 17 , 32 , Pedals )

…would move pins 17-48 to the Pedal Keying buffer.

Map_fragment_merge ( 5 , 49 , 8 , Pistons , 17 )

map_fragment_merge ( card_number , pin , # , destination_buffer , destination_starting_pin )

This example would allow to you move (in one command) pins 49-56 from card 5 to Pistons 17-24.  Map_fragment_merge and map are similar, but map_fragment_merge allows the selection of where the data is pasted, as opposed to map, which always starts pasting at the beginning of the buffer. The pasted data is MERGED with the data that was there, and does NOT overwrite it (this is the other key difference).

Swell & Crescendo Analog Inputs & Rollers

There are four common ways to interface with a swell shoe:

  • Reuse an existing roller contact assembly and wire to input (or IO) pins.
  • Install a linear transducer or potentiometer assembly and wire it to an analog input on a controller card.
  • Connect a new swell shoe (such as a Walker shoe) to a controller analog input.

Roller Contacts

Connect the roller contacts (in order ideally) to an input card.  For the sake of discussion, we are going to assume that the roller is 12 stages and is connected to Input Card #6, Pins 25-36.  We will also assume that we want to put the resulting value in exprb2.

convert_roller_values ( 6 , 25 , 12 , exprb2 )*

*contact us before using this

Wiring To and Using the Analog Inputs

Any potentiometer or transducer requires positive voltage, a negative voltage, and will return a value in between them.  The header on the C-IV controller provides +5V, 0V, and has 4 input pins for analog shoe connections.

Once the physical connections are made, the config file must be updated to reflect the location of the shoe:

exprb1 = filter_analog_input ( 5 , 1 , 10 , 128 , saved_solo )

filter_analog_input ( threshold , input_number , minimum , range , saver )

In this example, exprb1 is (=) analog input #1 (input_number), filtered so that changes in its value less than 5 (threshold) get ignored, the lowest 10 values (minimum) get ignored ( of the potential 0-255 vales, 0-9 get ignored).  That incoming value is not multiplied or divided (range becomes larger to make the number bigger and smaller to make it smaller), and the previous cycle’s result is stored in saved_solo for the comparison engine.

Getting Into Combination Action

--                   Ch 1     Ch 2     Ch 3     Ch 4     Ch 5
 Bit_map ( pstnb3 , In4_45 , In4_46 , In4_47 , In4_48 , In4_49 ,
--                   Ch 6     Ch 7     Ch 8  
                    In4_50 , In4_51 , In4_52 )

Bit_map ( byte , bit_1 , bit_2 , bit_3 , bit_4 , bit_5 , bit_6 , bit_7 , bit_8 )

This enables pistons to be arranged logically.  Also enables individual pistons to be put in correct locations so that certain things work out (moving pistons with manual transfers, etc.).  Bit_map isn’t just for pistons though, mis wired keyboards, stop rails, etc. can be easily mapped that way.

If the pistons are wired in the correct order* then the data can moved en mass using map or map_fragment_merge to the Pistons buffer.

* Eventually this has to be addressed:  The first 10 general pistons should end up in the first 10 bits of the pistons buffer.  This allows the “quick dial” feature for memory level selection to work properly.

At some point, we need to locate the set and cancel pistons:

cancel_piston ( in4_23 )
set_piston ( in4_24 )

And now to look at a reversible control:

east_coast_coupler ( in2_53 , 53 , 52 , 54 , 0 ) -- s/g

The east_coast_coupler watches for the button to be pressed, and does this:

  • Check to see if any of the stops are on (in this case 52, 53, or 54).  If they are, it turns them off.
  • If no stops are on when the button is pressed, it turns on the first stop.  Only the first stop will ever be turned on by this procedure, the rest only turn off.
  • This procedure supports up to 3 “off only” stops.  It can be used as a basic one-stop toggle by making the last 3 values “0”.

Another type of reversible is:

reversable_tab ( in2_53 , stop_53 ,  53 )

This will toggle stop 53 on or off each tie in2_53 is pressed.

Stop Couplers

The stop coupler serves as the transition between reading and processing any input signals and driving output signals.  When the first stop coupler is encountered, a console will automatically package up everything it has processed (keys, stops, expressions) and transmit a chamber data frame to any chamber controllers.  The system will take keying and format it for chamber use, process any traps, and clear out the output card buffer space.

stp_cplr ( low , gr_k , gr_k , p_8 )

stp_cplr ( stop_name , from , to , pitch )

This is a coupler.  The first variable is the bit (stop number or name) that activates the coupler.  “Low” means never on.  This is therefore, a coupler that can not be activated.  But it serves as a placeholder to begin the transition from inputting to outputting (see previous paragraph).

So a Great to Pedal 8 operated from stop #15 would be:

stp_cplr ( Stop_15 , gr_k , pd_k , p_8 ) 

Stop Action Coils

While there is an incredible amount of flexibility mapping stop sense wires in, the same isn’t necessarily true for mapping coils out.  The coil processing algorithm assumes that the coils are wired in the same order as the stop sense wires.

 if comb_coils_enabled then
   move_buf ( TCO1 >> 8 , TCO1 , Out_5 >> 8 , Out_5 , 7 )
 end if

This example copies 7 bytes worth of coil data (56 bits = 28 stops x 2 coils each) to Card 5.


Drive Output Cards

drive_output_cards ( 6 )

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.