Building a MIDI Controller with Analog Discovery Pro (ADP3450/3250)

To connect to your DAW without a physical MIDI connector, you will need a network MIDI driver. Such a driver is included in the rtpMIDI by Tobias Erichsen. Download, install, and start the program, then rename and enable your first session.

Let the rtpMIDI run in the background and open the DAW. Open the DAW's settings, then find the MIDI settings, or MIDI devices and select the previously created rtpMIDI session as an input device.

Add a new track (or more) to your project and select the desired instrument or effect to control.

Before playing the selected instrument, you must set up your MIDI controller.

Select the location where you want to work with the “cd” command, then clone the RaveloxMIDI GitHub repository:

git clone https://github.com/ravelox/pimidi.git

Open the cloned directory:

cd pimidi
cd raveloxmidi

Install RaveloxMIDI with:

sh ./autogen.sh
./configure
make
sudo make install

Design the user interface circuit to contain the control and indicator elements you want. Keep in mind the offered possibilities and limitations of the ADP3450, and the signal conditioning methods discussed above.

Connect the output signals of the user interface to the FPGA board, but keep track of the connections, as they will have to be defined in the PLD design later, in Multisim (see below).

The BNC oscilloscope connectors are connected directly to the drum pad outputs (multiplexed) and the waveform generator channels are used to generate the reference signal for the PWM generator and the -5V DC voltage reference. The USB ports on the ADP are used to power and program the FPGA, connect the Wi-Fi dongle and supply power to the displays and LEDs through a USB connector.

The Pmod connectors are used on the Arty-S7 to connect the user interface control elements, while the Chipkit analog headers are used to connect the displays and the LEDs. The ADP3450 digital pins are connected to the outer digital Chipkit header.

As most of the control signals are digital (including the converted “slow” analog signals), the conditioning circuits for them will be also digital. To prototype a complex digital circuit, the easiest way is to use an FPGA development board. In this project the Arty-S7 FPGA board will be used, for which the design will be created in Multisim, to avoid using VHDL, or Verilog (which can be challenging, especially for new users) and to make the final circuit easier to understand by drawing a schematic of it.

If your chosen FPGA board isn't available in Multisim PLD design, follow the instructions in the Adding Digilent FPGA Boards to Multisim guide to create the configuration files for it.

Start a new PLD design in Multisim, select your board and create the conditioning circuits for your signals. You should use some digital I/O pins of the ADP3450 as outputs to control the multiplexers connected to the input pins, this way you can connect much more signals to the input, then the number of input pins.

When ready, click Transfer → Export to PLD… → Generate and save programming file to use Vivado and compile the bit file from the design.

To configure the FPGA board connected to the ADP3450, with the bit file created with Multisim, the Adept Utilities must be installed on your device. To install the software, follow the Programming an FPGA Board with the Analog Discovery Pro (ADP3450/ADP3250) guide.

Create a module in which you use in a subprocess the commands

djtgcfg init -d ArtyS7

and

djtgcfg prog -d ArtyS7 -i 0 -f ./FPGA/midi_driver_ArtyS7.bit

Note: Don't forget to change the device name and the name of the bit file to match to your preferences.

""" This module realizes communication with the FPGA board """
 
from subprocess import Popen, PIPE
 
"""-------------------------------------------------------------------"""
""" UPLOADING THE BIT FILE """
"""-------------------------------------------------------------------"""
 
 
def configure(description_file="./FPGA/MIDI_UI_Arty_S7.bit", device_name="ArtyS7", chip_index="0"):
    """
        configures the connected FPGA board
 
        parameters: - bit file
                    - device name
                    - chip index
 
        returns:    - True on success, False on error
    """
    # initialize the FPGA board
    process = Popen(["djtgcfg", "init", "-d", device_name],
                     stdout=PIPE, stderr=PIPE)
    stdout, stderr = process.communicate()
    stdout = stdout.decode("UTF-8")
    stderr = stderr.decode("UTF-8")
 
    # check response
    if stderr != "" or not ("Found Device ID" in stdout):
        return False
 
    # upload the bit file
    process = Popen(["djtgcfg", "prog", "-d", device_name,
                     "-i", chip_index, "-f", description_file],
                     stdout=PIPE, stderr=PIPE)
    stdout, stderr = process.communicate()
    stdout = stdout.decode("UTF-8")
    stderr = stderr.decode("UTF-8")
 
    # check response
    if stderr != "" or not ("Programming succeeded" in stdout):
        return False
 
    return True
 
 
"""-------------------------------------------------------------------"""

Start raveloxmidi in the background as a subprocess, to be able to communicate using RTPMIDI. Use the following command:

sudo raveloxmidi -c ./MIDI/address.conf

Don't forget to change the path of the configuration file, to a file, which contains the bind address: “0.0.0.0”.

network.bind_address = 0.0.0.0

""" This module contains the functions needed to send MIDI messages """
""" More information: 
            https://github.com/ravelox/pimidi/tree/master/python """
 
"""-------------------------------------------------------------------"""
""" GLOBAL """
"""-------------------------------------------------------------------"""
 
 
import sys  # interactions with the interpreter
import socket   # socket operations
import struct   # conversion between Python values and C type data
from subprocess import Popen, PIPE # system calls
from MIDI.message import *   # import all MIDI messages
 
sock = None
 
"""-------------------------------------------------------------------"""
""" INITIALIZATION """
"""-------------------------------------------------------------------"""
 
 
def open(configuration_file="./MIDI/address.conf", localport=5006):
    """
        start ravelomidi
 
        parameters: - configuration file path
                    - local port
    """
    # start raveloxmidi in the background
    Popen(["sudo", "raveloxmidi", "-c", configuration_file])
 
    global sock # load variable
 
    # local variables
    family = None
    connect_tuple = None
 
    # defining connection parameters
    # code snippet from the RaveloxMIDI examples
    if len(sys.argv) == 1:
        family = socket.AF_INET
        connect_tuple = ("localhost", localport)
    else:
        details = socket.getaddrinfo(
            sys.argv[1], localport, socket.AF_UNSPEC, socket.SOCK_DGRAM)
        family = details[0][0]
        if family == socket.AF_INET6:
            connect_tuple = (sys.argv[1], localport, 0, 0)
        else:
            connect_tuple = (sys.argv[1], localport)
 
    # connect socket
    sock = socket.socket(family, socket.SOCK_DGRAM)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    sock.connect(connect_tuple)
    return

While the background process is running, you can send data sockets containing MIDI data. An extensive list of possible MIDI messages is available on the page MIDI Specification and MIDI CC List for Continuous Controllers.

Open the drop-downs below for the most important MIDI messages.

MIDI Message Types

Message Type	Code	Meaning	Data Byte 1	Data Byte 2
NOTE_OFF	0x80	This message is sent when a note is stopped.	Note number	Velocity
NOTE_ON	0x90	This message is sent when a note is started.	Note number	Velocity
POLY_KEY_PRES	0xA0	Polyphonic Key Pressure (Aftertouch)	Note number	Pressure
CTRL_CHG	0xB0	Sent when a controller value changes.	Controller number	…
PRG_CHG	0xC0	Sent when a patch number changes.	Program number	-
CH_PRS_AFTT	0xD0	Channel Aftertouch	Pressure	-
PITCH_BND	0xE0	This message is sent to indicate a change in the pitch wheel.	LSB	MSB
SYS_EX_START	0xF0	This message makes up for all that MIDI doesn't support.	…	…

MIDI Notes

Note	Value
C	0
C#	1
D	2
D#	3
E	4
F	5
F#	6
G	7
G#	8
A	9
A#	10
B	11

MIDI Octaves

Notation	Value	Meaning
DBL_CONTRA_O	0	Starts with $C_{-1}$.
SUB_CONTRA_O	12	Starts with $C_{0}$.
CONTRA_O	24	Starts with $C_{1}$.
GREAT_O	36	Starts with $C_{2}$.
SMALL_O	48	Starts with $C_{3}$.
LINE1_O	60	Starts with $C_{4}$.
LINE2_O	72	Starts with $C_{5}$.
LINE3_O	84	Starts with $C_{6}$.
LINE4_O	96	Starts with $C_{7}$.
LINE5_O	108	Starts with $C_{8}$.
LINE6_O	120	Starts with $C_{9}$.

"""-------------------------------------------------------------------"""
""" SENDING """
"""-------------------------------------------------------------------"""
 
 
def send(msg_type, channel, data):
    """
        send a message
 
        parameters: - message type: from MIDI.message
                    - midi channel: 0-15
                    - data: from MIDI.message
    """
    # get data length
    length = len(data)
 
    # get message length
    byte_count = "B"
    for _ in range(length):
        byte_count = byte_count + "B"
 
    # construct the message
    # pack a binary structure with all the data words
    message = None
    if length == 1:
        message = struct.pack(byte_count, msg_type + channel, data[0])
    elif length == 2:
        message = struct.pack(byte_count, msg_type + channel, data[0], data[1])
    elif length == 3:
        message = struct.pack(byte_count, msg_type +
                              channel, data[0], data[1], data[2])
    elif length == 4:
        message = struct.pack(byte_count, msg_type + channel,
                              data[0], data[1], data[2], data[3])
    elif length == 5:
        message = struct.pack(byte_count, msg_type + channel,
                              data[0], data[1], data[2], data[3], data[4])
    elif length == 6:
        message = struct.pack(byte_count, msg_type + channel,
                              data[0], data[1], data[2], data[3], data[4], data[5])
    else:
        message = struct.pack(byte_count, msg_type + channel,
                              data[0], data[1], data[2], data[3], data[4], data[5], data[6])
 
    # send message
    sock.send(message)
    return

When you are finished, kill every process with the name “raveloxmidi” to terminate the connection.

"""-------------------------------------------------------------------"""
""" CLEANUP """
"""-------------------------------------------------------------------"""
 
 
def close():
    """
        stop ravelomidi
    """
    # close socket
    sock.close()
 
    # find remaining processes
    process = Popen(["sudo", "ps", "u"], stdout=PIPE, stderr=PIPE)
    stdout, _ = process.communicate()
    stdout = stdout.decode("UTF-8")
    processes = stdout.split("root")
    processes.pop(0)
    proc_id = []
    for index in range(len(processes)):
        processes[index] = processes[index].split()
        for property in processes[index]:
            if property == "raveloxmidi":
                proc_id.append(processes[index][0])
                continue
 
    # kill the processes
    success_flag = True
    for pid in proc_id:
        try:
            Popen(["sudo", "kill", "-SIGKILL", pid])
        except:
            success_flag = False
    return success_flag
 
 
"""-------------------------------------------------------------------"""

Copy the project containing the Python scripts on the Analog Discovery Pro 3450, with the help of a FAT32 formatted USB flash drive, or using WinSCP.

Navigate into the project directory, then run the script by typing

sudo python3 midi_controller.py

image

On your PC open the rtpMIDI program, then connect to the directory called “raveloxmidi”. The connection should appear in the participants tab.

Now you can use your wireless MIDI controller, to play any instrument you like - the limit is your imagination. You can expand the capabilities of your controller by adding extra digital and analog control elements, like sliders, more buttons, switches, etc.