Opus-Two System Design and Configuration Reference

Configuration baseline: BaseOS 82_35. The underscore separates the release number from its revision. This reference explains the relationship between an instrument’s wiring, its musical specification, its configuration program, and the control hardware. It is intended for organ builders, technicians, developers, and readers using an AI assistant to understand or prepare a configuration.

A configuration belongs to a particular instrument and controller. To adapt an example, replace its illustrative wiring and musical assignments with the installation’s verified information. A correct procedure name and a successful compilation cannot establish which wire is connected to a particular pipe, stop, or expression shoe. Legacy C-I/C-IV documentation and current CVA/CVE-family configuration instructions describe different generations; identify the controller and BaseOS before applying an instruction.

How the system turns a key into a sounding note

Opus-Two is an integrated instrument control system. The console controller combines keyboard and stop inputs with combination-action state and musical rules, then prepares the outputs required by the instrument. A conventional pipe installation also has output hardware near the windchests. Digital voices use their configured digital interfaces. The same instrument can combine these arrangements.

• Input hardware reports keys, stop senses, pistons, buttons, and expression positions.
• The configuration assigns those signals to named controls and divisions.
• Combination action and other control functions establish the current registration.
• Key processing and couplers establish which division notes are requested.
• Stop definitions add those notes to the appropriate ranks at their playing pitches.
• Output mappings connect rank notes and auxiliary actions to the installation’s physical or digital destinations.

The musical assignment and the wiring assignment are separate. A stop definition answers which rank should play, from which keyboard, at which pitch, and under which conditions. A rank-output definition answers where that rank’s successive notes are connected. This separation makes borrowing, extensions, split wiring, and changes of console layout manageable.

The product architecture is described in the Opus-Two system overview.

A short glossary

The information needed to specify a system

Begin with the actual instrument. A stoplist is necessary, but it does not contain all the information required for either a hardware quotation or a working configuration. Keep musical requirements, electrical loads, and wiring destinations together in the project documentation.

Count the outputs that must actually be driven. A unified rank can supply several stops without multiplying its physical pipe count. A compound mixture may require several pipe outputs per played key. On a chest with a shared note action and separate stop actions, count both kinds of load. A tremulant or cymbelstern control is an auxiliary action, not an additional pitched rank.

For an illustrative console, two 61-note manuals and a 32-note pedalboard require 154 key inputs. Forty conventional stop controls with one sense input and two movement coils each add 40 senses and 80 coil outputs. Those functions total 274 logical pins before pistons, lamps, expression interfaces, or other controls. Dividing by 64 gives five fully usable 64-pin card equivalents after rounding up; that is only a counting exercise. Actual card selection and quantity also depend on polarity, card type, grouping, available ports, current limits, and unused pins imposed by the wiring layout.

Choose a controller by the interfaces and capacities required at its location. The current console-controller hardware is CVER10 and CVAM4-IV. CVA-II and CVER9 names in older documentation identify earlier hardware. A NanoW receives Ethernet chamber frames and passes the selected data to an attached card chain; its setup includes the chamber to receive and the attached card count. The i97+ chamber driver combines receiver and I/O functions. Use the exact board revision’s wiring guide and ratings when specifying connections and loads. The technician support page provides separate guides for several console revisions.

Current console hardware: CVER10 and CVAM4-IV

CVAM4-IV also provides two D/A ports (analog outputs). CVER10 also has an SPI port, which is generally unused. A/D input and D/A output are different functions; a ribbon port, a card-chain port, and an analog port are not interchangeable connections. The two USB connectors have different roles: the micro-USB connector is the terminal connection, and USB-A accepts the thumb drive.

Port counts identify physical interfaces. They do not, by themselves, specify the number of cards allowed on a chain, the pinout of an attached accessory, or the permissible electrical load. Match those details to the installed card and wiring documentation. A two-chain software procedure does not create a second physical card-chain connector on CVER10.

BackPlane capacity and header allocation

The 97-note BackPlane allocation used for chamber quoting requires a different calculation from simply counting unused note outputs. Headers contain twelve positions except for the final header. When a rank is assigned complete headers without sharing a header with another rank, a 61-note rank occupies six headers, reserving 72 positions. The remaining upper end has 97 - 72 = 25 positions, not 36.

The preferred arrangement is to start a rank at physical card pin 1 or split it across the upper ends of two cards. Two 61-note ranks can start on separate cards, leaving two 25-position upper ends. A 32-note rank can then use 25 notes on one upper end and seven on the other. The wiring proof must preserve note order and prevent either overlapping pins or shared headers.

Keep the supplied rank order in the musical documentation even if an allocation tool sorts ranks internally to find a fit. Physical BackPlane header positions and the 64-bit logical card images discussed later are different address descriptions; convert between them using the actual product’s mapping, rather than treating a 97-position physical board as one conventional 64-position card image.

The configuration file skeleton

The configuration is an Oberon-family program compiled by the console controller. The following is the required structural outline, with comments identifying where installation-specific work belongs. It is a skeleton, not a complete instrument configuration.

MODULE name;
CONST
  (* [declare stop, rank, and OSC button constants here] *)
TYPE
  (* [declare additional types here, if needed] *)
VAR
  (* [declare additional variables here, if needed] *)

PROCEDURE Main_Cycle();
BEGIN
  (* [configure system settings and combination-action limits here] *)
  (* [scan I/O cards, apply input inversion, and read MIDI here] *)
  (* [configure keys and ribbon manuals here] *)
  (* [configure stops, coils, and buttons here] *)
  (* [configure pistons, reversibles, sequencer, and set/cancel here] *)
  (* [configure expression inputs and raw-manual effects here] *)
  CA.Process_Pistons;
  O2S.Record_Play;
  GIO.Init_Pipes;
  (* [configure couplers here] *)
  (* [declare ranks with P.New_Rank here] *)
  (* [define stops and route rank notes to outputs here] *)
  (* [configure stop actions and chamber/MIDI outputs here] *)
  (* [configure console displays here] *)
END Main_Cycle;

BEGIN
  (* [place startup-only calls here, if required] *)
END name.

Keep CONST, TYPE, and VAR even if there are no user declarations in them. These headers cause the embedded compiler to load the system’s constant, type, and procedure resources. The final module name must match the opening name. The final period is required. Configuration library modules are available implicitly; there is no IMPORT section.

Main_Cycle must be the last declared procedure. Declare helper procedures before it. Its body runs repeatedly. The final module BEGIN section is for startup work. A startup-only call, such as MCU.Put_Proj_Nickname, belongs there rather than in the repeating cycle.

Software layers and file formatting

The bootloader starts the controller and launches BaseOS. BaseOS provides the operating system, configuration compiler, callable libraries, and device services. The configuration supplies the wiring and behavior of one instrument. Changing the configuration and changing BaseOS are different operations. Record both the running BaseOS version and the identity of the configuration being serviced.

Configuration files use .MOD or .TXT. The language is case-sensitive. Constants use an equals sign in their declarations. Statements are separated by semicolons; the module ends with END followed by its matching name and a period. Comments use (* and *). Boolean AND is written &, OR is written OR, and NOT is written ~. Keep each procedure call on one physical line.

Embedded configuration files must use CRLF line endings: carriage return followed by line feed. The compiler uses this pair to track source line numbers. Other line endings may still compile but can make error and debugging locations unusable. Preserve the file’s encoding when making an unrelated edit, and ensure new or edited configuration files have CRLF throughout. Pasting code from a web page does not guarantee the saved file has those line endings.

INTEGER represents whole numbers; BOOLEAN represents TRUE or FALSE; BYTE holds 0–255. A type’s numeric range does not establish a parameter’s allowed values: a BYTE MIDI channel still uses its documented channel numbering, and an INTEGER card argument still needs a valid card. IF condition THEN ... ELSE ... END selects between two behaviors on each processing pass. GIO.Stop returns a stop state, GIO.Button returns a software-button state, and GIO.Expr returns a logical expression value. Use parentheses to make combined conditions clear.

Names and numbers that must stay separate

Use named constants for stops, ranks, and touchscreen controls. Names make the intent readable; their numeric values still have to agree with the wiring and the procedure arguments. Preserve established stop and piston numbering when editing an existing system because stored combinations and other references depend on that numbering.

Raw keyboard buffers and processed keying buffers

The suffix _uk identifies an uncoupled keyboard buffer. The suffix _k identifies a processed keying buffer. Map keyboard inputs into the appropriate _uk buffer. Ordinary speaking-stop definitions use the corresponding _k buffer so the stop receives the intended coupling and key processing. The semantic source and destination of a coupler must be checked against the actual procedure being called.

These are library names and aliases, not instructions to infer the physical order of keyboards from a division name. The installation specifies which physical keyboard maps to each buffer. Named divisions can share a keyboard, and a keyboard can control additional divisions through couplers or transfers.

Card scanning and physical input mapping

GIO.Opus_Cards_IO(num_a, num_b) scans the two logical card chains. Each chain exchanges input and output data. Call it before consuming that pass’s mapped inputs. The arguments are the attached card counts for the logical chains, not the number of ranks, remote chambers, or MIDI channels.

GIO.Opus_Cards_IO ( 3, 0 );
GIO.Map_Keys ( 1, 1, gr_uk, 1, 61 );
GIO.Map_Stops ( 2, 1, 2, St_First );
GIO.Map_Pistons ( 2, 9, 4, 1 );
GIO.Set_Button ( 2, 13 );
GIO.Cancel_Button ( 2, 14 );

This illustrative fragment scans three cards on logical chain A and none on B. It reads 61 Great keys beginning at card 1 pin 1 into notes 1 through 61, two maintained stop contacts from card 2 pins 1 and 2, four piston contacts from pins 9 through 12, SET on pin 13, and CANCEL on pin 14. St_First must be declared as the first stop number in the two-stop run. The physical installation must match all of those assignments.

A standard 64-position card image occupies eight bytes. For a one-based physical card C and pin P, the zero-based byte containing that position is (C - 1) × 8 + floor((P - 1) / 8). For example, card 2 pin 1 is in byte 8. This formula describes the image; it does not establish the pin convention of every low-level helper. Check the called procedure before translating an internal bit index into a physical pin.

A contiguous run can cross a card boundary where the applicable mapping routine advances through the same continuous chain. A new call is needed when the wiring sequence, logical assignment, or supported destination is no longer contiguous. Do not split every stop into a separate call merely because the routine also supports a quantity argument.

For a whole active-low input card, use GIO.Card_Invert after scanning. It operates on validated scan data. GIO.Invert_Byte is a different, byte-level operation; its image selector and timing matter. Input inversion and output drive polarity are different concerns. Inverting a magnet or stop-coil output image can leave loads continuously energized; it is not a substitute for the correct output hardware or coil control.

Ribbon peripherals and remote stop controllers

RibFlex ports are the ribbon-peripheral connections used for supported keyboards, input modules, analog peripherals, and serial stop controllers. Older procedure and constant names may call them Pmux ports. The SPI_Per library name is historical: these peripheral calls use the RS-485/RibFlex path. They do not refer to CVER10’s separate, generally unused SPI connector.

SPI_Per.Get_Manual reads a Hall-effect keyboard or pedalboard into a raw keyboard buffer. Its port selects the physical RibFlex connection, k_adr selects the device’s scan address on that connection, man selects the destination keyboard buffer, and start and num select the scanned run. Devices sharing a port need distinct scan addresses. The BaseOS 82 destinations documented for this call are sw_uk, gr_uk, ch_uk, so_uk, and pd_uk. Physical scan order and direction of key travel are separate settings, handled by SPI_Per.Set_Key_Order and SPI_Per.Set_Key_Motion.

SPI_Per.Read_Mini_In places a peripheral’s scanned inputs into a selected card position in the normal input image. Subsequent key, stop, and piston mappings use that destination card position. Reserve the destination so another input source does not overwrite it. Its address argument can also carry device-specific mode flags; use the actual peripheral’s address and mode specification instead of treating every peripheral address as a plain card number.

Serial stop controllers provide a different connection from parallel card/pin movement coils. SPI_Per.Map_SC_Coil_Group maps a local RibFlex stop-controller group, including its coil timing and drive settings. SPI_Per.Map_Enet_SC_Coils assigns a group to a remote controller running Remote SC firmware: Ethernet carries the stop and coil commands, and that remote controller handles the serial-coil communications. The remote IP octet, group, quantity, first stop number, and drive settings must match the installed group.

Mapping moving stops and their coils

A conventional moving stop control can require three signals: a sense input, an ON coil, and an OFF coil. The pin layout determines which mapping procedure fits. Similar procedure names do not imply the same wiring stride.

CA.Map_Grouped_Stops ( St_First, 2, 1, 2, 2, 2, 3, 2 );

This example maps two triplet-wired stops. The first uses card 2 pins 1, 2, and 3 for sense, ON, and OFF. The second uses pins 4, 5, and 6. The stops receive consecutive numbers beginning at St_First. This example is an alternative wiring layout to the maintained-contact example above, not an additional mapping for those same pins.

Choose coil timing for the installed hardware and preserve the established value when making an unrelated configuration edit. A stop-sense mapping by itself does not define the coils that physically move the stop. Conversely, coil mapping without the correct sense input does not tell the controller the control’s real position.

Combination action and stored controls

A piston has both a range and stored contents. Its range determines which stop states it can affect. Its contents determine the recalled on/off state within that range. General and divisional labels describe an intended use, but the configured or stored range determines the actual set of affected controls. Opus-Two also uses Organist and Folder for the user’s separate collection of combination settings.

CA.Set_Stop_Count specifies the stop-state storage span. Include all state positions needed by the combination action, including stored software controls where applicable. It is not simply the number of physical drawknobs or movement coils. The documented maximum is 1600 stop-state positions. CA.Set_Max_Pistons sets the highest available piston number; use 1 through 350. Values above 350 are ignored. Changes to these layout-defining values on an established instrument need to account for existing stored data.

CA.Set_Max_Mem_Level accepts a positive level limit and clamps requests above the controller’s hardware-dependent maximum. A headline memory capacity is not a complete statement of folder count, levels per folder, and the installation’s active layout.

For a control with no physical moving stop, map the contact to a software button with GIO.Map_Buttons. Use CA.Map_Buttons_To_Stops when the state must participate in piston capture and recall. That mapping also keeps the button state synchronized with recalled stop state. Add the appropriate output action if the control operates a device.

A coil-backed reversible operates an actual stop mechanism. A software-button toggle operates a stored button state. Select the mechanism that matches the installed control. When relocating a toe stud, check every use of the old and new contact: piston maps, reversibles, sequence controls, and dedicated buttons can otherwise cause two functions to fire together.

The required processing order

CA.Process_Pistons;
O2S.Record_Play;
GIO.Init_Pipes;

In the ordinary combined-processing configuration, call these once in each Main_Cycle pass in exactly this order. CA.Process_Pistons performs combination-action processing. O2S.Record_Play enables the record/playback and debounce processing used by controls. GIO.Init_Pipes prepares the keying buffers for the pipe-processing section. O2S.Record_Play is required even if the installation does not offer recording to its users.

Place raw-manual operations such as GIO.Manual_Transfer before GIO.Init_Pipes. Apply ordinary couplers after GIO.Init_Pipes. Initialize each accumulated rank before adding its stop contributions, and output the rank after those contributions are complete. Place display and transmission work after the states it consumes have been prepared. Advanced split combination-action processing is a separate pattern; do not add split calls alongside the ordinary combined call without a complete design for that sequence.

A complete teaching example of the note path

The following example makes the wiring assumptions explicit: a 61-note Great keyboard is on input card 1 pins 1–61, one maintained stop switch is on card 2 pin 1, and a 61-note 8-foot rank is connected in ascending order to local output card 3 beginning at pin 1. All three cards belong to logical chain A. There are no moving stop coils, piston contacts, remote chambers, expression inputs, or digital voices in this example. Its purpose is to show a complete module and note path; a real instrument needs its own wiring and operating settings.

MODULE NotePath;
CONST
  St_Great_Principal = 1;
  Rk_Great_Principal = 1;
TYPE
VAR

PROCEDURE Main_Cycle();
BEGIN
  CA.Set_Stop_Count ( 1 );
  CA.Set_Max_Pistons ( 1 );
  GIO.Opus_Cards_IO ( 3, 0 );
  GIO.Map_Keys ( 1, 1, gr_uk, 1, 61 );
  GIO.Map_Stops ( 2, 1, 1, St_Great_Principal );
  CA.Process_Pistons;
  O2S.Record_Play;
  GIO.Init_Pipes;
  P.New_Rank ( Rk_Great_Principal, "Great Principal", p_8, 61, P.Primary );
  P.Define_Stop ( St_Great_Principal, -1, 10, Rk_Great_Principal, p_8, gr_k, -1, -1 );
  P.Rank_Notes_Out ( Rk_Great_Principal, 61, P.Forward, 0, 3, 1 );
END Main_Cycle;

BEGIN
END NotePath.

The stop constant and rank constant are both 1 because they belong to separate namespaces. The key mapping establishes raw Great notes. After the required processing calls, P.New_Rank prepares the named rank, P.Define_Stop contributes Great keying while the stop is on, and P.Rank_Notes_Out places the 61 rank notes in local output space. The two -1 range arguments request the full compass. In this ordinary logic-10 form, a nonpositive second-stop argument leaves the primary stop as the controlling stop.

Ranks, borrowing, extensions, and output segments

In the accumulated method, P.New_Rank identifies a rank by its own number, label, base pitch, compass, and P.Unit or P.Primary classification. P.Define_Stop then adds the contribution of a selected stop and keying buffer. Several stops can contribute to the same rank. P.Rank_Notes_Out sends successive portions of that rank to the configured outputs.

For example, a physical flute rank beginning at 8-foot pitch with 73 notes can provide a full 61-note 8-foot stop and a full 61-note 4-foot stop. The upper octave is available because the rank extends twelve notes beyond the manual. The two stop definitions use different playing pitches but share the same rank ID. Rank length comes from the actual pipework; naming a 61-pipe rank as 73 notes does not create the missing pipes.

P.New_Rank ( Rk_Flute, "Flute Unit", p_8, 73, P.Unit );
P.Define_Stop ( St_Flute_8, -1, 10, Rk_Flute, p_8, gr_k, -1, -1 );
P.Define_Stop ( St_Flute_4, -1, 10, Rk_Flute, p_4, gr_k, -1, -1 );
P.Rank_Notes_Out ( Rk_Flute, 61, P.Forward, 1, 1, 1 );
P.Rank_Notes_Out ( Rk_Flute, 12, P.Forward, 1, 2, 1 );

This is a pipe-section fragment with illustrative names and wiring. Declare its constants and provide its stop inputs, keyboard mapping, and receiver setup elsewhere. The first output call consumes 61 rank notes; the second consumes the next 12. The output counts add to the declared 73-note compass. In this layout the second segment deliberately starts at another card, leaving the unused positions after the first segment untouched.

P.Define_Stop has eight arguments: primary stop, secondary stop or touchscreen control, logic selector, rank, playing pitch, keying buffer, range start, and range end. With skip = -1, the full compass is selected. For a ranged definition, skip and run are the first and final one-based note numbers, not a starting note and a count. To split a 61-note manual after note 20, the ranges are 1,20 and 21,61.

The documented logic selectors include 10 for a secondary-stop-off condition, 11 for a secondary-stop-on condition, 12 for an additional OSC/iPad contribution, and 99 for forced-on behavior when the secondary-stop argument is positive. The secondary argument changes meaning with the logic selector. Do not insert a touchscreen button number into a condition that expects a stop number.

The sequential GIO method uses a shared working buffer instead of a rank ID: build the contributions with GIO.Stp_Seg, set the base pitch and compass with GIO.Rank_Trim, and output segments with GIO.Ext_Rnk_Seg. Keep the entire sequence for one rank together. GIO and P procedures with similar names are not interchangeable: the accumulated P form commonly adds a rank argument. Preserve the established method when editing an existing rank.

Chromatic, reversed, diatonic-split, multiple-output, and mixture arrangements require their own output mapping. Tn2 names refer to diatonic-split output, not second-touch keying. Check the precise procedure’s direction codes, starting-pin convention, and note consumption before translating a chest plan. The simple forward examples above do not define those other mappings.

Forward, reverse, and two-output rank segments

P.Rank_Notes_Out uses the same chamber/card/pin address for forward and reverse wiring: supply the beginning of the output block as though the wiring were forward. P.Reverse reverses the note order within that block. Do not move the supplied address to the high end yourself. For N notes beginning at pin P within one card, the occupied positions are P through P + N - 1. Forward puts the next rank note at P; reverse puts it at P + N - 1.

P.Rank_Notes_Out ( Rk_Example, 4, P.Reverse, 1, 3, 10 );

This illustrative call occupies chamber 1, card 3, pins 10–13. The next four rank notes go to pins 13, 12, 11, and 10, respectively. The next output call continues with the fifth rank note. The reverse convention belongs to this procedure; do not assume that every other procedure with a direction argument uses the same convention.

P.Rank_Notes_Out2 with P.Forward sends each rank note to two consecutive output positions. A three-note segment beginning at pin 10 uses pairs 10/11, 12/13, and 14/15 and consumes three rank notes. The example below uses forward output in chamber 1. Other direction and destination combinations require guidance for the installed version; the ordinary Rank_Notes_Out reverse convention does not establish their behavior.

P.Rank_Notes_Out2 ( Rk_Example, 3, P.Forward, 1, 3, 10 );

P.Rank_Notes_Dia_Skip divides successive rank notes between two diatonic sides, with independent direction and chamber/card/pin assignments. Set the two per-side skip settings with P.Set_Skips before the output call. pairs is the number of notes sent to each side, so a call consumes 2 × pairs rank notes. When the next rank note is C, one side receives C, D, E, F-sharp, G-sharp, and A-sharp; the other receives C-sharp, D-sharp, F, G, A, and B. Each side supports forward or reverse output. Specify the actual spacing and starting positions from the chest wiring and the matching procedure version.

Pitch constants

Use the library’s pitch constants. p_8 is the unison reference. p_16 is an octave below, p_4 is an octave above, and p_0 is the special unison-off control value. p_0 is not a sounding pitch. A rank’s base pitch describes its bottom pipe; a stop’s playing pitch describes how keyboard notes contribute to the rank. These are related but distinct values.

The appendix records the full public pitch-constant inventory for this baseline. Preserve the documented spellings for fractional pitches rather than deriving a new identifier from the printed stop label.

Couplers and transfers

Read a coupler label “Swell to Great” as: playing the Great keyboard also requests Swell notes. The sounded division is Swell; the played keyboard is Great. Argument names can be misleading across wrappers, so describe those two roles explicitly.

P.Stop_Coupler ( St_Swell_to_Great_8, sw_k, gr_uk, p_8 );

In P.Stop_Coupler(stop, source, dest, pitch), the argument named source is the sounded division’s processed buffer, and the argument named dest is the played keyboard’s raw buffer. The lower-level GIO.Stp_Cplr(stop, dest, source, pitch) names those same positional roles the other way around. In both of these calls, the first buffer argument receives the coupled notes and the second supplies the played notes.

Place unison-off definitions before other couplers and use the affected division’s _k buffer in both buffer positions. For example, a Swell unison off uses sw_k, sw_k, p_0. Ordinary intermanual coupling normally uses the sounded side’s _k buffer and the played side’s _uk buffer. Using a processed source can propagate coupling that was not intended. Cumulative coupling is a deliberate musical design that should be specified explicitly.

A coupler adds a division to a played keyboard. GIO.Manual_Transfer exchanges raw keyboard assignments and belongs before GIO.Init_Pipes. A transfer of only a particular stop group is usually expressed by selecting the target keying in the stop-definition section. For an exclusive transfer, put the destination definitions in the IF branch and the home definitions in the ELSE branch; leaving the home definitions active outside the conditional makes both locations play.

(* After rank initialization, in the stop-definition section: *)
IF GIO.Stop ( St_Flute_Transfer ) THEN
  P.Define_Stop ( St_Flute_8, -1, 10, Rk_Flute, p_8, sw_k, -1, -1 );
ELSE
  P.Define_Stop ( St_Flute_8, -1, 10, Rk_Flute, p_8, gr_k, -1, -1 );
END;

In this fragment the transfer control moves the selected flute stop from Great keying to Swell keying. The speaking stop must still be on in either branch. Initialize Rk_Flute before this conditional and output it afterward. For a complete stop-group transfer, put every affected stop definition in the appropriate branch.

Sustain and legato holding

P.Sustain and P.Legato act on raw manual keying. Place them after the relevant input mapping and before GIO.Init_Pipes. Their trigger argument is the condition that engages the effect. Call the procedure on every processing pass, including passes with trigger FALSE, so releasing the control also releases the stored notes.

The id argument selects one of sixteen effect records, numbered 0–15. These records are shared by Sustain, Legato, and SosteLegato. Give each independent effect its own id so two manuals or effects do not share stored notes unintentionally. Use the raw _uk manual constant, such as gr_uk or sw_uk.

(* After raw input mapping and before GIO.Init_Pipes: *)
P.Sustain ( gr_uk, 0, GIO.Stop ( St_Great_Sustain ) );
P.Legato ( sw_uk, 1, GIO.Stop ( St_Swell_Legato ) );

This fragment gives Great sustain record 0 and Swell legato record 1. The two named stop constants represent the installation’s mapped controls. Keep the calls active when either control is off; pass its FALSE state rather than omitting the call.

Percussion, pizzicato, and reiteration

Pizzicato limits a note to a short pulse. Reiteration repeatedly interrupts and restarts a held note. These effects can be generated in the console or in the chamber controller. Chamber-side timing is preferable when precise timing is important or several consoles share the same chamber behavior. Console-side effects are configured in the note-processing path; the P forms act on a named accumulated rank, while the GIO forms act on the sequential working rank.

Timing units belong to the individual procedure. For P.Pizz_Stp and P.Reit_Stp, the documented timing values count routine or configuration-cycle invocations; they are not milliseconds. P.Pizz_Stp can end its pulse early when the key is released. P.Reit_Stp uses timer slots 0–15 and needs a speed greater than two for a distinct off phase. Preserve the installed timing design and validate the resulting action on its actual controller and mechanism.

Expression, crescendo, and auxiliary actions

Treat the physical shoe channel, logical expression number, and output destination as separate assignments. CA.Calc_ADC reads a selected ADC channel, applies stored calibration and hysteresis, and returns a value from zero through the requested positive stage limit. GIO.Set_Expr stores that result in a logical expression box. Normal configurations use 0–127 for direct compatibility with MIDI expression and the documented blade and Gray-code helpers.

GIO.Set_Expr ( 1, CA.Calc_ADC ( 2, 127 ) );
P.Expr_Blades_Out ( 1, 8, 1, 4, 1 );

In this illustrative fragment, physical ADC channel 2 controls logical expression box 1, which drives eight blade outputs at chamber 1, card 4, beginning at pin 1. The numbers must be replaced with the verified channel and wiring. Calibration cannot correct an assignment to the wrong shoe channel.

P.Expression_Gray_Code_32 uses five output bits; P.Expression_Gray_Code_64 uses six. Both are designed around the normal 0–127 expression range. CA.Calc_External_ADC is a different scaler: it uses the supplied input minimum and maximum rather than applying the stored calibration for a physical ADC channel. Avoid treating its channel-like argument as an instruction to read a physical shoe.

An expression shoe changes a division’s loudness through shades or digital expression. A crescendo shoe advances a programmed sequence of registrations. A tutti or sforzando introduces its programmed registration. These are separate functions even when they use similar physical controls. Crescendo and tutti behavior, including which stops participate, belongs in the musical specification and the stored setup.

CA.Get_Cresc_Sforz retrieves a stored stop-state bitmap: item 0 selects the actively loaded crescendo step, and items 1 through 4 select the corresponding tutti. Its destination is the firmware’s GIO.Stops_T type, exposed as Stops_T in the configuration type resource. For this baseline the buffer occupies 200 bytes: MCU.max_coil_size is 1600, and MCU.max_stops_bytes is (1600 + 7) DIV 8. Allocate the full Stops_T buffer even on an instrument with fewer configured stops. This is packed stop-state data, not 200 stop numbers or a text list.

(* In the module VAR section: *)
  CrescSnapshot : Stops_T;

(* In a procedure, after the desired state has been prepared: *)
  CA.Get_Cresc_Sforz ( 0, CrescSnapshot );

Auxiliary devices such as tremulants, cymbelsterns, lamps, and stop actions generally follow a control state rather than a pitched note compass. P.Stop_Action follows a configured stop and/or OSC button at a destination. It does not itself toggle that control. Use the output method suited to the load, including any required local timing or controller-specific behavior.

Piston sequencing and performance recording

The piston sequencer steps through registrations. The performance recorder records and plays an organ performance. They are different functions, and the configuration’s required O2S.Record_Play processing call also serves control debouncing.

Group the piston-sequencer setup together: CA.Seq_Enable, CA.Seq_Fires_From_GC, and CA.Set_Last_General precede the Next/Previous controls. Set_Last_General establishes the highest general piston used by this sequence. Seq_Fires_From_GC(TRUE) permits Next to advance from general-cancel state to General 1.

Seq_Next_CP and Seq_Prev_CP take physical card/pin inputs through the debounced contact path. Range-based sequence calls repurpose piston triggers; the specified range does not set the whole sequence’s travel range. Their arming and debounce behavior differ, so Next and Previous variants must not be assumed identical.

For musicians, the distinction between a piston’s range and its contents is essential: a “reeds off” piston can have a range containing the reeds and stored contents with those stops off. The organist instructions explain range setting, registration storage, recording, crescendo, and tutti operation for the supported display generations.

MIDI and digital voices

For each MIDI connection, document the port, direction, channel, note range, expected pitch, stop-control behavior, and expression route. MIDI channel numbers are not ranks or chamber numbers. A device receiving notes still needs the correct voice selection and expression behavior.

WTC.Send_PC_Msg(stop, ch, num, last_octet) sends a program-change message to the destination NanoW controller and checks the state of the specified Opus-Two stop. Pass ch as the human-facing MIDI channel number, 1–16. Pass num as program number 0–127. Do not subtract one from ch or add one to num before calling this procedure. last_octet is the destination IP address’s final octet.

WTC.Send_PC_Msg ( St_Digital_Voice, 1, 0, 123 );

This argument example identifies channel 1, program 0, and the device whose address ends in .123, with St_Digital_Voice as the controlling stop. Replace both the stop assignment and network destination with the installation’s values.

P.Midi_Stop can send a raw keyboard independently of a stop when logic is 1. In the ordinary stop-controlled mode it uses processed keying and the controlling stop, releasing previously active notes when that stop turns off. Its skip and run parameters are reserved; use -1 for both rather than assuming they provide the range selection supported by P.Define_Stop.

The exported GIO.Midi_Expr_Out and Midi_IO.Expr_Out wrappers take an expression-box index. That is different from an interface taking the raw expression value. Confusing an index with a value can produce valid syntax and the wrong musical result.

Walker integration adds a digital note path and a stop-selection path. WTC.Sysex_Stop binds the digital control number to a stop, with the control number first. WTC.Send_Stops transmits the prepared stop state to the specified device’s last IP octet. WTC.Sysex_Welcome belongs in the module’s startup section when required by that installation. A declared digital rank and a visible drawn stop alone do not prove that notes, voice selection, and expression all reach the engine.

Walker stops can be assigned to digital primaries or defined as digital units assigned to a MIDI channel. Walker expects at least 61 notes per primary. The normal extended primary is declared at p_16 with 85 notes: twelve below the standard 61-note keyboard, the keyboard’s 61 notes, and twelve above it. The extra notes allow sub and super couplers to send keying beyond the physical keyboard compass. Whether the engine actually sounds those notes depends on its available and enabled voices.

The primary’s p_16 base and 85-note length describe its extended keying compass. They do not say that every Walker stop speaks at 16-foot pitch. The stop or digital-unit definition and the engine’s voice assignment establish the musical pitch. Keep the primary compass, stop footage, MIDI channel, and expression assignment separate in the specification.

The documented Walker chamber convention allocates two 64-position card images per MIDI channel, beginning at card 2 × channel - 1, with the first transmitted note at position 25. These are encoded digital addresses rather than physical cards to include in GIO.Opus_Cards_IO. The channel-1 primary therefore starts at card 1 pin 25; channel 2 starts at card 3 pin 25. The channel and digital chamber must agree with the receiver’s setup.

P.New_Rank ( Rk_Digital_Great, "Digital Great", p_16, 85, P.Primary );
(* Add the installation’s primary-keying contributions here. *)
P.Rank_Notes_Out ( Rk_Digital_Great, 85, P.Forward, Ch_Digital, 1, 25 );

This is a primary-compass and output-location fragment for MIDI channel 1. Rk_Digital_Great and Ch_Digital are installation constants. The fragment still requires the appropriate keying contributions, Walker voice-control bindings, expression routing, and stop transmission; an output mapping alone does not supply those functions.

Networks, chambers, and external interfaces

Give every device a unique IP address and every console its intended identity number. The documented controller convention uses a /24 subnet, with 255.255.255.0 as the mask. Calls that take a last octet obtain the rest of the network address from the controller’s subnet. The common factory console address is 192.168.175.12; additional consoles are commonly assigned .13, .14, and onward. These conventions do not override the actual site address plan.

A logical chamber is an output buffer. A receiver is a network device configured to use a chamber and, where supported, a portion of that chamber’s data. Several receivers can therefore use different parts of the same logical chamber. The buffer carries output state; the configuration and wiring documentation supply the musical meaning of its positions.

For the BaseOS 82_35 constant set, chmbr_max is 15 and chmbr_limit is 16. The latter is an internal limit expression, not a promise that chamber 16 is a normal supported chamber. Chamber 0 is used by the documented output procedures for local outputs. Special image selectors used by low-level helpers are not additional ordinary chambers.

Ethernet chamber frames, legacy serial PipeBus transport, the service terminal, MIDI, and application API messages are different interfaces. A legacy RS-485 Nano and an Ethernet receiver do not have the same transport. A Raspberry Pi or other external application must implement the specific interface it is intended to use, with its matching firmware’s discovery, framing, state-update, and timeout behavior.

An API command handled by a controller application is not automatically callable from a configuration module. Configuration calls must exist in that BaseOS’s exposed callable interface. Conversely, a named configuration routine is not automatically a network command. The interface catalogue below is the configuration-call surface; it is not a wire-protocol specification.

For an external output receiver, define how fresh state replaces old state and what happens when updates stop. A newly received state snapshot must allow previously active outputs to turn off. Discovery visibility alone does not establish that the correct chamber, byte range, or musical mapping is being received.

Ethernet chamber discovery and output frames

An Ethernet chamber receiver announces the chamber it wants. The console records the receiver’s source IP address and sends that chamber’s binary output state to UDP port 5005. This section describes automatic chamber discovery and the chamber-frame transport. Ordinary chamber identifiers are 1–15. Application API traffic uses identifier 108 and has a separate contract.

Receiver discovery

Listen on UDP port 5005 before announcing. Send an SSDP NOTIFY advertisement to multicast address 239.255.255.250, UDP port 1900, from the receiver’s actual address on the organ network. Announce at startup and repeat about every five seconds. Select the organ-facing network interface explicitly on a computer with several adapters. A new receiver must be in the console’s configured subnet.

The embedded parser recognizes literal strings, including NTS:ssdp:alive, USN:uuid:, and Opus-Two. Preserve their capitalization and punctuation. In particular, inserting a space into NTS: ssdp:alive or USN: uuid: changes a string the parser expects. Send ASCII with CRLF line endings and a final blank line. Keep discovery packets below 250 bytes for compatibility with both the 250-byte and 300-byte parser limits.

The receiver’s requested chamber and offset are encoded in the name carried inside the UUID. A conventional name is N_<decimal-last-IP-octet>_<C><OO>. C is one uppercase hexadecimal chamber digit. OO is a two-digit hexadecimal, zero-based byte offset into the chamber. It is a byte offset, not a card number or a pin number.

Build the UUID bytes from ten bytes of ASCII name, padded with zero bytes, followed by six MAC-address bytes. Keep the visible name to nine characters so the name area includes a terminator. Format the result as uppercase hexadecimal in 8-4-4-4-12 groups. This field carries encoded data; generating a random UUID or replacing its version/variant bits would damage the requested name.

Receiver name: N_123_100
Illustrative MAC: 02:00:00:00:01:23
Name bytes: 4E 5F 31 32 33 5F 31 30 30 00
MAC bytes:  02 00 00 00 01 23
UUID: 4E5F3132-335F-3130-3000-020000000123

The following complete illustrative advertisement requests chamber 1 with 30 card-sized groups and offset zero. NanoE is the Ethernet receiver identity used by this example. It does not identify a legacy RS-485 Nano. Substitute the real receiver identity and MAC address. Each displayed line must end with CRLF, and the packet must end with an additional CRLF.

NOTIFY * HTTP/1.1
HOST: 239.255.255.250:1900
NTS:ssdp:alive
NT:urn:Opus-Two NanoE
NT:urn:Version Emu1 :urn:Cards 1E
USN:uuid:4E5F3132-335F-3130-3000-020000000123::urn:Opus-Two NanoE
CACHE-CONTROL: max-age=3600
LOCATION: *

The second NT line carries version and card-count metadata. The card count is hexadecimal: 01 means one eight-byte group, 10 means sixteen groups, 1E means thirty, and 22 means thirty-four. Writing 30 would request hexadecimal 30, or forty-eight groups. The card-count parser is inside the version-metadata path, so preserve that structure.

The console routes replies using the packet’s source IP. The decimal octet in the encoded name does not override that address. LOCATION is not used to obtain an HTTP device-description document on this path. M-SEARCH alone is not a substitute for the receiver’s NOTIFY/alive announcement. The chamber stream does not require Dev Subscribe, an API Burst request, or an AppleMIDI invitation.

Offsets, lengths, and receiver identity

The 34-group chamber transport provides 34 eight-byte groups per chamber, for 272 bytes. It uses the advertised card count when valid and substitutes its maximum for a missing, zero, or excessive value. An older sender can send a full 30-group, 240-byte buffer. Always validate the received length instead of assuming the requested count determines every sender’s packet size.

groups_sent = min(34, requested_groups + ceil(byte_offset / 8))
payload_bytes = groups_sent * 8
local_data = payload[byte_offset : byte_offset + requested_groups * 8]

The transmitted payload still begins at chamber byte zero. The offset increases the prefix length sent; the receiver performs the slicing. For four groups at byte offset 16, the console sends 48 bytes and the receiver uses bytes 16–47. Reject a request whose desired slice extends beyond the available payload. Do not wrap the slice around the buffer.

Several IP addresses can request the same chamber. Entries are keyed by source IP, so changing the encoded name does not create another independent receiver at the same IP. The discovery table for this transport has 25 entries. It also supports a name suffix such as 17M: primary chamber 1 and secondary chamber 7, delivered as separate frames. M selects this two-chamber form and is not an offset digit.

After changing a receiver’s chamber or offset, verify the console’s discovery entry and the actual received byte range before using the new assignment. A visible device name alone does not prove that every cached routing field reflects the new settings.

Ordinary chamber datagram layout

All offsets in this table begin at the first byte of the UDP payload, excluding Ethernet, IP, and UDP headers. Chamber data is sent to port 5005. The fixed envelope is RTP-like, but the data after it is the Opus-Two chamber image.

Ordinary chamber frames always use two length bytes, including payloads below 256 bytes. Eight data bytes therefore use length 00 08 and give a 23-byte UDP payload. A 240-byte image gives 255 bytes total; a 272-byte image gives 287. There is no text terminator, extra application CRC, or serial PipeBus wrapper after the chamber bytes.

80 64 12 34 00 00 00 A0 76 54 32 10 01 00 08 01 00 00 00 00 00 00 00

This complete synthetic packet contains chamber 1, sequence 1234 hex, timestamp A0 hex, and eight data bytes. Only bit zero of the first data byte is set. It illustrates encoding; it is not a recording from an installed organ.

The sender takes the sequence from the low 16 bits of its processing-pass counter. It wraps from 65535 to zero, and several different chamber packets sent during one pass can share the same number. Track sequence and freshness per console IP and chamber. Do not discard a different chamber merely because its sequence matches the preceding packet. A missed packet does not prevent a later complete state from being used.

Using a chamber snapshot

For ordinary card outputs, every eight-byte group represents 64 logical bit positions, least significant bit first within each byte. For zero-based bit index i, use byte i DIV 8 and mask 1 shifted left by i MOD 8. A set bit is an asserted logical output. The installation’s wiring and output hardware determine the resulting electrical action.

Replace the previous snapshot from that source, including its zero bits. These packets are complete current states, not a stream of note-on and note-off events. OR-ing successive snapshots forever would prevent outputs from turning off. For a receiver serving several consoles, retain a separate fresh snapshot for each console and combine only those currently valid contributions.

Check the fixed header, chamber, declared length, available bytes, expected source, and requested slice before using the data. Clear a source’s output contribution when its updates become stale according to the receiver’s documented timeout. A timeout belongs to receiver behavior; it is not a number carried in the chamber frame. Keep the timeout separate from the much slower SSDP advertisement interval.

The frame contains no rank names, stop names, or wiring descriptions. Some configurations use a chamber for digital or other packed data. Interpret the bytes according to that configuration. Do not send raw Ethernet datagrams down a legacy RS-485 PipeBus connection: the serial receiver requires its own framing and timing.

Controller application API

The controller API carries commands such as CA Gen Can and Dev Subscribe inside eFrames with identifier 108, hexadecimal 6C. It is separate from the configuration procedure interface, ordinary chamber output, OSC tuning messages, file transfer, and the interactive terminal. A command’s spaces and capitalization are part of its spelling. Send one complete command per datagram.

OpusAssistant’s current implementation sends controller API commands through UDPCommandService and uses DiscoveryService’s shared socket bound to UDP port 5005. Replies return to that port at the client’s IP address. An external client should likewise listen on 5005 before sending and retain the sender’s identity with every reply. A send operation succeeding only establishes that the datagram was handed to the network; the reply or resulting state establishes what the controller did.

Current application framing and legacy short framing

The current OpusAssistant encoder uses the same twelve-byte fixed header shown above, sets byte 12 to 6C, writes a two-byte big-endian payload length at bytes 13–14, and begins the payload at byte 15. Its text-command path accepts up to 49 UTF-8 bytes and appends one zero byte, included in the declared length. Use ASCII for the documented commands and names to match the controller’s text parser. The encoder accepts a maximum payload of 550 bytes for binary commands. Its API timestamp may be zero.

Query OLED, encoded by the current application:
80 64 00 01 00 00 00 00 76 54 32 10 6C 00 0B
51 75 65 72 79 20 4F 4C 45 44 00

The final eleven bytes are the ten characters Query OLED followed by a zero. This is a read-only query example and a byte-encoding example; it is not a live exchange.

There is a legacy short-message variant. This older transport writes one length byte for short identifier-108 payloads and begins their text at byte 14. Its console-message buffer is 64 bytes. That transport is not interchangeable with the application’s two-byte, binary-page-capable format. Ordinary chamber output still uses two length bytes in the older transport.

Choose framing from the actual controller transport version. Do not infer API compatibility solely from a configuration library version, and do not silently send both encodings for a state-changing command. The named current application format and the older short format are distinct compatibility profiles. Large page transfers require the transport that supports their full binary payload.

API commands and argument conventions

The following commands are implemented in the API module associated with this reference. N means a decimal argument, not literal text to transmit. Use positive one-based numbers for ordinary stops, pistons, tracks, folders, levels, and buttons unless a row explicitly states otherwise. The configured instrument still limits which numbers are meaningful. A parser’s positive-number test does not prove that a particular piston or track exists.

Do not supply negative values to the generic decimal parser expecting rejection: it searches for digit characters and does not parse a signed number. Keep required numbers and quoted strings explicit. Unknown commands need not produce an error reply. Use the documented command set; a label in a client interface does not establish that the connected controller implements a corresponding command.

Commands that toggle, increment, delete, reset, record, or program have state-changing effects. The API has no documented transaction identifier tying every reply to a particular command. Serialize requests where their replies matter, tolerate duplicate responses, and do not automatically repeat a toggle merely because its first reply was lost. Reconcile with the returned current state.

Replies, subscription, and live status

Some responses go directly to the command sender; some named/status responses go to the subscriber list when subscribers exist. A client expecting those updates should subscribe and continue receiving asynchronous messages while awaiting a command response. OpusAssistant separately advertises an Opus-Two API SSDP identity about every five seconds. That discovery beacon and Dev Subscribe have different purposes.

The subscription handler described here admits up to four distinct IP addresses. It sends change-driven updates plus periodic updates distributed across the listener list. Do not treat its scheduler intervals as a guaranteed per-client frame rate. The documented command set has no unsubscribe command.

A status payload begins with the quoted marker "API Burst". Fields are colon-separated, with quoted text fields. Parse delimiters outside quotes so a colon inside a name does not shift the field positions. The current layout’s stable prefix is listed below, with the marker numbered zero.

Older bursts can omit the folder-relative general level, shifting later fields by one. OpusAssistant includes compatibility parsing for that form. The remaining button-state, write-permission, and subscription fields depend on the emitting firmware’s layout. Decode that tail using the matching version’s contract; the prefix table does not define universal offsets for the later fields.

Record/playback elapsed-time messages can arrive separately, such as Opus Recording M:SS or Opus Playing M:SS; OpusAssistant also recognizes Opus Playback. Status, elapsed-time, compile-progress, display-line, and command-acknowledgment messages can interleave. Route them by their actual prefix and controller IP.

Binary application pages

Application pages are opaque 512-byte blocks, numbered 1–9. They are not configuration source text, HTML pages, or a generic text command. Page ownership and its internal layout belong to the consuming application feature.

Read command:  Dev API_Page Rd 01
Read response: OK, Page 01<exactly 512 binary bytes>

A binary page write requires the exact header and block placement defined by the matched controller and application versions. The command name and page number alone do not define that layout. Preserve all 512 block bytes, including zero bytes, and use the binary-capable transport. Do not pass the block through a zero-terminated text routine or replace it with hexadecimal or Base64 text.

A successful read response has the eleven-byte prefix OK, Page 01 followed immediately by 512 raw bytes, for 523 payload bytes and length 02 0B hex. Parse this response as binary before trying text decoding. The write acknowledgment is OK; errors include Wr Fail, Rd Fail, and Invalid Page #. Read back a changed block and compare all 512 bytes when verifying an application-page write.

OpusAssistant transport responsibilities

The application project includes controller discovery, configuration editing and transfer, firmware tools, testing, tuning, touchscreen-layout work, MIDI tools, and engine-voicing interfaces. Availability depends on the application version, workspace access, connected hardware, and the receiving firmware’s supported features. A Raspberry Pi interface can implement the same particular controller contracts it needs; sharing Ethernet does not make the different protocols interchangeable.

Displays and OpusAssistant

Display setup follows the actual display hardware and desired presentation. The service terminal provides access to controller status and diagnostic views. The documented serial connection uses 921600 baud; the existing guide names TeraTerm on Windows and OpusAssistant on macOS. The Ethernet terminal uses Telnet on port 26. USB serial supports the documented XMODEM/YMODEM transfer paths; the Telnet session does not provide those transfers.

Keep application behavior distinct from controller behavior. A desktop or Raspberry Pi interface can present controls, status, or service functions, but the underlying meanings of stops, ranks, pistons, and outputs still come from the running controller and configuration. Replacing the screen does not change a stop’s physical wiring or make an unsupported controller command available.

For a graphic home-screen UserText slot, LDS.UpdateUserText supplies persistent text. The slot must be included in the home-screen layout. A status message remains until overwritten, so a conditional message should have a normal-state branch that writes an empty string. Otherwise a message such as “Tutti active” can remain after the condition has ended.

Retrieving, changing, and loading a configuration

The USB command-folder workflow uses the console controller’s USB-A thumb-drive connection. Use a FAT or FAT32 USB drive of 64 GB or less, and uppercase folder names, file names, and extensions. Preserve a copy of the running configuration before preparing a replacement.

• Create GET at the root of the drive. Insert it into the controller and wait until the activity LED beside the USB receptacle goes out. The running configuration is copied into GET.
• Edit the retrieved configuration or a clearly identified successor. Keep CRLF line endings, the required module structure, and the exact callable signatures for the target BaseOS.
• Prepare a root-level PUT folder containing exactly one intended configuration file. Keep the backup elsewhere so it cannot be confused with the replacement.
• Insert the drive and allow the compile operation to finish. PUT takes longer than GET; wait for the heartbeat to return to a blinking state.
• After a successful PUT operation, the configuration file is consumed from PUT and the instrument reboots into the new configuration. After a compile failure, the file remains and the drive receives a DUMP folder with a .LST listing. Read the end of the listing for the compiler’s stopping point.
• Retrieve the running configuration again when its identity is in doubt. A successful compile of an older file is still a successful compile; it does not prove the intended revision was loaded.

Interpret the PUT result after observing that the controller actually processed the drive. A file remaining on an unreadable or unprocessed drive does not by itself prove a compile was attempted. The controller display and terminal provide additional progress information. Record the loaded file, BaseOS, and verified behavior with the project’s backup.

Checking a configuration before it becomes a playing instrument

Use three kinds of verification: interface and structure checks, musical and wiring review, and observation on the actual hardware. They answer different questions. A compiler verifies that the program is accepted by its implementation. It does not know which pipe or shoe the installer connected to a terminal.

• Check the required section headers, matching module names, final period, CRLF endings, exact procedure names, parameter order, and argument counts.
• Check setup-before-use dependencies and the Process_Pistons → Record_Play → Init_Pipes order.
• Check every physical input against the wiring list and every logical state against its intended function.
• Check every rank’s real compass, base pitch, stop contributions, output sequence, and total number of consumed notes.
• Check coupler direction with an actual played-key example. For “Swell to Great,” playing a Great key must request the intended Swell note.
• Check every expression input and output independently. The shoe channel, logical box, and destination can each be wrong while the file still compiles.
• Check piston capture and recall, range boundaries, reversible behavior, sequence controls, and the clearing of notes and auxiliary outputs.
• Test representative first and last notes, card boundaries, stop releases, combination changes, and any required loss-of-communication behavior.

A wiring spreadsheet should be read with its row and column coordinates intact. A column may identify a board while a row offset identifies the pin. Confirm the offset with known anchors and check the far end of each run. Division names, voice names, visual jamb order, and general organ-building conventions are clues, not substitutes for verified assignments. Some installations use reversed drawknob columns or mixed divisions on one board; those are installation patterns, not universal Opus-Two rules.

Troubleshooting by following the signal

Establish the BaseOS and device firmware versions early. A known version-specific defect or an incompatible discovery format can explain behavior that appears to be a wiring or configuration problem. Match a proposed update to the actual hardware and symptom; preserve the running configuration and project data before changing the system.

Using this reference with an AI assistant

Give the assistant the controller model, BaseOS 82_35 baseline, current configuration, musical specification, and wiring information relevant to the task. For an existing system, include the working file rather than asking it to reconstruct the whole instrument from a stoplist. Tell it the intended change and the expected musical result.

Require the assistant to identify every assumption affecting sound or hardware: division identity, physical pin assignment, rank compass, expression channel, switching polarity, and digital routing. Missing facts should become specific questions. A plausible-looking configuration cannot resolve a missing wiring assignment.

A useful configuration explanation traces one complete path: physical key → raw keyboard → processed keying → stop condition → rank and pitch → physical or digital output. For a piston change, trace contact → piston number → range and stored contents → stop state → movement coils or software-button state.

When using a procedure from the catalogue, require an exact signature match. Do not invent an IMPORT, infer a function from a similarly named API command, treat similar GIO and P forms as interchangeable, or fill in undocumented parameter meanings from ordinary programming conventions. An interface declaration proves the callable name and types; it does not provide missing installation facts or unrecorded operational semantics.

Common configuration procedure reference

The following entries cover the principal operations used in the examples and typical configuration work. Signatures show parameter names and types. Parameter names preserve the callable interface, including historical spellings. Explanations specify the roles needed to use the routines correctly.

GIO.Opus_Cards_IO

GIO.Opus_Cards_IO ( num_a , num_b : INTEGER )

Runs the card I/O scan once per Main_Cycle pass. num_a and num_b are the numbers of cards on logical chains A and B; each chain exchanges both input and output data. Place the call after setup and before any mappings that consume the current card image.

GIO.Map_Keys

GIO.Map_Keys ( card , pin , manual , note , count : INTEGER )

Reads count consecutive key contacts beginning at card/pin and merges them into the destination raw keyboard buffer, beginning at note. Set the physical run, destination keyboard, first note, and count from the wiring list.

GIO.Map_Stops

GIO.Map_Stops ( card , pin , qty , stop : INTEGER )

Maps ‘qty’ consecutive stop-tab contacts, beginning at card/pin, to consecutive stop numbers beginning at ‘stop’.

GIO.Map_Pistons

GIO.Map_Pistons ( card , pin , qty , pstnadd : INTEGER )

Maps qty consecutive piston contacts beginning at card/pin to consecutive piston numbers beginning at pstnadd.

GIO.Set_Button

GIO.Set_Button ( card , pin : INTEGER )

Maps the console SET control to the specified card/pin contact.

GIO.Cancel_Button

GIO.Cancel_Button ( card , pin : INTEGER )

Maps the console CANCEL control to the specified card/pin contact.

GIO.Card_Invert

GIO.Card_Invert ( cardnum : INTEGER )

Inverts all 64 validated input bits for one active-low card. Pass a 1-based card number after GIO.Opus_Cards_IO. Unlike GIO.Invert_Byte, this call does not invert discarded or invalid scan data.

SPI_Per.Get_Manual

SPI_Per.Get_Manual ( port , k_adr , man , start , num : INTEGER )

Reads one Hall-effect manual or pedalboard over RS-485/RibFlex into its uncoupled key buffer. Multiple devices may share a port when they use distinct k_adr scan addresses. BaseOS 82 supports the destinations sw_uk, gr_uk, ch_uk, so_uk, and pd_uk.

SPI_Per.Read_Mini_In

SPI_Per.Read_Mini_In ( mux_port , addr , card_in : INTEGER )

Polls a Mini-In peripheral over a RibFlex port and deposits its scanned inputs at card_in in the normal input image. Subsequent input mappings use that destination. The addr argument includes the peripheral address and any applicable mode flags; select them from the specific device’s setup.

SPI_Per.Map_Enet_SC_Coils

SPI_Per.Map_Enet_SC_Coils ( last_octet , rbn , qty , stop_num , duty , fallback , end_duty : INTEGER )

Assigns a serial-coil group to another controller running Remote SC firmware. The console exchanges stop states and coil commands with that controller over Ethernet, while the remote controller performs all serial-coil communications for the group.

GIO.Stop

GIO.Stop ( stopper : INTEGER ) : BOOLEAN

Returns the on/off state of stop 'stopper' (reads BB stop space). The basic stop test used throughout couplers and conditions.

GIO.Button

GIO.Button ( k : INTEGER ) : BOOLEAN

Returns the current state of toggle button 'k' (from Button_State). Read a console button.

CA.Map_Group_Stops

CA.Map_Group_Stops ( stop_num , s_c , s_p , on_c , on_p , off_c , off_p , qty : INTEGER )

Maps consecutive stop-sense inputs beginning at sense_card/sense_pin. The ON and OFF coil locations form interleaved pairs, so each successive stop advances each coil address by two pins.

CA.Map_Stop_Groups

CA.Map_Stop_Groups ( stop_num , s_c , s_p , on_c , on_p , off_c , off_p , qty : INTEGER )

Maps consecutive stop senses and separate contiguous ON- and OFF-coil runs. Each of the three runs advances by one pin per stop; this is different from Map_Group_Stops, whose coil addresses advance by two.

CA.Map_Grouped_Stops

CA.Map_Grouped_Stops ( stop_num , s_c , s_p , on_c , on_p , off_c , off_p , qty : INTEGER )

Maps sense/ON/OFF triplets. Each successive stop advances the sense, ON-coil, and OFF-coil starting addresses by three positions. Thus sense/ON/OFF at pins 1/2/3 is followed by 4/5/6. A contiguous triplet run can cross a card boundary.

GIO.Map_Buttons

GIO.Map_Buttons ( card , pin , button : INTEGER )

Maps the physical contact at card/pin to a software button. For a button state that must participate in piston storage and recall, pair it with the appropriate CA.Map_Buttons_To_Stops mapping. Use the physical moving-stop mapping instead where a sense contact and movement coils are installed.

CA.Map_Buttons_To_Stops

CA.Map_Buttons_To_Stops ( start , qty , stop : INTEGER )

During normal operation, binds consecutive button bits to consecutive stop states. During a combination-action movement, it also mirrors recalled stop state back into the button state so piston recall and button indication remain synchronized.

CA.Set_Stop_Count

CA.Set_Stop_Count ( num : INTEGER )

Sets how many stop-state bits the combination action stores and processes and therefore how many bytes each piston record uses. It is a storage span, not necessarily the number of physical stop coils, and should be higher than the installed stop count when the configuration requires additional stored states. Maximum: 1600.

CA.Set_Max_Pistons

CA.Set_Max_Pistons ( value : INTEGER )

Sets the highest piston number available to the combination action. Use 1..350; values above 350 are ignored rather than clamped. This value determines stored layout and should not be changed casually on an established instrument.

CA.Set_Max_Mem_Level

CA.Set_Max_Mem_Level ( value : INTEGER )

Sets the maximum general memory level. Use a positive value; values above the controller's hardware-dependent limit are clamped to that limit.

CA.Process_Pistons

CA.Process_Pistons ()

Runs the combination-action piston, sequencer, storage, and coil-processing phases. Call it once per Main_Cycle pass immediately before O2S.Record_Play and GIO.Init_Pipes. For advanced user-mask editing, use the documented split Process_Pstns_1/Process_Pstns_2 pattern instead of this combined call.

O2S.Record_Play

O2S.Record_Play ()

Runs record/playback and the debounce processing required by controls. Call it every Main_Cycle pass between CA.Process_Pistons and GIO.Init_Pipes, including instruments that do not offer performance recording.

GIO.Init_Pipes

GIO.Init_Pipes ()

Clears and rebuilds raw/keyed working buffers, applies pedal divide and supported OSC/trap/predictive updates, and prepares the key buffers for the pipe section. It does not apply couplers; call coupler procedures afterward.

P.New_Rank

P.New_Rank ( rnk_num : INTEGER ; name : ARRAY OF CHAR ; pitch , trim : INTEGER ; is_unit : BOOLEAN )

Allocates and clears an accumulated rank. pitch is its base pitch; trim is the number of real notes/pipes in its compass; name is its display label; is_unit stores the P.Unit/P.Primary classification used by the surrounding system.

P.Define_Stop

P.Define_Stop ( stop1 , stop2 , logic , rnk_num , pitch , key , skip , run : INTEGER )

Adds a stop-controlled keying contribution to an accumulated rank. stop2 depends on logic: 10 uses a secondary-stop-off condition, 11 uses a secondary-stop-on condition, 12 adds OSC/iPad keying, and 99 forces the state on when stop2 is positive. For ordinary logic 10 with nonpositive stop2, the primary stop controls the contribution. skip=-1 selects full compass; otherwise skip and run are the first and final one-based notes.

P.Rank_Notes_Out

P.Rank_Notes_Out ( rnk_num , num_notes : INTEGER ; direction : BOOLEAN ; chambr , card , pin : INTEGER )

Outputs the next num_notes notes of an accumulated rank. Supply the same starting chamber/card/pin for P.Forward and P.Reverse. Forward places the notes in ascending output order; reverse reverses their order within the same output block. Do not pre-adjust the address to the high end. Successive calls consume successive rank notes.

P.Rank_Notes_Out2

P.Rank_Notes_Out2 ( rnk_num , num_notes : INTEGER ; direction : BOOLEAN ; chambr , card , pin : INTEGER )

With P.Forward, outputs each of the next num_notes rank notes to a pair of consecutive destinations, using 2 × num_notes output positions and consuming num_notes rank notes. The example in this reference uses chamber 1. Other direction and destination combinations require guidance for the installed version.

P.Set_Skips

P.Set_Skips ( sk1 , sk2 : INTEGER )

Sets the two per-side skip settings used by P.Rank_Notes_Dia_Skip. Set them before the output call. Match the numeric settings to the required chest layout and installed implementation.

P.Rank_Notes_Dia_Skip

P.Rank_Notes_Dia_Skip ( rnk_num , pairs : INTEGER ; style1 : BOOLEAN ; chambr1 , card1 , pin1 : INTEGER ; style2 : BOOLEAN ; chambr2 , card2 , pin2 : INTEGER )

Sends alternating rank notes to two diatonic sides, each with its own direction and chamber/card/pin assignment. pairs specifies the number of notes on each side; the call consumes 2 × pairs rank notes. Set the per-side skip settings first with P.Set_Skips. Each side supports P.Forward or P.Reverse.

GIO.Stp_Seg

GIO.Stp_Seg ( Stop_Num , pitch , key : INTEGER )

Adds one stop’s keying contribution to the current sequential rank. The first contribution after the preceding rank’s output begins a fresh shared rank; additional contributions merge into it. There is no rank-number argument. Keep the contributions, trim, and output calls for one sequential rank together.

GIO.Rank_Trim

GIO.Rank_Trim ( pitch , num_notes : INTEGER )

Sets the base pitch and real note compass of the current sequential rank. Place it after that rank’s GIO.Stp_Seg contributions and before its GIO.Ext_Rnk_Seg output calls.

GIO.Ext_Rnk_Seg

GIO.Ext_Rnk_Seg ( num_notes , chambr , card , pin : INTEGER )

Outputs the next contiguous segment of the current sequential rank. Additional calls output its following segments. After the output block, the next GIO.Stp_Seg starts a fresh rank. This form has no rank ID; the accumulated P.Rank_Notes_Out form has a separate rank-number argument.

P.Stop_Coupler

P.Stop_Coupler ( stop , source , dest , pitch : INTEGER )

Applies a coupler while stop is on. In this P wrapper, source is the sounded division's coupled _k buffer and dest is the played keyboard's uncoupled _uk buffer. Use the established _k/_k form for unison-off handling before other couplers.

GIO.Stp_Cplr

GIO.Stp_Cplr ( Stop_Num , dest , source , pitch : INTEGER )

When Stop_Num is on, merges source (the played/source key buffer) into dest (the sounded division buffer) at pitch. These dest/source meanings follow the GIO signature and are the reverse of the P.Stop_Coupler wrapper's semantic labels.

GIO.Dual_Stp_Cplr

GIO.Dual_Stp_Cplr ( Stop_Num , Stop_Num2 , dest , source , pitch : INTEGER )

When both Stop_Num and Stop_Num2 are on, merges source (the played/source key buffer) into dest (the sounded division buffer) at pitch.

GIO.Cnd_Stp_Cplr

GIO.Cnd_Stp_Cplr ( Stop_Num , Stop_Num2 , dest , source , pitch : INTEGER )

When Stop_Num is on and Stop_Num2 is off, merges source (the played/source key buffer) into dest (the sounded division buffer) at pitch.

GIO.Manual_Transfer

GIO.Manual_Transfer ( button : BOOLEAN ; man_1 , man_2 : INTEGER )

Transfer coupler: while ‘button’ is on, swaps the raw key input of manuals man_1 and man_2 so each keyboard plays the other’s division. Acts on the raw (_uk) manual keys - place it before Init_Pipes.

P.Sustain

P.Sustain ( man_num , id : BYTE ; trigger : BOOLEAN )

Holds every note played while trigger is TRUE, adding subsequent notes to the stored notes until trigger becomes FALSE. Acts on raw manual keying. Call every cycle after input mapping and before GIO.Init_Pipes, including cycles when the trigger is FALSE. Allocate a distinct id for each independent effect.

P.Legato

P.Legato ( man_num , id : BYTE ; trigger : BOOLEAN )

Captures the notes held when trigger engages and holds that chord until trigger becomes FALSE. Notes played afterward sound normally and are not added to the captured chord. Call every cycle on raw manual keying after input mapping and before GIO.Init_Pipes, including cycles when the trigger is FALSE. Allocate a distinct id for each independent effect.

P.Stop_Action

P.Stop_Action ( stop_num , ipad_num , chamber , card , pin : INTEGER )

Drives the configured action output whenever positive stop_num or positive ipad_num is active. The routine drives the output state; it does not toggle the stop itself.

CA.Reversable_tab

CA.Reversable_tab ( button : BOOLEAN ; stop_num : INTEGER )

Toggles the reversible tab when state is TRUE. The procedure does not debounce internally, so pass a debounced one-shot pulse rather than a held contact.

P.Pizz_Stp

P.Pizz_Stp ( rnk_num , timer_setter , lngth : INTEGER )

Starts a pizzicato pulse whose maximum duration is set in configuration-cycle counts. Early key release resets it immediately, so release can shorten the pulse.

P.Reit_Stp

P.Reit_Stp ( rnk_num , timer_set , speed : INTEGER )

Applies reiteration with timer_set 0..15. Timing values count routine/Main_Cycle invocations; speed must be greater than two to create a distinct off phase.

CA.Calc_ADC

CA.Calc_ADC ( num , stages : INTEGER ) : INTEGER

Reads ADC channel num, applies that channel's stored calibration and hysteresis, and returns 0..stages inclusive. stages must be greater than zero.

CA.Calc_External_ADC

CA.Calc_External_ADC ( num , value , min , max , stages : INTEGER ) : INTEGER

Scales the supplied value using min and max and quantizes it into 0..stages inclusive. num selects the shared hysteresis slot; stored physical-ADC calibration is not applied. stages must be positive.

CA.Get_Cresc_Sforz

CA.Get_Cresc_Sforz ( item : INTEGER ; VAR csdata : ARRAY OF BYTE )

Copies the active crescendo step (item 0) or the selected tutti (items 1–4) into a Stops_T destination. The firmware type is GIO.Stops_T, occupying 200 bytes for the 1600-stop baseline. The ARRAY OF BYTE signature accepts that buffer; use the full type rather than guessing a size from the instrument’s stop count.

GIO.Set_Expr

GIO.Set_Expr ( exprnum , value : INTEGER )

Sets expression box 1..32. The BYTE value may be 0..255, but normal configurations should use 0..127 so expression values map directly to MIDI output.

GIO.Expr

GIO.Expr ( exprnum : BYTE ) : BYTE

Returns the current value of expression box 1..31. Although setters accept box 32, BaseOS 82 returns zero for box 32 and for invalid indices. Values are BYTE; use 0..127 in normal configurations for MIDI compatibility.

P.Expr_Blades_Out

P.Expr_Blades_Out ( expr , stages , chamber , card , pin : INTEGER )

Drives stages consecutive expression-blade outputs progressively from a 0..127 expression value. stages must be greater than zero. Expression storage can hold 0..255, but this helper is designed around 127.

P.Expression_Gray_Code_32

P.Expression_Gray_Code_32 ( expr , chamber , card , pin : INTEGER )

Divides the expression value by four and sends five Gray-code bits. Use the normal 0..127 expression range; values above 127 wrap within the five output bits.

P.Expression_Gray_Code_64

P.Expression_Gray_Code_64 ( expr , chamber , card , pin : INTEGER )

Divides the expression value by two and sends six Gray-code bits. Use the normal 0..127 expression range; values above 127 wrap within the six output bits.

CA.Seq_Enable

CA.Seq_Enable ( button : BOOLEAN )

Enables the piston sequencer while button is TRUE. Group this setup with CA.Seq_Fires_From_GC and CA.Set_Last_General before the Next/Previous controls.

CA.Seq_Fires_From_GC

CA.Seq_Fires_From_GC ( button : BOOLEAN )

By default, NEXT has no effect while the console is in General Cancel. Pass TRUE to allow NEXT to advance from General Cancel to General 1.

CA.Set_Last_General

CA.Set_Last_General ( levels : INTEGER )

Sets the highest general piston number used by the sequencer and general-piston logic. The sequencer cycles through General 1 to this number.

CA.Seq_Next_CP

CA.Seq_Next_CP ( card , pin : INTEGER )

Sequencer step-NEXT driven directly from a debounced contact - a convenience form of Seq_Next that reads the pin itself (card, pin) instead of taking a boolean.

CA.Seq_Prev_CP

CA.Seq_Prev_CP ( card , pin : INTEGER )

Sequencer step-PREVIOUS driven directly from a debounced contact (card, pin).

P.Midi_Stop

P.Midi_Stop ( Stop_num , port , logic , pitch , ch , key , skip , run : INTEGER )

Sends raw-manual notes when logic is 1; otherwise sends keyed notes while the controlling stop is on and sends the required note releases when it turns off. The skip and run parameters are reserved; use -1 for each.

GIO.Midi_Expr_Out

GIO.Midi_Expr_Out ( port , ch , indx : INTEGER )

Reads the configured expression index and sends its value through the MIDI output path. This GIO wrapper takes an expression index, as does the separately exported Midi_IO.Expr_Out; the raw-value Midi_IO.Midi_Expr_Out routine is internal.

Midi_IO.Expr_Out

Midi_IO.Expr_Out ( port , ch , expr : INTEGER )

Reads logical expression box expr and transmits its value as MIDI expression on the selected port and channel. The expr argument is a box number, not a raw expression value.

WTC.Sysex_Stop

WTC.Sysex_Stop ( control_num , stop_num : INTEGER )

Binds a configured stop state to the specified Walker voice-control number in the prepared SysEx state. The Walker control number is the first argument and the Opus-Two stop number is second. Prepare the bindings before WTC.Send_Stops transmits the state.

WTC.Send_Stops

WTC.Send_Stops ( last_octet : BYTE )

Periodically transmits the stop image built by WTC.Sysex_Stop to the Walker digital engine at last_octet. It sends one of three groups on alternating passes and only transmits a group when its data changed.

WTC.Send_PC_Msg

WTC.Send_PC_Msg ( stop , ch , num , last_octet : BYTE )

Formats and sends a program-change message to the NanoW controller identified by last_octet, checking the state of the specified stop. ch uses channel numbers 1–16 and num uses program numbers 0–127. Pass these numbers directly; do not convert the channel to zero-based numbering or the program to one-based numbering.

WTC.Sysex_Welcome

WTC.Sysex_Welcome ()

Initializes the Walker digital-interface record. Call it once before any WTC.Sysex_Stop or WTC.Send_Stops calls, and place it in the module BEGIN section.

MCU.Put_Proj_Nickname

MCU.Put_Proj_Nickname ( proj , nick : ARRAY OF CHAR )

Stores the project name and controller nickname. Place this call in the config file's final module BEGIN section, not in Main_Cycle, so it runs once when the configuration starts.

Public keying and pitch constants

These entries reproduce the public constant names and declared expressions for BaseOS 82_35. A named alias has exactly its target’s value. Dotted P names are the configuration-facing forms. Values are interface definitions; hardware capacity still depends on the relevant controller, receiver, and transport.

Complete public configuration interface catalogue

This catalogue lists the 493 public configuration procedures for BaseOS 82_35, with their exact declared signatures. It is an interface index: a signature alone does not establish operational ranges, physical wiring, timing, side effects, or an appropriate use. Procedures without a usage explanation here require the matching detailed procedure guidance before use.

INTEGER and BYTE arguments retain their individual documented numbering conventions. VAR marks an argument passed by reference. ARRAY OF CHAR usually denotes text. A result type after the closing parenthesis indicates a function result; signatures without a result type are procedures. Keep names, spelling, module prefixes, and argument order exactly as declared.

ADC callable interfaces

ADC.Fetch_ADC ( item : INTEGER ) : INTEGER

ADC.Put_Mini_In_Sensor_Dat ( ch , dat : INTEGER )

CA callable interfaces

CA.Activate_User_Mask ( state : BOOLEAN )

CA.Byte_Playback_Recall_CA ( sel_num : BYTE ; VAR _value : BYTE )

CA.Byte_Save_CA ( sel_num : BYTE ; VAR _value : BYTE ; set_button : BOOLEAN ; min1 , max1 , min2 , max2 : INTEGER )

CA.CA_Format_Change ( max_pistons , max_level : INTEGER )

CA.Calc_ADC ( num , stages : INTEGER ) : INTEGER

CA.Calc_External_ADC ( num , value , min , max , stages : INTEGER ) : INTEGER

CA.Change_Cresc_Blk ( chg : INTEGER )

CA.Check_For_Recent_Skip () : BOOLEAN

CA.Chg_LMem_Level ( dir : BOOLEAN )

CA.Chg_Mem_Level ( dir : BOOLEAN )

CA.Chg_Organist ( direction : BOOLEAN )

CA.Clear_All_Folder_Names ()

CA.Clear_Cresc_Blocks ()

CA.Clear_Cresc_Data ()

CA.Clear_Folder_Name ( folder : INTEGER )

CA.Clear_Sforz_Data ()

CA.Clr_Comb_Setting ()

CA.clr_lvl_clear_table ()

CA.Coil_Tmr ( stop_num : INTEGER ) : BYTE

CA.coilmap ( In1i , In2i , In3i , In4i : INTEGER ) : BYTE

CA.coilmap8 ( In1i , In2i , In3i , In4i , In5i , In6i , In7i , In8i : INTEGER ) : BYTE

CA.Copy_Cresc_Data ( s_number , d_number : INTEGER )

CA.Copy_Piston_and_Mask ( s_level , s_pnum , d_level , d_pnum : INTEGER )

CA.Cresc_Level_Change ( up , dn : BOOLEAN )

CA.Dec_Cresc_Step ()

CA.Dec_Folder ( trig : BOOLEAN )

CA.Dec_Local_Mem_Level ( trig : BOOLEAN )

CA.Dec_Mem_Level ( trig : BOOLEAN )

CA.Dec_Organist ()

CA.Dec_Track ( trig : BOOLEAN )

CA.Dec_Transposer ( trig : BOOLEAN )

CA.Delete_Piston ( trig : BOOLEAN )

CA.Direct_Access_General ( card , pin , lvl , pstn : INTEGER ; cx_allow : BOOLEAN )

CA.Direct_Access_Piston ( card , pin , lvl , pstn : INTEGER )

CA.Display_Last_General ( state : BOOLEAN )

CA.EC_Reversable ( button : BOOLEAN ; stop_num , stop_2 , stop_3 , stop_4 : INTEGER )

CA.EC_Reversable_Btns ( button : BOOLEAN ; stop_num , stop_2 , stop_3 , stop_4 : INTEGER )

CA.Enable_Remote_CA ()

CA.Enable_Undo ( state : BOOLEAN ; depth : INTEGER )

CA.fetch_con_cfg_byte ( bytenum : INTEGER ) : BYTE

CA.Fetch_Organist () : INTEGER

CA.Fetch_Res_Mem_Level () : INTEGER

CA.Fetch_Stop_Name ( num : INTEGER ; VAR t_name : ARRAY OF CHAR )

CA.Fetch_UserVar ( index : INTEGER ) : BYTE

CA.Flag_Prog_Rev ( trig : BOOLEAN )

CA.Force_Cresc_Number ( value : INTEGER )

CA.force_track_info ( base , siz : INTEGER )

CA.Get_Address ( level , pnum : INTEGER ) : INTEGER

CA.Get_Cresc_Sforz ( item : INTEGER ; VAR csdata : ARRAY OF BYTE )

CA.Get_Folder_Name ( folder : INTEGER ; VAR f_name : ARRAY OF CHAR )

CA.get_last_general_pressed () : INTEGER

CA.get_mem_level () : INTEGER

CA.Get_Sforz_Address ( level : INTEGER ) : INTEGER

CA.Get_uSD_Address ( level , pnum : INTEGER ) : INTEGER

CA.Goto_Folder ( button : BOOLEAN )

CA.Goto_Level ( button : BOOLEAN )

CA.Goto_Root_Level ()

CA.Goto_Root_LLevel ()

CA.Goto_Track ( button : BOOLEAN )

CA.Inc_Cresc_Step ()

CA.Inc_Dec_Cresc_Step ( dir : BOOLEAN )

CA.Inc_Dec_Folder ( trig , dir : BOOLEAN )

CA.Inc_Dec_Local_Mem_Level ( trig , dir : BOOLEAN )

CA.Inc_Dec_Mem_Level ( trig , dir : BOOLEAN )

CA.Inc_Dec_Organist ( dir : BOOLEAN )

CA.Inc_Dec_Track ( trig , dir : BOOLEAN )

CA.Inc_Dec_Transposer ( trig , dir : BOOLEAN )

CA.Inc_Folder ( trig : BOOLEAN )

CA.Inc_Local_Mem_Level ( trig : BOOLEAN )

CA.Inc_Mem_Level ( trig : BOOLEAN )

CA.Inc_Organist ()

CA.inc_pstn_activity_counts ( sav , msk : BOOLEAN )

CA.Inc_Track ( trig : BOOLEAN )

CA.Inc_Transposer ( trig : BOOLEAN )

CA.Init_Level_Lock ( state : BOOLEAN )

CA.Insert_Function ()

CA.Insert_Piston ( trig : BOOLEAN )

CA.last_piston_pressed () : INTEGER

CA.Level_Clear ( lvl : INTEGER )

CA.Level_Lock ( mem_lvl : INTEGER ) : BOOLEAN

CA.Level_Lock_Btn ( card , pin : INTEGER )

CA.Link_Sforz_Cresc ( b : BOOLEAN )

CA.Local_Level_Enable ( state : BOOLEAN )

CA.Local_Level_Lock ( mem_lvl : INTEGER ) : BOOLEAN

CA.Map_Buttons_To_Stops ( start , qty , stop : INTEGER )

CA.Map_Coil_Stops ( stop_num , on_c , on_p , off_c , off_p , qty : INTEGER )

CA.Map_Coil_Stops_Rev ( stop_num , on_c , on_p , off_c , off_p , qty : INTEGER )

CA.Map_Group_Stops ( stop_num , s_c , s_p , on_c , on_p , off_c , off_p , qty : INTEGER )

CA.Map_Grouped_Stops ( stop_num , s_c , s_p , on_c , on_p , off_c , off_p , qty : INTEGER )

CA.Map_Insertable_Gen ( shift : BOOLEAN ; card , pin , qty , pstnadd : INTEGER )

CA.Map_Off_Coil_Group ( stop_num , card , pin , qty : INTEGER )

CA.Map_Off_Coil_Rev ( stop_num , card , pin , qty : INTEGER )

CA.Map_On_Coil_Group ( stop_num , card , pin , qty : INTEGER )

CA.Map_Quad_Grouped_Stops ( stop_num , s_c , s_p , on_c , on_p , off_c , off_p , qty , stp_cmn_c , stp_cmn_p : INTEGER )

CA.Map_Single_Stop ( stop_num , s_c , s_p , on_c , on_p , off_c , off_p : INTEGER )

CA.Map_Stop_Groups ( stop_num , s_c , s_p , on_c , on_p , off_c , off_p , qty : INTEGER )

CA.Midi_Select_Save_CA ( sel_num : BYTE ; set_button : BOOLEAN ; min1 , max1 , min2 , max2 : INTEGER )

CA.Nxt_Byte ( byte_num : INTEGER ) : BYTE

CA.Nxt_Stop ( stopper : INTEGER ) : BOOLEAN

CA.Off_Coil ( stop_num : INTEGER ) : BOOLEAN

CA.On_Coil ( stop_num : INTEGER ) : BOOLEAN

CA.OSC_CA_Get ( piston : INTEGER ; VAR data : ARRAY OF BYTE )

CA.OSC_CA_Put ( piston : INTEGER ; data : ARRAY OF BYTE )

CA.Pause_Change ()

CA.Pgm_Reversable_Piston ( button : BOOLEAN )

CA.Piston_Blank_Check ( level , piston : INTEGER ) : BOOLEAN

CA.Piston_Clear ( lvl , pstn : INTEGER )

CA.Piston_Lamp ( pstn_num , qty , card , pin : INTEGER )

CA.Playing_Change ()

CA.Process_Pistons ()

CA.Process_Pstns_1 ()

CA.Process_Pstns_2 ()

CA.Quick_Folder ( btn : BOOLEAN )

CA.Quick_Level ()

CA.Quick_Set_Mem_Level ( pnum : INTEGER )

CA.Quick_Track ()

CA.recalc_uSD_settings ()

CA.Recall_Cresc ( cx_number , step : INTEGER )

CA.Recall_Mask ( level , _pnum : INTEGER ; VAR _pmask : ARRAY OF BYTE )

CA.Recall_Piston ( level , _pnum : INTEGER ; VAR _pdata : ARRAY OF BYTE )

CA.Recall_Piston_And_Mask_Smart ( level , pnum : INTEGER ; VAR pdata , pmask : ARRAY OF BYTE )

CA.Recording_Change ()

CA.Reset_Mem_Level ()

CA.Reversable_tab ( button : BOOLEAN ; stop_num : INTEGER )

CA.Save_Mask ( level , _pnum : INTEGER ; _pdata : ARRAY OF BYTE )

CA.Save_Misc_CA_Midi ()

CA.Save_Piston ( level , pnum : INTEGER ; _pdata : ARRAY OF BYTE )

CA.Seed_User_Mask ( indx : INTEGER )

CA.Seq_Enable ( button : BOOLEAN )

CA.Seq_FF_Bit ( bit_in : INTEGER )

CA.Seq_FF_Mode ( state : BOOLEAN )

CA.Seq_Fires_From_GC ( button : BOOLEAN )

CA.Seq_Insert_Piston ( trig : BOOLEAN )

CA.Seq_Next ( button : BOOLEAN )

CA.Seq_Next_CP ( card , pin : INTEGER )

CA.Seq_Next_Range ( arm : BOOLEAN ; start , finish : INTEGER )

CA.Seq_Prev ( button : BOOLEAN )

CA.Seq_Prev_CP ( card , pin : INTEGER )

CA.Seq_Prev_Range ( start , finish : INTEGER )

CA.Set_Coil_Time ( num : INTEGER )

CA.set_con_cfg_byte ( bytenum , j : INTEGER )

CA.Set_Cresc_Enabled ( bit : BOOLEAN )

CA.Set_Cresc_State ( cx_number , step : INTEGER ; src : ARRAY OF BYTE )

CA.Set_Cresc_Step ( level , _step : INTEGER )

CA.Set_enable_level_lock ( state : BOOLEAN )

CA.Set_Folder_Name ( folder : INTEGER ; f_name : ARRAY OF CHAR )

CA.Set_Last_General ( levels : INTEGER )

CA.Set_LDS_Cresc_Step ( step : INTEGER )

CA.Set_Legacy_Track_Format ( s : BOOLEAN )

CA.Set_Level_Lock ( mem_lvl : INTEGER ; _state : BOOLEAN )

CA.Set_Levels_Per_Folder ( levels : INTEGER )

CA.Set_LLvll_Lock ( mem_lvl : INTEGER ; _state : BOOLEAN )

CA.Set_LMem_Level ( lvl : INTEGER )

CA.Set_Local_Mask_Disable ( state : BOOLEAN )

CA.Set_Max_Cresc_Stages ( input : INTEGER )

CA.Set_Max_Mem_Level ( value : INTEGER )

CA.Set_Max_Pistons ( value : INTEGER )

CA.Set_Max_Track ( value : INTEGER )

CA.Set_Mem_Level ( lvl : INTEGER )

CA.Set_Organist ( num : INTEGER )

CA.set_record_pause_option ( b : BOOLEAN )

CA.Set_Seq_Num_Inserts ( j : INTEGER )

CA.Set_Sforz_Status ( num : INTEGER ; state : BOOLEAN )

CA.Set_Stop_Count ( num : INTEGER )

CA.Set_Tab_New_State ( stop : INTEGER ; state : BOOLEAN )

CA.Set_Track ( value : INTEGER )

CA.set_use_last_level ( b : BOOLEAN )

CA.Set_UserVar ( index : INTEGER ; value : BYTE )

CA.Show_Cresc_Step ( cresc_block , _cresc_step : INTEGER )

CA.Show_On_Tab_Rail ( button : BOOLEAN ; _stops_in : ARRAY OF BYTE )

CA.Show_Playback_On_Tab_Rail ( button : BOOLEAN ; _stops_in : ARRAY OF BYTE )

CA.Show_Sforz_Data ( sforz_step : INTEGER )

CA.Submit_Terminal_Request ( act , src , dst , rng , lvl , pnum : INTEGER )

CA.test_local_option ( bitnum : INTEGER ) : BOOLEAN

CA.Tgl_Level_Lock ()

CA.Tgl_LLvl_Btn ( card , pin : INTEGER )

CA.Tgl_LLvl_Lock ()

CA.toggle_local_option ( bitnum : INTEGER )

CA.Toggle_Piston_Stop ( level , piston , stop : INTEGER )

CA.Toggle_RP_Enable ()

CA.Transposer_Adjust ( direction : BOOLEAN )

CA.Transposer_Assign ( value : INTEGER )

CA.transposer_Neutral ()

CA.Undo_Button ( state : BOOLEAN )

CA.Universal_Clear ( lvl : INTEGER ; Piston , Mask : BOOLEAN )

CA.Universal_Level_Copy ( s_lvl , d_lvl : INTEGER ; Piston , Mask : BOOLEAN )

CA.Universal_Lock_Btn ( card , pin : INTEGER )

CA.Update_Building_Name ( data : ARRAY OF CHAR )

CA.uSD_get ( loc : INTEGER ; VAR buffer : ARRAY OF BYTE )

CA.uSD_put ( loc : INTEGER ; buffer : ARRAY OF BYTE )

Convert callable interfaces

Convert.IntToHex ( n : INTEGER ; VAR s : ARRAY OF CHAR )

Convert.IntToStr ( n : INTEGER ; VAR s : ARRAY OF CHAR )

Convert.StrToInt ( str : ARRAY OF CHAR ; VAR n , result : INTEGER )

Enet callable interfaces

Enet.Nano_Return_To_Cards ( last_octet , chmbr , card_num , num_cards : INTEGER ) : BOOLEAN

Enet.send_midi_out_msg ( midi_port , option : BYTE ; last_octet : INTEGER ; msg_in : ARRAY OF BYTE ; lngth : INTEGER )

Enet.set_return_resp_tmo ( tmo : INTEGER )

Enet.SSDP_Msg ( unique : ARRAY OF CHAR ; bye : BOOLEAN )

GIO callable interfaces

GIO.Auto_Bass ( local_ap : BOOLEAN ; ab_num , k_lim , src : INTEGER )

GIO.Auto_Bass_nr ( local_ap : BOOLEAN ; ab_num , k_lim , src : INTEGER )

GIO.BT_Repeat ( bot_rpt , top_rpt : INTEGER )

GIO.Button ( k : INTEGER ) : BOOLEAN

GIO.Button1 ( k : INTEGER ) : BOOLEAN

GIO.byte_to_bits ( cond : BYTE ; VAR a , b , c , d , e , f , g , h : BOOLEAN )

GIO.Cancel_Button ( card , pin : INTEGER )

GIO.Cancel_Flag ( state : BOOLEAN )

GIO.Card_Invert ( cardnum : INTEGER )

GIO.Clear_Card_In_Bit ( card , pin : INTEGER )

GIO.Clear_O2_Blk_Record ( cards : BOOLEAN )

GIO.Clr_bit ( VAR dst : ARRAY OF BYTE ; _indx : INTEGER )

GIO.Clr_Buf ( _dst : ARRAY OF BYTE )

GIO.Clr_Chamber ()

GIO.Cnd_Stp_Cplr ( Stop_Num , Stop_Num2 , dest , source , pitch : INTEGER )

GIO.Cnd_Stp_Seg ( Stop_Num1 , Stop_Num2 , pitch , key : INTEGER )

GIO.Copy_Bytes_ofst ( src , dest : ARRAY OF BYTE ; count , s_off , d_off : INTEGER )

GIO.Copy_Bytes_To_Card_In ( cardindex : INTEGER ; source : ARRAY OF BYTE ; sourceindex , count : INTEGER )

GIO.count_bits ( b : BYTE ) : BYTE

GIO.CP ( card , pin : INTEGER ) : BOOLEAN

GIO.CP_Count ( card , pin , count : INTEGER ) : INTEGER

GIO.CP_On ( _indx : INTEGER )

GIO.CP_Range_Tst ( card , pin , count : INTEGER ) : BOOLEAN

GIO.DB_CP ( card , pin : INTEGER ) : BOOLEAN

GIO.Delay ( _delay : INTEGER )

GIO.DMA_Block_q ( _port , _ctrl : BYTE ; ofst , _nbytes , speed : INTEGER ; data : ARRAY OF BYTE )

GIO.DMA_Chamber_Block_q ( _port , _ctrl : BYTE ; _ch , _nbytes , speed : INTEGER )

GIO.Dual_Stp_Cplr ( Stop_Num , Stop_Num2 , dest , source , pitch : INTEGER )

GIO.Dual_Stp_Seg ( Stop_Num1 , Stop_Num2 , pitch , key : INTEGER )

GIO.Expr ( exprnum : BYTE ) : BYTE

GIO.Expr_Merge ( exprcplstop : BOOLEAN ; exprcplsource , exprcpldesti : BYTE )

GIO.Expression_Roller ( card , pin , number : INTEGER ) : INTEGER

GIO.Ext_Dbl_Rnk_Seg ( num_notes , chambr , card , pin : INTEGER )

GIO.Ext_Gray_Code_Out ( byte_in , chambr , card , start_pin , num_bits : INTEGER )

GIO.Ext_Rnk_Seg ( num_notes , chambr , card , pin : INTEGER )

GIO.Ext_Stp_Ctrl ( condition : BOOLEAN ; chambr , card , pin : INTEGER )

GIO.Find_low_bit ( _dat : ARRAY OF BYTE ) : INTEGER

GIO.Fluid_Melody_Coupler_1 ( local_am : BOOLEAN ; fmc_num , adjust : INTEGER ; src_man , dst_man : BYTE )

GIO.Fmt_7_seg ( value : BYTE ) : BYTE

GIO.Force_Button ( btn : INTEGER )

GIO.Force_PD_Point ( point : INTEGER )

GIO.Force_Piston ( num : INTEGER )

GIO.Force_Piston_Off ( num : INTEGER )

GIO.Force_Set_Button ()

GIO.Get_Chamber_Byte ( chambr1 , index : INTEGER ) : BYTE

GIO.Gray_Code_In ( num : INTEGER ) : INTEGER

GIO.Inc_Limit ( VAR item : INTEGER ; limit : INTEGER )

GIO.init_key_buf ( u_k , k : INTEGER )

GIO.Init_Pipes ()

GIO.Inline_Auto_Mel ( local_am : BOOLEAN ; k_lim , count : INTEGER ; src_man , dst_man : BYTE )

GIO.Inline_Auto_Melody_Dum ( local_am : BOOLEAN ; k_lim , count , adjust : INTEGER ; src_man , dst_man : BYTE )

GIO.Invert_Byte ( j , chambr1 : INTEGER )

GIO.Limit_Num_Notes ( num_notes : INTEGER )

GIO.Low_Piston_Tst () : INTEGER

GIO.Manual_Transfer ( button : BOOLEAN ; man_1 , man_2 : INTEGER )

GIO.Map_Buf_Keys ( buff : ARRAY OF BYTE ; start , manual , dst , qty : INTEGER )

GIO.Map_Buf_Stops ( buff : ARRAY OF BYTE ; start , qty , stop : INTEGER )

GIO.Map_Buttons ( card , pin , button : INTEGER )

GIO.Map_Buttons_Alt ( card , pin , button , num : INTEGER )

GIO.Map_Buttons_Inc ( card , pin , button , num : INTEGER )

GIO.Map_Keys ( card , pin , manual , note , count : INTEGER )

GIO.Map_Keys_Dia ( card1 , pin1 , card2 , pin2 , manual , note , pairs : INTEGER )

GIO.Map_Keys_Rev ( card , pin , manual , note , count : INTEGER )

GIO.Map_Midi_Keys ( port , ch , mstart , man , start , num : INTEGER )

GIO.Map_Midi_Stops ( port , ch , mstart , num , start : INTEGER )

GIO.Map_Pistons ( card , pin , qty , pstnadd : INTEGER )

GIO.Map_Pistons_Rev ( card , pin , qty , pstnadd : INTEGER )

GIO.Map_Stop ( card , pin , _indx : INTEGER )

GIO.Map_Stops ( card , pin , qty , stop : INTEGER )

GIO.Melody_State_Cplr ( state : BOOLEAN ; adjust : INTEGER ; dest , source : BYTE )

GIO.Melody_Stp_Cplr ( Stop_Num , adjust : INTEGER ; dest , source : BYTE )

GIO.Merge_Byte_Buf ( src , dst : ARRAY OF BYTE )

GIO.Merge_Chamber_Byte ( b : BYTE ; chambr1 , index : INTEGER )

GIO.Merge_Stop ( _num : INTEGER ; state : BOOLEAN )

GIO.Midi_Expr_In ( port , ch : INTEGER ) : BYTE

GIO.Midi_Expr_Out ( port , ch , indx : INTEGER )

GIO.Midi_Keys_Out ( manual , port , ch , start , num : INTEGER )

GIO.Midi_Stops_Out ( port , ch , start , num : INTEGER )

GIO.Mixture_Notes_Out ( chambr1 , card , pin1 , pin2 , pin3 , pin4 , pin5 , pin6 , pin7 : INTEGER )

GIO.Note_Out_4 ( chambr1 , card1 , pin1 , card2 , pin2 , card3 , pin3 , card4 , pin4 : INTEGER )

GIO.Note_Swap ( ch1 , c1 , p1 , ch2 , c2 , p2 : INTEGER )

GIO.Opus_Cards_IO ( num_a , num_b : INTEGER )

GIO.Opus_Cards_out ()

GIO.Out_Buttons ( card , pin , button : INTEGER )

GIO.Out_Buttons_Alt ( card , pin , button , num : INTEGER )

GIO.Out_Buttons_Inc ( card , pin , button , num : INTEGER )

GIO.Pad_msg ( _del : INTEGER )

GIO.Pedal_Divide ( pedal_divide : BOOLEAN )

GIO.Pizz_Stp ( timer_setter , lngth : INTEGER )

GIO.Pizz_Stp_Prd ( timer_setter , lngth : INTEGER )

GIO.Range_Button ( card , pin : INTEGER )

GIO.Rank_Trim ( pitch , num_notes : INTEGER )

GIO.Reit_Stp ( timer_set , speed : INTEGER )

GIO.Reit_Stp_Pitch ( timer_set , speed , pitch : INTEGER )

GIO.Rev_Rnk_Seg ( num_notes , chambr , card , pin : INTEGER )

GIO.Reverse_Byte ( b , chambr1 : INTEGER )

GIO.Reverse_Pairs ( b : BYTE ; chambr1 : INTEGER )

GIO.Send_Chamber_Block ( _port , _ctrl : BYTE ; _ch , _nbytes : INTEGER )

GIO.Set_bit ( VAR dst : ARRAY OF BYTE ; _indx : INTEGER )

GIO.Set_Button ( card , pin : INTEGER )

GIO.Set_Chamber_Byte ( b : BYTE ; chambr1 , index : INTEGER )

GIO.Set_Cmd_To_Keyscan ( cmd : INTEGER )

GIO.Set_Expr ( exprnum , value : INTEGER )

GIO.Set_Expr_F ( exprnum , value : INTEGER )

GIO.Set_Expr_Merge ( exprnum , value1 , value2 : INTEGER )

GIO.Set_Ext_Stp_Ctrl_Pins ( condition : BOOLEAN ; chambr , card , pin , numbr : INTEGER )

GIO.Set_Legacy_Cards ( _in , _out : BOOLEAN )

GIO.Set_Link_Speed ( speed : INTEGER )

GIO.Set_Long_Cable ( _state : BOOLEAN )

GIO.Set_Midi_Expr ( port , ch , value : INTEGER )

GIO.Set_Midi_Selects ( num , voice_ , cc_ , pitch_ , shoe_ , min_ , max_ : INTEGER )

GIO.Set_Midi_Stop ( _num : INTEGER ; state : BOOLEAN )

GIO.Set_Predictive_Stops ( _state : BOOLEAN )

GIO.Set_Rem_Midi_Expr ( chmbr , chan : INTEGER ; value : BYTE )

GIO.Set_Single_Note ( _man , _note : INTEGER ; _state : BOOLEAN )

GIO.Set_Stop ( _num : INTEGER ; state : BOOLEAN )

GIO.Set_Stop_Byte ( _num : INTEGER ; _value : BYTE )

GIO.State_Buttons ( state : BOOLEAN ; button : INTEGER )

GIO.State_Cplr ( State : BOOLEAN ; dest , source , pitch : INTEGER )

GIO.State_Seg ( state : BOOLEAN ; pitch , key : INTEGER )

GIO.State_Seg_l ( state : BOOLEAN ; pitch , key , skip , run : INTEGER )

GIO.State_Seg_Midi ( Stop : BOOLEAN ; pitch , port , ch : INTEGER )

GIO.Stop ( stopper : INTEGER ) : BOOLEAN

GIO.StopsByte ( a , b , c , d , e , f , g , h : INTEGER ) : BYTE

GIO.Store_bit ( VAR dst : ARRAY OF BYTE ; _indx : INTEGER ; b : BOOLEAN )

GIO.Stp_Cplr ( Stop_Num , dest , source , pitch : INTEGER )

GIO.Stp_Seg ( Stop_Num , pitch , key : INTEGER )

GIO.Stp_Seg_l ( Stop_Num , pitch , key , skip , run : INTEGER )

GIO.Stp_Seg_Midi ( Stop_Num , pitch , port , ch : INTEGER )

GIO.Tgl_bit ( VAR dst : ARRAY OF BYTE ; _indx : INTEGER )

GIO.Tn2_Dbl_Seg ( pairs , chambr1 , card1 , pin1 , style1 , chambr2 , card2 , pin2 , style2 : INTEGER )

GIO.Tn2_Rnk_Seg ( pairs , chambr1 , card1 , pin1 , style1 , chambr2 , card2 , pin2 , style2 : INTEGER )

GIO.Toggle_Button ( k : INTEGER )

GIO.Trap ( n : INTEGER ) : BOOLEAN

GIO.Tst_bit ( dst : ARRAY OF BYTE ; _indx : INTEGER ) : BOOLEAN

GIO.Wipe_Pistons ()

LDS callable interfaces

LDS.Activate_Graphic_Home ( Col1 , Col2 , Col3 , Col4 , Name1 , Name2 : INTEGER )

LDS.BackerUD_To_Div ( trig : BOOLEAN )

LDS.Fill_Bars ( k , l , j , m : INTEGER )

LDS.inc_lds_screen ()

LDS.set_Gen_From_Zero ( b : BOOLEAN )

LDS.Set_Lx_Message ( line : INTEGER ; trig : BOOLEAN ; msg : ARRAY OF CHAR ; time : INTEGER )

LDS.UpdateUserText ( msg : ARRAY OF CHAR )

MCU callable interfaces

MCU.And ( a , b : INTEGER ) : INTEGER

MCU.BFI ( VAR word : INTEGER ; msb , lsb , bitfield : INTEGER )

MCU.Bits ( a : INTEGER ) : SET

MCU.Div ( a , b : INTEGER ) : INTEGER

MCU.Get_Brd_Info ( has_two_nand : BOOLEAN )

MCU.Mod ( a , b : INTEGER ) : INTEGER

MCU.Mul ( a , b : INTEGER ) : INTEGER

MCU.Nand ( a , b : INTEGER ) : INTEGER

MCU.Nor ( a , b : INTEGER ) : INTEGER

MCU.Not ( a : INTEGER ) : INTEGER

MCU.Or ( a , b : INTEGER ) : INTEGER

MCU.Ordb ( a : BOOLEAN ) : INTEGER

MCU.Ords ( a : SET ) : INTEGER

MCU.Put_Proj_Nickname ( proj , nick : ARRAY OF CHAR )

MCU.UBF ( word , msb , lsb : INTEGER ) : INTEGER

MCU.Xnor ( a , b : INTEGER ) : INTEGER

MCU.Xor ( a , b : INTEGER ) : INTEGER

Midi_IO callable interfaces

Midi_IO.All_Notes_Off ( port : INTEGER )

Midi_IO.Clr_Midi_Rx_Port ( port : INTEGER )

Midi_IO.Clr_mx_buff ( bufr : INTEGER )

Midi_IO.Clr_Sysx ()

Midi_IO.discard_unused_midi ( bufr : INTEGER )

Midi_IO.Expr_Out ( port , ch , expr : INTEGER )

Midi_IO.Get_midi_back_buf ( bufr : INTEGER ) : BYTE

Midi_IO.Manual_Out ( man , port , ch , start , notes : INTEGER )

Midi_IO.Midi_Bn_ctrl_decode ( bufr , mcmd_in , mopt_in : BYTE ; VAR ctrl_decode : BYTE )

Midi_IO.Midi_Bn_decode ( bufr , mcmd_in , mopt_in , mstop_in : BYTE ; stp_decode : INTEGER )

Midi_IO.Midi_Bn_gen_decode ( bufr , mcmd_in , ctrl_on , ctrl_off , mstop_in : BYTE ; stp_decode : INTEGER )

Midi_IO.midi_decode_work ( bufr : INTEGER ) : BOOLEAN

Midi_IO.Midi_NRPN_decode ( bufr , mcmd_in , mopt_in , mbnk_in , mindx_in , mbnk_s , mindx_s , stp_s : BYTE ; stp_decode : INTEGER )

Midi_IO.Midi_Out ( src : ARRAY OF BYTE ; port , ch , start , notes : INTEGER )

Midi_IO.Midi_PC_decode ( bufr : INTEGER ; mcmd_in , mopt_in : BYTE ) : BOOLEAN

Midi_IO.op_midi_byte ( bufr : INTEGER ) : BYTE

Midi_IO.op_midi_chr ( bufr : INTEGER ) : BYTE

Midi_IO.op_midi_chrs ( bufr : INTEGER ) : INTEGER

Midi_IO.op_midi_cmd ( bufr : INTEGER ) : BOOLEAN

Midi_IO.op_midi_in ( bufr : INTEGER ; _mcmd_in , _indx : BYTE ) : BOOLEAN

Midi_IO.op_midi_indx ( bufr , _indx : INTEGER ) : BYTE

Midi_IO.send_ipad_midi ( port : BYTE ; level , track : INTEGER ; force_update : BOOLEAN )

Midi_IO.Send_Midi_Msg ( port , ch , b1 , b2 : BYTE )

Midi_IO.Send_Midi_Msg_2byte ( port , ch , b1 : BYTE )

Midi_IO.Send_xMidi_Frame ( port , _ctrl : INTEGER )

Midi_IO.Set_Custom_Sysx_ID ( byte1 , byte2 , byte3 , byte4 , byte5 , custom_size : BYTE ; compand : BOOLEAN )

Midi_IO.set_did_midi_work ( bufr : INTEGER ; state : BOOLEAN )

Midi_IO.Set_Midi_Info ( ch , dat : INTEGER )

Midi_IO.Stops_Out ( port , ch , start , num : INTEGER )

Midi_IO.Store_Midi_Note ( port , chan , note : INTEGER ; b : BOOLEAN )

Nano callable interfaces

Nano.expr_merge ( indx , format , option : INTEGER )

Nano.init_cfg_msg ( cft_tbl , port , nmsg , speed : INTEGER )

Nano.Init_PWM_Settings ( pwm_tbl : INTEGER ; mx_on_time , mx_off_time , on_fb_time , off_fb_time , on_fb , off_fb : BYTE )

Nano.Init_PWM_Table ( pwm_tbl , port , nano_adr , speed , cards : INTEGER ; prd , duty , pulse : BYTE )

Nano.refresh_cfg_items ( interval : INTEGER )

Nano.Set_PWM_Pin_tmg ( pwm_tbl , card , pin , numbr : INTEGER ; prd , duty , pulse : BYTE )

Nano_Cfg callable interfaces

Nano_Cfg.expr_merge ( indx , format , option : INTEGER )

Nano_Cfg.init_cfg_msg ( cft_tbl , port , nmsg , speed : INTEGER )

Nano_Cfg.Init_PWM_Settings ( pwm_tbl : INTEGER ; mx_on_time , mx_off_time , on_fb_time , off_fb_time , on_fb , off_fb : BYTE )

Nano_Cfg.Init_PWM_Table ( pwm_tbl , port , nano_adr , speed , cards : INTEGER ; prd , duty , pulse : BYTE )

Nano_Cfg.refresh_cfg_items ( interval : INTEGER )

Nano_Cfg.Set_PWM_Pin_tmg ( pwm_tbl , card , pin , numbr : INTEGER ; prd , duty , pulse : BYTE )

O2S callable interfaces

O2S.Clr_Char_Buf ( VAR _dst : ARRAY OF CHAR )

O2S.Ethernet ()

O2S.Merge_Display_Button ( b : BOOLEAN ; s : INTEGER )

O2S.Or_Display_Button ( b : BOOLEAN ; s : INTEGER )

O2S.Prep_Input_Buffers ()

O2S.Record_Play ()

O2S.Send_Digit_Display_Frame ( port , ctrl , baud , nbytes : INTEGER )

O2S.Set_7_Seg_Digit_Data ( i , d : INTEGER )

O2S.Set_Digit_Data ( i , d : INTEGER )

O2S.set_display_port ( port : INTEGER )

O2S.Start_Cfg ( cycle_time : INTEGER )

O2S.Update_Digit_Brightness ( unit , digit , brightness : INTEGER )

OSC callable interfaces

OSC.Button ( indx : INTEGER ) : BOOLEAN

OSC.Button_Range ( min , max : INTEGER ) : BOOLEAN

OSC.Fetch_Fader ( a : INTEGER ) : INTEGER

OSC.Ipad_Expr ( num , range : INTEGER ) : INTEGER

OSC.Set_Burst_Mode ( b : BOOLEAN )

OSC.Set_Div_Label ( indx : INTEGER ; s : ARRAY OF CHAR )

OSC.Set_Expr_Label ( indx : INTEGER ; s : ARRAY OF CHAR )

OSC.Set_Label ( indx : INTEGER ; s : ARRAY OF CHAR )

OSC.Set_Tab_Label ( indx : INTEGER ; s : ARRAY OF CHAR )

OSC.Set_UserVar_Label ( indx : INTEGER ; s : ARRAY OF CHAR )

Out callable interfaces

Out.Hex ( d , w : INTEGER )

Out.Int ( d , w : INTEGER )

Out.Ln ()

Out.String ( s : ARRAY OF CHAR )

P callable interfaces

P.Alt_Rnk_Seg ( rnk_num , num_notes , chambr , card , pin , skip : INTEGER )

P.BT_Repeat ( rnk_num , bot_rpt , top_rpt : INTEGER )

P.Cumulative_Coupler ( stop_in , sub , unison , super , source , dest : INTEGER )

P.Define_Stop ( stop1 , stop2 , logic , rnk_num , pitch , key , skip , run : INTEGER )

P.Double_Stop_Coupler ( stop , stop2 , source , dest , pitch : INTEGER )

P.Expr_Blades_Out ( expr , stages , chamber , card , pin : INTEGER )

P.Expr_Blades_Rev ( expr , stages , chamber , card , pin : INTEGER )

P.Expression_Gray_Code_32 ( expr , chamber , card , pin : INTEGER )

P.Expression_Gray_Code_64 ( expr , chamber , card , pin : INTEGER )

P.Ext_Dbl_Rnk_Seg ( rnk_num , num_notes , chambr , card , pin : INTEGER )

P.find_low_bit_key ( man : INTEGER ) : INTEGER

P.Get_Byte ( index : INTEGER ) : BYTE

P.Get_Chmbr_Adr ( chambr1 : INTEGER ) : INTEGER

P.Get_Word ( index : INTEGER ) : INTEGER

P.iPad_Stop ( name : ARRAY OF CHAR ; stop1 , rnk_num , pitch , skip , run : INTEGER )

P.Legato ( man_num , id : BYTE ; trigger : BOOLEAN )

P.Limit_Num_Notes ( rnk_num , num_notes : INTEGER )

P.Midi_Stop ( Stop_num , port , logic , pitch , ch , key , skip , run : INTEGER )

P.Mixture_Notes_Out ( rnk_num , chambr1 , card , pin1 , pin2 , pin3 , pin4 , pin5 , pin6 , pin7 : INTEGER )

P.New_Rank ( rnk_num : INTEGER ; name : ARRAY OF CHAR ; pitch , trim : INTEGER ; is_unit : BOOLEAN )

P.Note_Out_4 ( rnk_num , chambr , card1 , pin1 , card2 , pin2 , card3 , pin3 , card4 , pin4 : INTEGER )

P.Offset_Stop ( stop_num , ipad_num , keying_k , start_note , qty , ch , crd , pin : INTEGER )

P.OSC_Stp_Grp ( stop1 , stop2 , rnk_num , pitch , skip , run : INTEGER )

P.Permanent_Coupler ( source , dest , pitch : INTEGER )

P.Pizz_Stp ( rnk_num , timer_setter , lngth : INTEGER )

P.Pizz_Stp_Prd ( rnk_num , timer_setter , lngth : INTEGER )

P.Put_Byte ( b : BYTE ; index : INTEGER )

P.Put_Word ( b , index : INTEGER )

P.Rank_Notes_Alt ( rnk_num , num_notes , skip , chambr , card , pin : INTEGER )

P.Rank_Notes_Dia ( rnk_num , pairs : INTEGER ; style1 : BOOLEAN ; chambr1 , card1 , pin1 : INTEGER ; style2 : BOOLEAN ; chambr2 , card2 , pin2 : INTEGER )

P.Rank_Notes_Dia_Skip ( rnk_num , pairs : INTEGER ; style1 : BOOLEAN ; chambr1 , card1 , pin1 : INTEGER ; style2 : BOOLEAN ; chambr2 , card2 , pin2 : INTEGER )

P.Rank_Notes_Out ( rnk_num , num_notes : INTEGER ; direction : BOOLEAN ; chambr , card , pin : INTEGER )

P.Rank_Notes_Out2 ( rnk_num , num_notes : INTEGER ; direction : BOOLEAN ; chambr , card , pin : INTEGER )

P.Rank_Notes_Out3 ( rnk_num , num_notes : INTEGER ; direction : BOOLEAN ; chambr , card , pin : INTEGER )

P.Rank_Notes_Out4 ( rnk_num , num_notes : INTEGER ; direction : BOOLEAN ; chambr , card , pin : INTEGER )

P.Reit_Stp ( rnk_num , timer_set , speed : INTEGER )

P.Reit_Stp_Pitch ( rnk_num , timer_set , speed , pitch : INTEGER )

P.Reit_StpF ( rnk_num , timer_set , speed : INTEGER )

P.Rev_Rnk_Seg ( rnk_num , num_notes , chambr , card , pin : INTEGER )

P.Set_Skips ( sk1 , sk2 : INTEGER )

P.SosteLegato ( man_num , id : BYTE ; trigger : BOOLEAN )

P.Stop_Action ( stop_num , ipad_num , chamber , card , pin : INTEGER )

P.Stop_Coupler ( stop , source , dest , pitch : INTEGER )

P.Sustain ( man_num , id : BYTE ; trigger : BOOLEAN )

P.Tn2_Dbl_Seg ( rnk_num , pairs , chambr1 , card1 , pin1 , style1 , chambr2 , card2 , pin2 , style2 : INTEGER )

SPI_Per callable interfaces

SPI_Per.Get_Manual ( port , k_adr , man , start , num : INTEGER )

SPI_Per.Get_Remote_ADC ( addr , ch : INTEGER ) : INTEGER

SPI_Per.Manual_Mux_Scan ( manual , spi_port , mx_port : INTEGER ; pol : BOOLEAN )

SPI_Per.Map_Enet_SC_Coils ( last_octet , rbn , qty , stop_num , duty , fallback , end_duty : INTEGER )

SPI_Per.Map_SC_Coil_Group ( port , stop_num , qty , group , option , tmo , freq , duty , fallback , end_duty : INTEGER )

SPI_Per.Plane_IO ( num , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 : INTEGER )

SPI_Per.Plane_Output_Info ( c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 : INTEGER )

SPI_Per.Process_2ndT_Manual ( man , dst_man , n_keys , offset : INTEGER )

SPI_Per.Read_Mini_In ( mux_port , addr , card_in : INTEGER )

SPI_Per.Read_PD_Analogs ( mux_port , num : INTEGER )

SPI_Per.Set_Key_Motion ( m : BOOLEAN )

SPI_Per.Set_Key_Order ( m : BOOLEAN )

SPI_Per.Set_Plane_Out ( col , pin : INTEGER )

Serial callable interfaces

Serial.init_AP ()

Signals callable interfaces

Signals.show_hz ( freq : REAL ; digits : INTEGER ; VAR w_string : ARRAY OF CHAR )

Strings callable interfaces

Strings.Append ( src : ARRAY OF CHAR ; VAR dest : ARRAY OF CHAR )

WTC callable interfaces

WTC.Midi_Speed ( speed : INTEGER )

WTC.Send_PC_Msg ( stop , ch , num , last_octet : BYTE )

WTC.Send_Stops ( last_octet : BYTE )

WTC.Sysex_Stop ( control_num , stop_num : INTEGER )

WTC.Sysex_Welcome ()

Documentation and revision scope

Configuration interfaces and constants in this edition are keyed to BaseOS 82_35. A later release, a different controller family, or an older working file may expose different behavior. Preserve the release identity when sharing an example or asking for help. Check the running controller’s version rather than assuming that the date of a web page identifies the installed firmware.

• Technician support and board-specific wiring guides
• Organist operation and display instructions
• Current product catalogue
• Opus-Two support contact