输出

Outputs#

MIDI#

One virtual source or a real destination. Add Messages; each has Type (Note gated / Note On / CC / Program Change), MIDI Channel, Note/CC #, and Value (a number, or a data key whose live value is used). Send: On Value Change (default) sends Note On / CC / Program Change when their value changes; On Trigger sends them all once each time the wired Trigger fires (or the cue it hangs off starts). Load Template fills the whole Messages list from a JSON file in Documents/TC Supply/TEMPLATE/MIDI (created on first use with a "DJM Mixer CC" example, faders/crossfader/master/EQ to CCs). A template is {"messages":[{"type","channel","number","value"},…]}; the popup snaps back after applying. Seeded templates are app-owned and refresh when a build ships an updated pack, rename the file to keep your own edits; files under other names are never touched.

OSC (the node is called OSC Out)#

Host/port/address + Arguments (add up to 16): each is a data key (suffix-matched) or a literal (3.5, true, hello), typed Auto / Float / Integer / String / Boolean, all sent in one message in slot order. A dotted key that isn't on the frame is skipped, not sent as 0. Send Mode: Continuous at a rate, On Change, or On Trigger (the message goes out once each time the wired Trigger fires or the cue it hangs off starts; with no arguments it is sent as the address alone). Smoothing (ms) glides Float arguments toward their target, deck values (pitch, BPM) only update every 64–200 ms as the players report, so receivers see steps; 150–300 ms here turns them into a continuous stream (Integer/String/Boolean arguments are never smoothed, so triggers stay crisp). Older single-value patches migrate into Argument 1 automatically. Load Template fills the address + Arguments (and host/port when the template carries them) from a JSON file in Documents/TC Supply/TEMPLATE/OSC, seeded with starter packs for Resolume Arena (port 7000: trigger-fired Clip/Column Connect, Next/Prev Column, Clear Layer/All, Tempo Tap, Beat Resync; continuous 0–1 Master Fader, Layer Opacity, Layer Master, Crossfader, Comp Speed), disguise/d3 (port 7401: trigger-fired Play, Play Section, Loop Section, Stop, Next/Prev Section, Return to Start, Next/Prev Track; continuous Cue, Volume, Brightness (plus disguise BPM, which takes the real BPM: bind beat.currentBpm raw) and grandMA3 (port 8000) match your console's OSC entry: Exec Button /Page1/Button201 follows a wired Trigger's press and release, Exec Fader /Page1/Fader201 0–100, Command /cmd sends a command-line string from value.out, e.g. a Script emitting "Go+ Sequence 1"). Trigger-fired commands bind trigger.active (the fire sends 1; Resolume/disguise ignore the release 0, MA3 Buttons use it as key-up); continuous params bind value.out, feed a scaling Script (output.value.out = source.parent.mixer.ch1.fader / 255). Host seeds as 127.0.0.1, retarget after loading when the server is another machine. Edit layer/clip/column/page/executor numbers in the address to taste. Templates are organised into family subfolders (TEMPLATE/OSC/Resolume/…); loading one always goes family first, then the command, the inspector's Load Template… button and the node's right-click menu → Load Template both open the same nested menu (Resolume / disguise / grandMA3 → commands, like the Add menus). Your own subfolders become families automatically. Works on the MIDI node too. A template is {"address","host"?,"port"?,"args":[{"value","type"},…]}, args can hold up to 16 entries, sent as one multi-argument message; the popup snaps back after applying. Seeded templates refresh on pack updates (rename to keep edits), like the MIDI ones.

Art-Net#

Net/Universe + Mappings (add up to 32): each maps a Value (a data key, or a 0–255 literal) to a DMX channel, all sent in one packet. Interface binding keeps DMX off the ProDJ Link NICs. Older single-field patches migrate into Mapping 1 automatically.

sACN (E1.31)#

The other lighting protocol, same Mappings model as Art-Net, but per-universe multicast (239.255.x.x:5568, or type a unicast IP in Target), plus sACN Priority (0–200, higher wins at the receiver) and a Source Name consoles display. Universe 1–63999.

UDP#

Generic glue: send a Text Template (BPM=${beat.currentBpm}\n, ${key} placeholders, suffix-matched, \n/\r become line endings) or a JSON Keys object (CSV key list) to any host:port, Continuous at a rate or On Change.

HTTP#

JSON server for browser overlays / stream graphics: GET http://<mac>:<port>/data.json returns the node's live frame (CORS open, so OBS browser sources can fetch it at any rate); optional CSV key filter; GET / serves a minimal live viewer page. Deleting, disabling or bypassing the node frees its port immediately.

CSV Logger#

Rows of chosen data keys to a timestamped .csv in Documents/TC Supply/LOG, the test/debug workhorse. Columns is a CSV of data keys (suffix-matched); every row starts with a wall-clock time column (HH:MM:SS.mmm). Write: On Change (default, a row only when a watched value changes) or Continuous at the Log Rate. Each enable/session/column-change starts a fresh name_YYYYMMDD-HHMMSS.csv (disabling or deleting the node closes the file cleanly). Node face shows the row count.

MSC#

MIDI Show Control cues to lighting/sound consoles: wire a Trigger in, each fire sends GO / STOP / RESUME / LOAD / FIRE / ALL_OFF / RESTORE / RESET (SysEx) for the chosen Target Type and Device ID (127 = all-call). Cue is a number or a data key (e.g. metadata.trackNumber = a cue per track); optional Cue List. Use a trigger Release Delay ≥ 60 ms so the 50 ms service never misses a fire. Load Template (inspector or right-click menu) fills Command / Target Type / Device ID / Cue / Cue List from Documents/TC Supply/TEMPLATE/MSC, seeded with grandMA2 and dot2 (Cue List = exec.page, e.g. 1.1, for the console's Exec.Page MSC mode; dot2 Main Only = no Cue List) and Chroma-Q Vista (cue + cuelist numbers, Device ID 0), GO, GO cue = track number, STOP (pause), RESUME. Your own {"command","format","device","cue","list"} files in subfolders become families.

MTC / LTC#

SMPTE timecode over MIDI / audio. MTC Output Mode: Virtual Source, MIDI Destination or ETC Gateway (UDP). The last sends running MTC out of an ETC Response MIDI Gateway's MIDI OUT socket: set Gateway IP and Gateway Port (the gateway's MIDI Out Source UDP Port in ETC Concert).

Unreal#

Live show data into Unreal Engine (virtual production) via the ShowKontrol plugin (UE 5.1+; runs in the editor without Play, in PIE and packaged). The plugin is the server (found automatically, UDP 47830 beacon; TCP 47831 data); the node is a client. Server = All Servers / one discovered server / Manual host+port; Send Rate (changes only are sent); Namespace prefixes every key; Only Keys = comma-separated fragments, only matching keys go (a script can set it live: output.child.gen.ue_keys = "value."). Four inputs (a frame or a whole Source bundle each: bundle decks arrive as deck<N>.…, a Device's frame as <Owner>.…, e.g. M.beatgrid.beatInBar) and one output From Unreal (talk-back: unreal.<name>, unreal.event.<name> + .count, unreal.lastEvent, unreal.connected, unreal.servers). In Unreal: Blueprint nodes ShowKontrol Number / Bool / Text (key (short keys allowed), Is Connected, Send …; a ShowKontrol Listener component; the ShowKontrol Flash actor (flashes on a key) latency tests); console ShowKontrol.Dump / .Status. Use the beatgrid.* keys for anything that must land on the beat (they follow the Source's Latency Compensation, like the cues). Node face: searching for Unreal… / connecting… / <server> · N keys.

Art-Net TC#

Timecode over Art-Net.

MIDI Clock#

24 PPQN beat clock (0xF8) paced by beat.currentBpm, deck tempo straight into synths, drum machines, DAWs. Send Start/Stop mirrors the deck transport (0xFA/0xFC); Clock When Stopped (default on) keeps ticking so gear holds tempo between plays. Virtual source or a real destination, like the MIDI node. Ticks are host-timestamp scheduled (MTC-grade jitter). Unwired, it idles at 120 BPM. Node face shows the live BPM.

TCNet#

One node that sends and receives TCNet (v3.6); Mode picks the role. Master (send): Wire a Source bundle into In, decks go out as layers 1–8 by device.number (Send to Localhost also reaches TCNet apps on this Mac). Client (receive): The master's layers come out of the Out pin as a device bundle, add a Device node to pick a layer (device.kind = tcnet). Auto: Stands by as a client and takes over when the master goes down. One machine talks to the players at a time: A machine that is not the master stays off the ProDJ Link network and follows the master; when it becomes master it connects to the players (a few seconds). Whoever took master stays master, a Master machine that comes back waits in standby. Bypass the TCNet node to put a machine straight on ProDJ Link. Discovered Devices shows each ShowKontrol as master / auto / standby / client. Other ShowKontrol machines get the master's complete deck data (waveforms, beat grid, artwork, cues, structure, and the DJM's faders and meters), so their screens look exactly like the master's; this needs ShowKontrol Network (Utility → Network, on by default), otherwise the node face says ShowKontrol Network off: timecode only. TCNet apps such as Resolume Arena also get beat grids, cues, waveforms, phrases, artwork and mixer data. Shared clock: All machines run on the master's clock; the heart at the bottom right of every window flashes on every shared second (green = synced or this machine is the master, grey = not synced yet). Network Interface keeps TCNet on its own network card. Node face: OUT · N nodes, Standby · <machine> is master, IN · <master>. Backup topology: Wire it inline, Source → TCNet → Device …; as Master (or bypassed) the data passes straight through, as Client the same chain is fed from the network master. Scratching passes through unsmoothed.

Click#

Audio click track locked to the deck's beat grid (beat.msToNextBeat + BPM), for drummers/band monitoring. Click On: Every Beat · Downbeats Only · Beats 2 + 4. Sound: High Beep / Low Beep / Click / Woodblock; Accent Downbeat makes beat 1 louder + brighter. Audio Device (live list) + Channel (Both/L/R) + Level, same audio engine as LTC. Runs while the deck plays; node face shows BPM · beat. Loops: The click knows the deck's loop points and wraps with it, no missed or doubled beat at the loop point, however short the loop. Inside a cue (wired to the Cue block): it clicks the beats that fall inside the cue's span, rendered ahead like any click, so the cue's first beat is on time. It follows the Source's Latency Compensation exactly like the cue audio lanes and the Cue Caller, tune that one value, keep the click's own Timing Offset at 0 unless its output device needs a correction. Pause stops it at once (queued clicks are dropped).

Ref Tone#

A reference / keep-alive tone for automation and broadcast systems that listen for it to know this system is alive. Sound: Always, While Condition (a key on the wired input, e.g. playback.onAir, trigger.active, cue.active, Is On / Is Off / Equals / Not Equal / Greater Than / Less Than a value; empty key = "something is wired and sending"), Heartbeat (a burst of Burst Length ms every Every s) or Heartbeat While Condition. Waveform: Sine (Frequency, 1000 Hz = line-up standard) or pink noise. Level in dBFS (−18 = EBU line-up, −20 = SMPTE reference); a short Fade on every start/stop so it never clicks; stops at once when the condition drops. Override E-STOP (on by default) keeps it sounding during an E-STOP, turn it off to have E-STOP silence it too. Audio Output: Device + Both / Left / Right. Works in the Patch and inside cues. The node face shows the tone and a green dot while it sounds.

Ableton Link#

Joins a Link session and pushes the deck's live BPM (beat.currentBpm) to every peer, the DJ deck is the tempo boss. Mode: Tempo Only (default) follows BPM; Tempo + Beat Align also steers the session's bar phase onto the deck's beat grid (uses the quantum, re-anchors only on real drift). Start/Stop Sync mirrors the deck's play state into the session. Wired straight to a Source (ProDJ Link / TCNet, no Device node in between): it follows the network's tempo master deck, press MASTER on another player and Link follows that one (the node face shows Master: Player N, or No tempo master). Node face shows session tempo + peer count. One Link session per app, the first enabled Link node drives it.

Ableton Live#

Makes Live's arrangement transport follow the wired deck so audio stems laid out in Live play in step with it: play/stop, pitch (Live's tempo = stems BPM × deck speed), needle drops, hot cues and loops (one clean jump), with small drift pulled in by an inaudible tempo bend. Needs the ShowKontrol Remote Script in Live (see Ableton Live: stems that follow the deck below). Stems Start At: Locator = Track Title (a locator named after each track at the start of its stems, one Live set holds the whole show) · Chosen Locator · Start Bar. No Locator Found: Stop Live / Leave Live Alone. Stems Tempo: Track BPM / Fixed BPM. Offset (ms), Jump Threshold, Max Tempo Bend, Start Lead. State pin: ableton.* (§10). Node face: locator · lock error in ms, or what is missing.

PSN#

PosiStageNet server (Add Output → Show Control): sends tracker positions to lighting consoles, media servers and tracking-aware software, multicast 236.10.10.10:56565 (or type a unicast IP in Target). Add Trackers (up to 32): each has an ID, a Name and X / Y / Z, a data key (suffix-matched, e.g. value.x from a Script) or a number, plus an optional Orientation (rx, ry, rz, radians). Position Scale multiplies X/Y/Z (PSN works in metres). Speed is worked out from the movement; names and the System Name go out once a second, positions at the Data Rate (default 60 Hz). A key missing from the input keeps the tracker where it was.

MagicQ#

ChamSys MagicQ (Add Output → Lighting). Transport OSC (MagicQ's OSC Rx Port, 8000) or Remote Ethernet (ChamSys Remote Ethernet Protocol, UDP 6553, with or without the CREP header). Actions: Go / Go Back / Pause / Release / Activate / Flash On·Off / Fast Back·Forward / Playback Level / Jump To Cue on a Playback, Change Page, Execute Press / Release / Tap / Fader (page + item number, 4x3 or name), Channel Intensity, Test / Untest Cue Stack, Remote Command (raw ChamSys remote protocol, e.g. 1G2R3,50L) and Custom OSC. Playbacks 1-10 use MagicQ's /pb/… addresses, higher ones the remote protocol via /rpc. Follow Value streams a level. Feedback Port (OSC Tx, 9000): the node asks for /feedback/pb+exec and the State pin carries magicq.pb.1 … See Lighting consoles and ProPresenter below.

ETC Gateway#

ETC Response MIDI Gateway (Add Output → Lighting). Sends MIDI out of the gateway's MIDI OUT socket over plain UDP text (MIDI 90 3C 64), so no USB or Net3 link is needed. Actions: Note On / Off / Tap, Control Change (Follow Value streams it), Program Change, MSC (GO, STOP, RESUME, LOAD, FIRE, ALL_OFF, RESTORE, RESET, GO_OFF with Device ID, Cue and Cue List), MTC Locate (one full frame), Raw MIDI (hex bytes) and Custom String (Response Analog IO Gateway relays). Listen Port: MIDI arriving at the gateway's MIDI IN lands on the State pin as etcgw.note.1.60, etcgw.cc.1.7, etcgw.msc.cue, etcgw.timecode … See ETC Response MIDI Gateway below.

ONYX#

Obsidian ONYX over its Telnet remote (port set in ONYX, 2323 in the manual) or the same commands over UDP. Go Cuelist, Go To Cue, Pause, Release, Set Cuelist Level (0-255, Value Range scales), Release All (dimmer first / + overrides / overrides only), Clear Programmer, Action Group, Go Schedule, raw Command. Pick Cuelist lists ONYX's cuelists live (Telnet). State: onyx.active, onyx.ql<N>.active, onyx.cuelists.

Titan#

Avolites Titan WebAPI (HTTP 4430). Fire / Release / Kill a playback, Go / Go Back / Pause / Set Next Cue on a cue list, Set Level, Flash On·Off, Release All, Kill All, Change Page, Grand Master, Run Macro, Custom Script. The playback is a Handle by User Number, Location (playback_2_1) or Titan ID, Pick Handle lists Titan's handles live. State: titan.connected, titan.version.

grandMA2#

grandMA2 console / onPC over its Telnet command line (port 30000; console: Telnet = Login Enabled). Logs in with User / Password on every connect, then Go / Go Back / Pause / Off / Toggle / Fader Level / Go To Cue on an Executor (1.1 = page 1 exec 1) or any raw Command line. The console's answer lands in ma2.reply (errors turn the face orange). For dot2 (no telnet) use the MSC templates.

ProPresenter#

ProPresenter 7 over its HTTP API (Settings ▸ Network ▸ Enable Network + Port). Next / Previous Slide, Trigger Slide (of the live presentation), Trigger Presentation (name / UUID + slide), Trigger Playlist Item, Next / Previous Media and Audio, Clear Layer / Clear Group, Timer Start / Stop / Reset, Show / Hide Stage Message (text with $VARIABLES, re-sent when it changes), Trigger Macro / Look, Transport Play / Pause, Custom Request. Slides count from 1. Timers, macros and looks are picked from live lists. State: propresenter.slide.current / .next, propresenter.timer.<name>.time / .state.

Lighting consoles and ProPresenter#

Six output nodes drive consoles, gateways and presentation software directly; all follow the usual command-output rule (a wired Trigger firing, the input going active (a Track / Cue / Smart Cue wired straight in) or ▶ on the node), show the last command on the node face (orange = it failed or is not connected) and report back on a State pin.

Live lists. ONYX cuelists, Titan handles and ProPresenter timers / macros / looks are read from the running console: pick one in the Pick … popup and its number / name lands in the field next to it (the popup goes back to ", "). The field can always be typed by hand, or be a data key / ${key} template (metadata.trackNumber = one cue per track).

Follow Value. MagicQ, ONYX, Titan and grandMA2 level actions can follow a value as it moves instead of firing once, a DJM channel fader riding a playback.

ProPresenter stage message. Show Stage Message takes text with $VARIABLES (Next: $NEXT in $CUEIN); with Keep Updating on it is re-sent whenever the text changes (at most once a second) until Hide Stage Message.

ETC Response MIDI Gateway. The gateway turns UDP text into real MIDI and back. ShowKontrol sends one message per packet, written as the word MIDI and hex bytes (MIDI 90 3C 64 is middle C on). Whatever is plugged into the gateway's MIDI OUT receives it: a console with a MIDI input, a synth, a sound desk. Set it up in ETC Concert, because the gateway ships with UDP switched off:

• MIDI Out ▸ Source UDP Port: the same number as the node's MIDI Out Port (6000 by default). Leave Source UDP Multicast Address at 0.0.0.0.
• MIDI In ▸ Destination IP Address: this computer's IP. Destination UDP Port: the node's Listen Port (6001 by default). Any terminator works.

Pick the Action and fire it with a Trigger, a Track or ▶. Note Tap sends note on and then note off on the next pass. MSC sends MIDI Show Control; FIRE runs a macro, so put the macro number in Cue. MTC Locate sends one MTC full frame so the receiver jumps to that time. For running timecode, set an MTC node's Output Mode to ETC Gateway (UDP) with the same Gateway IP and port. Custom String sends any text, which drives the relays of a Response Analog IO Gateway (on_1, off_1).

MIDI coming in through the gateway fills the State pin. A Response SMPTE Gateway can send to the same Listen Port; its timecode shows up as etcgw.timecode. Two ETC nodes may share one Listen Port.

Eos itself listens to the gateway over Net3, not UDP. To drive Eos straight from ShowKontrol, use its String UDP or OSC input.

State keys: etcgw.connected, etcgw.lastMidi, etcgw.note.<ch>.<n> (velocity, 0 = off), etcgw.lastNote, etcgw.cc.<ch>.<n>, etcgw.program.<ch>, etcgw.pitchbend.<ch>, etcgw.msc.command / .cue / .list / .count, etcgw.timecode (HH:MM:SS:FF, from full frames and quarter frames), etcgw.timecode.ms, etcgw.rxCount, etcgw.txCount · magicq.connected, magicq.pb.<n> … (whatever MagicQ sends) · onyx.connected, onyx.active, onyx.activeCount, onyx.ql<N>.active · titan.connected, titan.version, titan.handles · ma2.connected, ma2.reply, ma2.error · propresenter.connected, propresenter.name, propresenter.slide.current, propresenter.slide.next, propresenter.timer.<name>.time / .state · every node: <kind>.lastCommand.

Resolume: a clip that follows the deck (Timecode Chase)#

The Resolume node's Timecode Chase action plays a video clip in step with a deck. Wire the deck (a Device node or the deck's Selector) into the Resolume node, pick the Layer and Clip, and choose what a fire connects (On Fire Connect: The clip, its Column, or nothing). Connect When Deck Plays connects it by itself when the deck starts.

From then on the clip's position follows the deck's track time (Clip Starts At = the track time of the clip's first frame): the deck pausing pauses the clip on the same frame, a needle drop or hot cue jumps it, and while both play the clip is read back about five times a second and re-seeded when it drifts more than Max Drift (80 ms). Latency aims every seek slightly ahead; Follow Pitch sends the deck's pitch to the clip's speed. Past the clip's end it holds on the last frame.

In Resolume the clip must use the Timeline transport (not BPM Sync). The node face shows chase · L1 C3 · drift 12 ms; the State pin adds resolume.chase.driftMs, .clipMs, .targetMs, .corrections.

Ableton Live: stems that follow the deck#

The Ableton Live output node turns Live into a stem player slaved to a deck (or to the master layer, wire whatever source the stems should follow).

Setup, once per machine running Live

1. Copy the ShowKontrol folder (from the ShowKontrol package, SK ABLETON) into ~/Music/Ableton/User Library/Remote Scripts/, or run install.sh next to it. (Windows: Documents\Ableton\User Library\Remote Scripts\.)
2. Restart Live, then Settings ▸ Link, Tempo & MIDI ▸ Control Surface: pick ShowKontrol (Input/Output: None). Live's status bar says "ShowKontrol: listening on UDP 47841".
3. Turn Link off in Live and leave External Sync off, the node drives Live's tempo itself.

Preparing the Live set

• Put each track's stems in the Arrangement, all starting at the same point: exactly where the track's audio starts (a stem export from the full track lines up by itself).
• Warp the stems at the track's BPM (one warp marker at their start, segment BPM = the rekordbox BPM). Beats or Complex Pro warp keeps the key when the deck's tempo moves; Re-Pitch follows a CDJ with Master Tempo off.
• Drop a locator at the start of each track's stems and name it after the track title as rekordbox shows it. The match ignores case and also accepts a locator that contains the title ("03 Strobe – stems").
• Remove tempo automation from the set: the node sets Live's tempo.

In the Patch: Source ▸ Selector (the deck) → Ableton Live node. When the deck loads a track Live locates to its locator; play/stop, pitch, needle drops, hot cues and loops follow. A track with no locator stops Live (or leaves it alone, No Locator Found). The State pin carries Live's position, tempo and lock error (ableton.*, §10) and the locator list.

How tight: The chase runs inside Live. A start or jump lands within a few milliseconds after the first one of a session (the script learns Live's own reaction time); in between, Live is held within a couple of ms by bending its tempo up to Max Tempo Bend (2 %). Anything further off than Jump Threshold (60 ms) is one clean jump. Offset (ms) lines the stems up by ear against the DJ mixer (+ = Live earlier).

If ShowKontrol quits, the node is disabled, or the network drops for a second, Live stops (Stop Live If ShowKontrol Stops, on by default).