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:

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:

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

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 GIT 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

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: 2024-05-08