MIDIbox OSC Server/Client

OSC stands for "Open Sound Control". This protocol becomes more and more popular these days, especially with the advent of gadgets such as iPhone and iPad which provide a touchscreen and wireless network interface, perfectly suitable for remote controlling musical gear. But the protocol allows much more usecases of course! It's especially more flexible than the MIDI protocol, which was tailored around the capabilities of synths developed in the 80s, and therefore has certain limitations (e.g. number of channels, resolution, the way how frequencies of notes are controlled).

OSC vs. MIDI

As somebody who developed programs for MIDI since the early 90s (started on a C64) I would like to give my personal opinions first before describing the OSC features provided by MIDIbox.

Speed: very often you will read that OSC is faster than MIDI as informations are typically sent over fast ethernet interfaces.
This statement is true as long as MIDI devices are connected through a common MIDI interface running at a baudrate of 31.25kbaud. Accordingly, the transmission of a single (unoptimized) MIDI event (3 bytes) will take ca. 1 mS, while over an ethernet line a bundle of OSC messages could be transmitted in a fraction of this time.
This statement is not true once MIDI events are sent over a different physical interface, such as USB.
If OSC is processed by a common microcontroller, USB-MIDI is even faster - see also the results of these experiments!

Speed2: sometimes I also read the argument that MIDI is so outdated that people don't understand why it hasn't been replaced by more modern protocol yet. From my experiences with using MIDI with low-cost microcontrollers: I'm very happy that it still exists! The usage of MIDI is uncomplicated and still leads to better performance compared to OSC; OSC can never beat it in these terms since the protocol requires more hardware and more computing power. Of course, today even cheap microcontrollers of the typical DIY range are powerful enough to send/receive OSC messages (if not via ethernet, then via RS232 resp. COM devices), but developers quickly run into problems once multiple tasks should run in parallel.
Not only that OSC increases the CPU load, it also leads to the requirement to process incoming packets much faster than with MIDI messages to avoid buffer overruns.
In other words: while with a common MIDI connection it was guaranteed that the application won't receive more than one MIDI event per mS (resp. 640 uS for running status optimized event), with OSC a huge bundle of messages could be received at the same time. This makes OSC applications less robust!
The reliability can be improved by transporting OSC messages via TCP/IP (a handshake protocol) instead of UDP, but this slows down the communication and adds some overhead (especially for embedded devices) so that the overall transfer speed could even be slower than 31.25kbaud!

Flexibility: OSC standardizes value types, formats and the addressing of entities. The same results could be achieved with MIDI (e.g. by using SysEx messages), but it isn't standardized! Extensions to the MIDI protocol are always proprietary and bound to custom applications.

Usability: Unfortunately OSC is still not supported by major DAWs such as Logic, Cubase, Sonar, Pro Tools, Ableton Live, etc! Especially when connecting control devices it would provide so many benfits, but it seems that the big companies are sleeping since years! There is still only a small number of applications which are supporting OSC, such as Reaktor and Max/MSP (to name the most favourite ones).

Personal conclusion: although OSC isn't the best performance option for a MIDI sequencer, I found already usecases which are very helpful for me, such as connection to an iPad based controller or transfer of MIDI events via WiFi (embedded into OSC messages), e.g. to a notebook. My hope is, that OSC will be supported in future versions of major DAWs - MIDIbox is prepared for this step! :-)

Ethernet Hardware

MIDIbox sends OSC packets over a "real ethernet device" (and not via COM has it can be found on many DIY projects). Accordingly, no computer is required for a communication to another device which provides OSC applications as well, such as iPhone and iPad. In these particular cases, just connect your MIDIbox to a wireless router and it will work!

The MBHP_CORE_LPC17 module provides an integrated Ethernet port, so that the OSC option can be used without additional hardware!

OSC is also supported by the MBHP_CORE_STM32 variant of the firmware if the MBHP_ETH module is connected to the SPI port J16 of the (in parallel to the SD Card).

OSC-ready Applications

The OSC protocol is only supported by MIOS32 based applications, and they have to reference the standard OSC Server/Client which can be seen as some kind of "plug-in".

It's currently included in applications like:

Please note: since these applications also include the MIDI router "plug-in", it's possible to use the MIDIboxes as OSC<->MIDI translator as well. See the appr. configuration example below.

If you would like to include OSC into your self-developed application, then have a look into Tutorial #028 (Simple OSC Server and Client)

Ethernet Configuration

The way how the ethernet interface and OSC server/client can be configured depends on the MIDIbox project, e.g. MIDIbox SEQ provides a special configuration page for this:

Ethernet

Alternatively all applications can be configured from the MIOS Terminal, which is part of MIOS Studio. Therefore below I will only refer to this possibility to keep this documentation generic.

All available terminal commands can be displayed by typing help in the MIOS Terminal:

Following commands are available:
...
  network:                          print network info
  set dhcp <on|off>:                enables/disables DHCP
  set ip <address>:                 changes IP address
  set netmask <mask>:               changes netmask
  set gateway <address>:            changes gateway address
  set osc_remote <con> <address>:   changes OSC Remote Address
  set osc_remote_port <con> <port>: changes OSC Remote Port (1024..65535)
  set osc_local_port <con> <port>:  changes OSC Local Port (1024..65535)
  set osc_mode <con> <mode>:        changes OSC Transfer Mode (0..4)
  set udpmon <0..4>:                enables UDP monitor (verbose level: 0)
...

With the network command the current configuration will be displayed:

Ethernet cable connected: yes
Ethernet MAC address: 00:5F:00:00:70:C4
Ethernet services running: yes
DHCP: enabled
IP address: 192.168.1.103
Netmask: 255.255.255.0
Default Router (Gateway): 192.168.1.1
OSC1 Remote address: 192.168.1.101
OSC1 Remote port: 8001
OSC1 Local port: 8000
OSC1 Transfer Mode: 0 - MIDI Messages       
OSC2 Remote address: 192.168.1.101
OSC2 Remote port: 8001
OSC2 Local port: 8000
OSC2 Transfer Mode: 0 - MIDI Messages       
OSC3 Remote address: 192.168.1.101
OSC3 Remote port: 8001
OSC3 Local port: 8000
OSC3 Transfer Mode: 0 - MIDI Messages       
OSC4 Remote address: 192.168.1.101
OSC4 Remote port: 8001
OSC4 Local port: 8000
OSC4 Transfer Mode: 0 - MIDI Messages       
UDP Monitor: verbose level #0

Network related commands:

  • set dhcp <on|off>: if enabled via set dhcp on (default), the Host IP, Network Mask and Gateway address will be requested from a DHCP Daemon (e.g. your wireless router) automatically whenever the ethernet cable is connected. The configuration could take some seconds depending on the responsiveness of your router.
    set dhcp off will disable this function, so that the IP settings can be specified directly.
  • set ip <address>: allows to enter the IP address of your MIDIbox manually if DHCP is disabled.
    Example: set ip 192.168.1.180
  • set netmask <mask>: allows to enter the netmask of your MIDIbox manually if DHCP is disabled.
    Example: set netmask 255.255.255.0
  • set gateway <address>: allows to enter the gateway of the ethernet network manually if DHCP is disabled.
    Example: set gateway 192.168.1.1

OSC related commands:

  • set osc_remote <con> <address>: defines the remote IP assigned to the given OSC connection (e.g. the IP of your iPad).
    <con> ranges from 1..4 and is displayed as OSC1..OSC4.
    Example: set osc_remote 1 192.168.1.110
  • set osc_remote_port <con> <port>: defines the remote port to which OSC packets will be sent.
    Example: set osc_remote_port 1 10001
  • set osc_local_port <con> <port>: defines the local port from which OSC packets will be received.
    Example: set osc_local_port 1 10000
  • set osc_mode <con> <mode>: defines the packet format which should be used.
    If you omit <mode>, the supported transfer formats will be listed:
    • 0: MIDI Messages: MIDI events are bundled into MIDI elements
    • 1: Text Msg (Integer): uses human readable pathes, values are in integer format
    • 2: Text Msg (Float): uses human readable pathes, values are in float format
    • 3: MPP (Pianist Pro): selects format which is used by Pianist Pro
    • 4: TOSC (TouchOSC): selects format which is used by TouchOSC

Supported OSC Packet Formats

Following OSC formats are supported by the application - the list of supported formats will be enhanced on request:

  • MIDI: MIDI events are bundled into MIDI elements, so that they can be forwarded with a MIDI proxy running on a computer. Currently only a selfwritten proxy for MacOS exists, but it should be possible to port it to other operating systems as well (if somebody is interested: step forward!)
    The proxy supports common MIDI events, but also SysEx streams (!!!) embedded into "blobs".
    OSC packets are sent to the path "/midi1" ... "/midi4" depending on the OSC port number.

  • Text Msg (Integer or Float): MIDI events will be converted into human readable pathes. Values are either in integer or float format (e.g. float is the only type which is supported by NI Reaktor.
    List of Events:
    • Note Events: /<chn>/note <key-number> <velocity>
    • Polypressure Events: /<chn>/polypressure <key-number> <velocity>
    • CC Events: /<chn>/cc <cc-number> <cc-value>
    • NRPN Events: /<chn>/nrpn <nrpn-number> <14bit-value>
    • Program Change Events: /<chn>/programchange <program-number>
    • Aftertouch Events: /<chn>/aftertouch <key-number>
    • Pitchbend Events: /<chn>/pitchbend <pitch>

  • Pianist Pro: MIDI events will be converted into the format which is used by Pianist Pro:
    • Note Events: /mcmpp/key/<chn>/<key-number> <velocity>
    • Polypressure Events: /mcmpp/polypressure/<chn>/<key-number> <velocity>
    • CC Events: /mcmpp/cc/<chn>/<cc-number> <cc-value>
    • Program Change Events: /mcmpp/programchange/<chn>/<program-number>
    • Aftertouch Events: /aftertouch/<chn> <key-number>
    • Pitchbend Events: /pitch/<chn> <pitch>

  • TouchOSC: MIDI events will be converted into the format which is compatible to TouchOSC:
    • Note Events: /<chn>/note_<key-number> <velocity>
    • Polypressure Events: /<chn>/polypressure_<key-number> <velocity>
    • CC Events: /<chn>/cc_<cc-number> <cc-value>
    • Program Change Events: /<chn>/programchange_<program-number>
    • Aftertouch Events: /<chn>/aftertouch <key-number>
    • Pitchbend Events: /<chn>/pitchbend <pitch>
    A simple example configuration for iPad can be downloaded from here.
    Update: this format is also the best choice for newer Native Instruments Reaktor versions meanwhile, because it's natively supported (nice word game ;-)) - see also the configuration example at the end of this page.

Please note: local and remote port have to be swapped when two devices communicate together. It's like connecting the "MIDI OUT" to the "MIDI IN" port. In other words: the "local port" of your MIDIbox has to be set to the "remote port" of the remote host, and vice versa.

Please note also that the MIDIbox implementation allows to use the same port number for "local" and "remote", but unfortunately most other applications don't support this simplified setup.

Visualize OSC data on a PC/Mac

The OSC Tool of MIOS Studio allows to send and receive OSC datagrams:

Similar to the SysEx window, there is one frame to enter data that should be sent, and another frame which displays received messages.

Enter the remote host and port over which datagrams should be sent. You can either enter the IP address or the host name of the host that should receive outgoing data (such as "localhost" to send data internally on your PC/Mac).

The local port is the one which receives OSC datagrams from any IP. It's allowed to set the local port to the same number as the remote port if your application requires this.

If no data is received in the monitor, it makes sense to check the IP address of your MIDIbox from your PC/Mac.
This can be done from the command line (Windows: run 'cmd', MacOS: search for 'terminal' in Spotlight).
Example:

Ethernet Ping1

Note that with a WiFi connection the latency could be much higher:

Ethernet Ping2

So: ping is also a nice tool to determine the network performance!

Visualize OSC data on your MIDIbox

An integrated UDP packet monitor can be enabled in the MIOS Terminal with different verbose levels:

  • set udpmon 4: maximum verbose level, displays all received and sent packets:
    Set UDP monitor level to 4 (all received and sent packets)
    [UDP:DHCP] from 0.0.0.0:0 to port 0 (0 bytes)
    [UDP:DHCP] from 0.0.0.0:0 to port 0 (0 bytes)
    [UDP:DHCP] from 0.0.0.0:65165 to port 10901 (0 bytes)
    [UDP:DHCP] from 0.0.0.0:65165 to port 10901 (0 bytes)
    [UDP:OSC_RECEIVED] from 192.168.1.110:63152 to port 10000 (20 bytes)
    00000000  2F 31 2F 6E 6F 74 65 5F 35 32 00 00 2C 66 00 00  /1/note_52..,f..
    00000010  3F 80 00 00                                      ?...
    [UDP:DHCP] from 192.168.1.110:63152 to port 10000 (0 bytes)
    [UDP:DHCP] from 192.168.1.110:63152 to port 10000 (0 bytes)
    [UDP:DHCP] from 192.168.1.110:63152 to port 10000 (0 bytes)
    [UDP:DHCP] from 0.0.0.0:65165 to port 10901 (0 bytes)
    [UDP:DHCP] from 0.0.0.0:65165 to port 10901 (0 bytes)
    [UDP:DHCP] from 0.0.0.0:65165 to port 10901 (0 bytes)
    [UDP:OSC_RECEIVED] from 192.168.1.110:63152 to port 10000 (20 bytes)
    00000000  2F 31 2F 6E 6F 74 65 5F 35 32 00 00 2C 66 00 00  /1/note_52..,f..
    00000010  00 00 00 00                                      ....
    [UDP:OSC_RECEIVED] from 192.168.1.110:63152 to port 10000 (20 bytes)
    00000000  2F 31 2F 6E 6F 74 65 5F 35 36 00 00 2C 66 00 00  /1/note_56..,f..
    00000010  3F 80 00 00                                      ?...
    [UDP:OSC_RECEIVED] from 192.168.1.110:63152 to port 10000 (20 bytes)
    00000000  2F 31 2F 6E 6F 74 65 5F 35 36 00 00 2C 66 00 00  /1/note_56..,f..
    00000010  00 00 00 00                                      ....
    [UDP:OSC_RECEIVED] from 192.168.1.110:63152 to port 10000 (20 bytes)
    00000000  2F 31 2F 6E 6F 74 65 5F 35 38 00 00 2C 66 00 00  /1/note_58..,f..
    00000010  3F 80 00 00                                      ?...
    
  • set udpmon 3: displays all received and sent packets with port number >= 1024.
  • set udpmon 2: displays all received and sent packets which are assigned to OSC1..OSC4
  • set udpmon 1: displays all received packets which are assigned to OSC1..OSC4
  • set udpmon 0: disables the monitor (default)

Usage Example: MIDI to OSC

We want to use the integrated MIDI router to translate MIDI events from an external MIDI device (e.g. a MIDI keyboard) into OSC packets. The OSC packets should be transmitted to a Reaktor patch running on a PC or Mac.

  • determine the IP address of your PC/Mac; we assume it's 192.168.1.113:
    set osc_remote 1 192.168.1.113
  • define a remote to which Reaktor will listen, and local port to which your MIDIbox will listen, e.g.:
    set osc_remote_port 1 10001
    set osc_local_port 1 10000
  • check the OSC transfer modes which are available:
    set osc_mode 1
    will output:
    Expecting OSC transfer mode 0..4
    Transfer Mode Mapping:
    0: MIDI Messages       
    1: Text Msg (Integer)  
    2: Text Msg (Float)
    3: Pianist Pro (iPad)  
    4: TouchOSC    (*)    
    
  • select the transfer mode which is suitable for Reaktor, e.g. 4 (TouchOSC)
    set osc_mode 1 4
  • now configure the integrated MIDI merger, so that it forwards MIDI events received from IN1 to OSC1, and MIDI events received from OSC1 to OUT1:
    set router 1 IN1 all OSC1 all
    set router 2 OSC1 all OUT1 all
  • type following command to check the setup:
    router
    It should display:
    MIDI Router Nodes (change with 'set router <in-port> <channel> <out-port> <channel>)
       1  SRC:IN1  all  DST:OSC1 all
       2  SRC:OSC1 all  DST:OUT1 all
       3  SRC:USB1 off  DST:OUT1 all
       4  SRC:USB1 off  DST:OUT1 all
       5  SRC:USB1 off  DST:OUT1 all
       6  SRC:USB1 off  DST:OUT1 all
       7  SRC:USB1 off  DST:OUT1 all
       8  SRC:USB1 off  DST:OUT1 all
       9  SRC:USB1 off  DST:OUT1 all
      10  SRC:USB1 off  DST:OUT1 all
      11  SRC:USB1 off  DST:OUT1 all
      12  SRC:USB1 off  DST:OUT1 all
      13  SRC:USB1 off  DST:OUT1 all
      14  SRC:USB1 off  DST:OUT1 all
      15  SRC:USB1 off  DST:OUT1 all
      16  SRC:USB1 off  DST:OUT1 all
    
  • enable the UDP monitor to display outgoing packets:
    set udpmon 2
    and move the modulation wheel on your MIDI keyboard. The MIOS terminal should display:
    [UDP:OSC_SEND] to 192.168.1.103:10001 from port 10000 (16 bytes)
    00000000  2F 31 2F 63 63 5F 31 00 2C 66 00 00 3E D9 B3 67  /1/cc_1.,f..>..g
    [UDP:OSC_SEND] to 192.168.1.103:10001 from port 10000 (16 bytes)
    00000000  2F 31 2F 63 63 5F 31 00 2C 66 00 00 3E E5 CB 97  /1/cc_1.,f..>...
    [UDP:OSC_SEND] to 192.168.1.103:10001 from port 10000 (16 bytes)
    00000000  2F 31 2F 63 63 5F 31 00 2C 66 00 00 3E E9 D3 A7  /1/cc_1.,f..>...
    [UDP:OSC_SEND] to 192.168.1.103:10001 from port 10000 (16 bytes)
    00000000  2F 31 2F 63 63 5F 31 00 2C 66 00 00 3E ED DB B7  /1/cc_1.,f..>...
    [UDP:OSC_SEND] to 192.168.1.103:10001 from port 10000 (16 bytes)
    00000000  2F 31 2F 63 63 5F 31 00 2C 66 00 00 3E F9 F3 E8  /1/cc_1.,f..>...
    [UDP:OSC_SEND] to 192.168.1.103:10001 from port 10000 (16 bytes)
    00000000  2F 31 2F 63 63 5F 31 00 2C 66 00 00 3F 01 02 04  /1/cc_1.,f..?...
    [UDP:OSC_SEND] to 192.168.1.103:10001 from port 10000 (16 bytes)
    00000000  2F 31 2F 63 63 5F 31 00 2C 66 00 00 3F 03 06 0C  /1/cc_1.,f..?...
    
  • turn the UDP monitor off again to save performance:
    set udpmon 0
  • start Reaktor on your PC/Mac, and open the OSC configuration (File->OSC Settings)
    Activate OSC, select the local port 10001 (remember: you've configured 10001 as remote port on your MIDIbox which is the right choice!). Enable the OSC Monitor ("Append Lines") and move the modulation wheel on your keyboard again. You should see:

    If you don't see incoming packets, check that no other application on your PC/Mac listens to the same port (this won't work!) - check especially that the OSC monitor of MIOS Studio is disconnected - Reaktor won't notify this conflict and won't receive packets!
    Finally you should add your device to the device list (here: MIDIbox 192.168.1.103 10000)
  • Integrate a synth into the Reaktor ensemble, select a knob and display the preferences.
    Select the Connect tab and then the OSC event to which the knob shut listen (here: CutOff to cc_1):
    ->done! :-)

Usage Example: MIDIbox to MIDIbox via Ethernet

We want to connect two MIDIboxes via Ethernet, and transfer MIDI streams between the MIDI IN/OUT ports.

  • we assume that MIDIbox A has IP address 192.168.1.112, and MIDIbox B the IP address 192.168.1.103.
    Configure MIDIbox A to send to MIDIbox B:
    set osc_remote 1 192.168.1.103
    set osc_remote_port 1 10000
    set osc_local_port 1 10001
    set osc_mode 1 0
    set osc_remote 2 192.168.1.103
    set osc_remote_port 2 10002
    set osc_local_port 2 10003
    set osc_mode 2 0
    And configure MIDIbox B to send to MIDIbox A:
    set osc_remote 1 192.168.1.112
    set osc_remote_port 1 10001
    set osc_local_port 1 10000
    set osc_mode 1 0
    set osc_remote 2 192.168.1.112
    set osc_remote_port 2 10003
    set osc_local_port 2 10002
    set osc_mode 2 0
    In both cases we select OSC transfer mode 0 (MIDI events), which will even work for SysEx streams!
  • now configure the integrated MIDI merger, so that it forwards MIDI events received from IN1 to OSC1 + IN2 to OSC2, and MIDI events received from OSC1 to OUT1 + OSC2 to OUT2:
    set router 1 IN1 all OSC1 all
    set router 2 OSC1 all OUT1 all
    set router 3 IN2 all OSC2 all
    set router 4 OSC2 all OUT2 all
    This has to be done for both MIDIbox devices!
  • type following command to check the setup:
    router
    It should display:
    MIDI Router Nodes (change with 'set router <in-port> <channel> <out-port> <channel>)
       1  SRC:IN1  all  DST:OSC1 all
       2  SRC:OSC1 all  DST:OUT1 all
       3  SRC:IN2  all  DST:OSC2 all
       4  SRC:OSC2 all  DST:OUT2 all
       5  SRC:USB1 off  DST:OUT1 all
       6  SRC:USB1 off  DST:OUT1 all
       7  SRC:USB1 off  DST:OUT1 all
       8  SRC:USB1 off  DST:OUT1 all
       9  SRC:USB1 off  DST:OUT1 all
      10  SRC:USB1 off  DST:OUT1 all
      11  SRC:USB1 off  DST:OUT1 all
      12  SRC:USB1 off  DST:OUT1 all
      13  SRC:USB1 off  DST:OUT1 all
      14  SRC:USB1 off  DST:OUT1 all
      15  SRC:USB1 off  DST:OUT1 all
      16  SRC:USB1 off  DST:OUT1 all
    
  • done! You've now a bidirectional connection between two MIDIboxes via Ethernet! :-)
    Use the udpmon to troubleshoot the connections for the case that MIDI data won't be forwarded!

Usage Example: Bridging a MIDIbox IN/OUT port to a Mac via Ethernet

We want send MIDI events to a computer via Ethernet, and they should be converted back to MIDI events and forwarded to an internal (virtual) MIDI bus. Such a "proxy" currently only exists for MacOS. The source code can be found in the SVN repository. It should be possible to port it to other operating systems as well (if somebody is interested: step forward!)

A prebuilt binary is available as well: osc_midi_proxy_v1.zip

  • determine the IP address of your Mac; we assume it's 192.168.1.113:
    set osc_remote 1 192.168.1.113
  • define a remote to which your Mac will listen, and local port to which your MIDIbox will listen, e.g.:
    set osc_remote_port 1 10001
    set osc_local_port 1 10000
  • check the OSC transfer modes which are available:
    set osc_mode 1
    will output:
    Expecting OSC transfer mode 0..4
    Transfer Mode Mapping:
    0: MIDI Messages           (*)
    1: Text Msg (Integer)  
    2: Text Msg (Float)
    3: Pianist Pro (iPad)  
    4: TouchOSC
    
  • select the MIDI transfer mode 0, because it will support SysEx streams as well!
    set osc_mode 1 0
  • now configure the integrated MIDI merger, so that it forwards MIDI events received from IN1 to OSC1, and MIDI events received from OSC1 to OUT1:
    set router 1 IN1 all OSC1 all
    set router 2 OSC1 all OUT1 all
  • type following command to check the setup:
    router
    It should display:
    MIDI Router Nodes (change with 'set router <in-port> <channel> <out-port> <channel>)
       1  SRC:IN1  all  DST:OSC1 all
       2  SRC:OSC1 all  DST:OUT1 all
       3  SRC:USB1 off  DST:OUT1 all
       4  SRC:USB1 off  DST:OUT1 all
       5  SRC:USB1 off  DST:OUT1 all
       6  SRC:USB1 off  DST:OUT1 all
       7  SRC:USB1 off  DST:OUT1 all
       8  SRC:USB1 off  DST:OUT1 all
       9  SRC:USB1 off  DST:OUT1 all
      10  SRC:USB1 off  DST:OUT1 all
      11  SRC:USB1 off  DST:OUT1 all
      12  SRC:USB1 off  DST:OUT1 all
      13  SRC:USB1 off  DST:OUT1 all
      14  SRC:USB1 off  DST:OUT1 all
      15  SRC:USB1 off  DST:OUT1 all
      16  SRC:USB1 off  DST:OUT1 all
    
  • enable the UDP monitor to display outgoing packets:
    set udpmon 2
    and move the modulation wheel on your MIDI keyboard. The MIOS terminal should display:
    [UDP:OSC_SEND] to 192.168.1.103:10001 from port 10000 (16 bytes)
    00000000  2F 31 2F 63 63 5F 31 00 2C 66 00 00 3E D9 B3 67  /1/cc_1.,f..>..g
    [UDP:OSC_SEND] to 192.168.1.103:10001 from port 10000 (16 bytes)
    00000000  2F 31 2F 63 63 5F 31 00 2C 66 00 00 3E E5 CB 97  /1/cc_1.,f..>...
    [UDP:OSC_SEND] to 192.168.1.103:10001 from port 10000 (16 bytes)
    00000000  2F 31 2F 63 63 5F 31 00 2C 66 00 00 3E E9 D3 A7  /1/cc_1.,f..>...
    [UDP:OSC_SEND] to 192.168.1.103:10001 from port 10000 (16 bytes)
    00000000  2F 31 2F 63 63 5F 31 00 2C 66 00 00 3E ED DB B7  /1/cc_1.,f..>...
    [UDP:OSC_SEND] to 192.168.1.103:10001 from port 10000 (16 bytes)
    00000000  2F 31 2F 63 63 5F 31 00 2C 66 00 00 3E F9 F3 E8  /1/cc_1.,f..>...
    [UDP:OSC_SEND] to 192.168.1.103:10001 from port 10000 (16 bytes)
    00000000  2F 31 2F 63 63 5F 31 00 2C 66 00 00 3F 01 02 04  /1/cc_1.,f..?...
    [UDP:OSC_SEND] to 192.168.1.103:10001 from port 10000 (16 bytes)
    00000000  2F 31 2F 63 63 5F 31 00 2C 66 00 00 3F 03 06 0C  /1/cc_1.,f..?...
    
  • turn the UDP monitor off again to save performance:
    set udpmon 0
  • on your Mac, open the command line terminal by searching for "terminal" in Spotlight.
  • change to the Download directory where you downloaded the prebuilt binary:
    cd ~/Downloads/osc_midi_proxy_v1/macos
  • execute the tool without arguments to see the syntax:
    ./osc_midi_proxy
    SYNTAX: ./osc_midi_proxy <remote-host> <remote-port> [<local-port>]
               [--in <in-port-number>] [--out <out-port-number>]
  • type:
    ./osc_midi_proxy 192.168.1.103 10000 10001
    (note that local/remote ports have to be swapped here!)
    ...and go through the dialog:
    Connecting to 192.168.1.103 on port 10000
    Receiving on port 10001
    [ 0] CoreMIDI, USB-MIDI-Ger?t Anschluss 1 (default input)
    [ 1] CoreMIDI, USB-MIDI-Ger?t Anschluss 2 (input)
    [ 2] CoreMIDI, USB-MIDI-Ger?t Anschluss 3 (input)
    [ 3] CoreMIDI, USB-MIDI-Ger?t Anschluss 4 (input)
    [ 4] CoreMIDI, USB-MIDI-Ger?t Anschluss 5 (input)
    [ 5] CoreMIDI, LPC17 Core 2 (input)
    [ 6] CoreMIDI, MIDIbox SEQ V4 Anschluss 1 (input)
    [ 7] CoreMIDI, MIDIbox SEQ V4 Anschluss 2 (input)
    [ 8] CoreMIDI, MIDIbox SEQ V4 Anschluss 3 (input)
    [ 9] CoreMIDI, MIDIbox SEQ V4 Anschluss 4 (input)
    [10] CoreMIDI, IAC-Treiber IAC-Bus 1 (input)
    [11] CoreMIDI, IAC-Treiber IAC-Bus 2 (input)
    [12] CoreMIDI, Daemon Input 0 (input)
    [13] CoreMIDI, Daemon Input 1 (input)
    [14] CoreMIDI, Daemon Input 2 (input)
    [15] CoreMIDI, Daemon Input 3 (input)
    [16] CoreMIDI, Daemon Input 4 (input)
    [17] CoreMIDI, Daemon Input 5 (input)
    [18] CoreMIDI, Daemon Input 6 (input)
    [19] CoreMIDI, Daemon Input 7 (input)
    [20] CoreMIDI, MidiKeys (input)
    Type input number: 10
    [21] CoreMIDI: USB-MIDI-Ger?t Anschluss 1 (default output)
    [22] CoreMIDI: USB-MIDI-Ger?t Anschluss 2 (output)
    [23] CoreMIDI: USB-MIDI-Ger?t Anschluss 3 (output)
    [24] CoreMIDI: USB-MIDI-Ger?t Anschluss 4 (output)
    [25] CoreMIDI: USB-MIDI-Ger?t Anschluss 5 (output)
    [26] CoreMIDI: LPC17 Core 2 (output)
    [27] CoreMIDI: MIDIbox SEQ V4 Anschluss 1 (output)
    [28] CoreMIDI: MIDIbox SEQ V4 Anschluss 2 (output)
    [29] CoreMIDI: MIDIbox SEQ V4 Anschluss 3 (output)
    [30] CoreMIDI: MIDIbox SEQ V4 Anschluss 4 (output)
    [31] CoreMIDI: IAC-Treiber IAC-Bus 1 (output)
    [32] CoreMIDI: IAC-Treiber IAC-Bus 2 (output)
    [33] CoreMIDI: Daemon Output 0 (output)
    [34] CoreMIDI: Daemon Output 1 (output)
    [35] CoreMIDI: Daemon Output 2 (output)
    [36] CoreMIDI: Daemon Output 3 (output)
    [37] CoreMIDI: Daemon Output 4 (output)
    [38] CoreMIDI: Daemon Output 5 (output)
    [39] CoreMIDI: Daemon Output 6 (output)
    [40] CoreMIDI: Daemon Output 7 (output)
    Type output number: 32
    HINT: next time you could select the MIDI In/Out port from command line with:
       ./osc_midi_proxy 192.168.1.103 10000 10001 --in 10 --out 32
    MIDI IN 'CoreMIDI: IAC-Treiber IAC-Bus 1' opened.
    MIDI OUT 'CoreMIDI: IAC-Treiber IAC-Bus 2' opened.
    Proxy is running!
    
  • done! You've now a bidirectional MIDI connection between a MIDIbox and your computer via Ethernet! :-)
    Note that the osc_midi_proxy even allows to forward MIDI events to physical MIDI IN/OUT ports connected to your computer!
    Use the udpmon to troubleshoot the connections for the case that MIDI data won't be forwarded!


Last update: 2017-06-24

Copyright 1998-2017, Thorsten Klose. All rights reserved.