cloud93421.sbs

TS-MIDI Editor: The Complete Guide to Editing MIDI on Your TS Hardware

Written by

admin

in

TS-MIDI Editor Tutorial: Create Custom MIDI Maps and AutomationsTS-MIDI Editor is a powerful tool for users of TS hardware and MIDI-capable setups. Whether you’re shaping live performances, streamlining studio workflows, or building complex instrument controllers, this tutorial shows step-by-step how to create custom MIDI maps and automations that save time and expand creative options.

What you’ll learn

  • How TS-MIDI Editor structures MIDI data and device mapping
  • Creating and saving custom MIDI maps for controllers and instruments
  • Building automations (macros, sequences, and parameter sweeps)
  • Best practices for performance reliability and backup
  • Troubleshooting common issues

1. Understanding TS-MIDI Editor basics

TS-MIDI Editor is centered on mapping MIDI messages (note, CC, program change, NRPN/CC14, SysEx) to hardware parameters and sequences of actions. Key concepts:

  • MIDI Channels and Ports: Messages are sent/received on specific channels and routed through selected input/output ports.
  • Mappings: A mapping links an incoming message (e.g., CC#1 on Channel 1) to one or more target actions (e.g., change filter cutoff, send Program Change).
  • Layers and Presets: Organize sets of mappings into layers or presets for different songs/patches.
  • Automations: Timed or triggered sequences that send messages over time (arpeggios, sweeps, multi-step CC changes).
  • Macros: Single triggers that execute multiple MIDI actions at once.

2. Preparing your setup

  1. Connect your TS device and other MIDI hardware to your computer or MIDI interface.
  2. Open TS-MIDI Editor and ensure the app detects your device. Check the MIDI I/O settings and enable the correct input and output ports.
  3. Set the global MIDI channel for incoming control messages if you prefer a single channel workflow, or leave per-mapping channel selection enabled for flexibility.
  4. Create a new project or preset to keep work organized.

Tip: Use a simple test patch (a synth or soft-synth) to verify messages while building mappings.

3. Creating a basic MIDI map

Goal: Map a hardware knob to a synth filter cutoff.

  1. In TS-MIDI Editor, create a new mapping (click “Add Mapping” or equivalent).
  2. Set the incoming trigger:
    • Type: Control Change (CC)
    • Number: CC#74 (example)
    • Channel: 1
  3. Set the target action:
    • Target device/port: Your synth or MIDI output port
    • Message: Control Change or Real-time parameter mapping specific to the synth (e.g., CC#74 to filter cutoff)
    • Value scaling: Map 0–127 to 0–127 or apply custom min/max for finer control
  4. Save the mapping to the preset and test: turn the knob on your controller and watch the synth respond.

Notes on value scaling and transformation:

  • Linear scaling is default; use logarithmic/exponential when mapping to frequency-like parameters for more natural response.
  • Add invert option if knob rotation direction is reversed.

4. Building multi-action macros

Macros let a single button press execute multiple MIDI messages (useful for patch changes, toggling effects, or setting multiple parameters).

Example macro: Switch patch, set volume, and enable a delay effect.

  1. Create new Macro and give it a name (e.g., “ChorusOnSwitch”).
  2. Add steps in sequence:
    • Program Change to Channel 1, Program 10 (select patch on synth)
    • Control Change CC#7 to value 100 (set volume)
    • Control Change CC#91 to value 127 (enable reverb/delay send)
  3. Optional delays: Insert 50–200 ms pauses between steps if the target device needs time to process program changes.
  4. Assign the macro to a hardware button or MIDI note-on message. Test in-context.

Best practice: Keep macros idempotent (safe to run multiple times without causing unexpected states).

5. Creating timed automations and sequences

Automations in TS-MIDI Editor can step through values or play sequences triggered by MIDI or tempo.

Example: Create a 4-step CC sequence for rhythmic filter modulation.

  1. Create a new Automation and set its trigger:
    • Trigger type: Note On (from a pad) or MIDI Clock start/beat sync
    • Tempo sync: On (if you want it tied to host tempo)
  2. Define steps:
    • Step 1: CC#74 value 30
    • Step 2: CC#74 value 90
    • Step 3: CC#74 value 60
    • Step 4: CC#74 value 110
    • Step length: ⁄8 note per step (or custom duration)
  3. Looping and direction: Choose forward, backward, or ping-pong to vary modulation patterns.
  4. Assign output port/channel and scaling if multiple destinations are required.
  5. Start/stop control: Map a button to toggle the automation on/off, or set it to run while a note is held.

Pro tip: Use subtle CC changes and smoothing to avoid zipper noise on analog-modeling synth parameters.

6. Advanced: Conditional mappings and stateful automations

Use conditions and state to create context-sensitive behavior.

  • Conditions: Only fire mappings if a particular patch is active, a toggle is on, or a controller value exceeds a threshold.
  • Stateful variables: Store simple on/off or numeric states (e.g., current bank, mode) and reference them in mappings to change behavior without reassigning hardware.
  • Program-dependent mappings: Auto-switch mapping layers when receiving Program Change messages from a DAW or master controller.

Example: Create a mapping that behaves differently when “Performance Mode” is active:

  1. Create a boolean state “PerfMode.”
  2. Map a button to toggle PerfMode.
  3. Create two mappings for CC#1: one active when PerfMode = true (send to synth A), another when false (send to synth B).

7. Saving, backing up, and organizing presets

  • Use descriptive preset names (Song_Intro, Bass_Patch, Live_Set_01).
  • Export complete projects and individual presets regularly. Store versioned backups to revert if a mapping change breaks other behavior.
  • For live rigs, keep a “Factory Reset” or safe preset that routes MIDI through with minimal processing as an emergency fallback.

8. Troubleshooting common problems

  • No response from target device: verify MIDI I/O port, cable, channel, and that the destination device is set to receive on that channel.
  • Values jumping or jittery: enable smoothing/filtering on CC inputs or increase resolution (use NRPN/14-bit CC where supported).
  • Program Change ignored: add small delays after Program Change before sending dependent CCs.
  • Conflicting mappings: check for overlapping mappings on the same incoming message and channel; use conditional states or layers to avoid clashes.

9. Example workflows

Live performance:

  • Create a “Live” preset with macros for song changes, automations for intros/outros, and a “panic” macro that sends All Notes Off + Reset/All Controllers.

Studio sound design:

  • Map multiple CCs to a synth’s macro parameters and record automation from TS-MIDI Editor into your DAW for detailed envelope editing.

Hybrid (live + DAW):

  • Use MIDI Clock sync for tempo-based automations and map transport controls from the DAW to TS-MIDI Editor to keep devices synchronized.

10. Appendix — Quick reference

  • Incoming types supported: Note On/Off, CC, Program Change, Pitch Bend, SysEx, NRPN/14-bit CC.
  • Common CC numbers: CC#1 (Mod Wheel), CC#7 (Volume), CC#10 (Pan), CC#74 (Filter Cutoff).
  • Useful defaults: 10–50 ms delay after Program Change; smoothing of 10–20 steps for analog-parameter-like control.

If you want, I can:

  • Provide a step-by-step walkthrough for your exact TS hardware model and synth.
  • Create downloadable preset examples (macro + automation) you can import into TS-MIDI Editor.

Comments

Leave a Reply

Your email address will not be published. Required fields are marked *

More posts