Support Materials
MPD16 Utility Software Manual
Utility Software, Drivers, and Manuals CD (came originally bundled with Akai MPD16)
Scan of Akai MPD16 CD label
Note: This original CD has manuals in multiple languages as well as the initial v1.0 drivers.
Pad Sensitivity Physical Modification Hack
This very simple hack involves little more than disassembling the MPD16 and putting thin layers of tape on the underside of each of the rubber pads so that they contact the pressure sensing sheet properly.
Factory Reset
Control Change, MIDI Channel, and key/note number assignments can be reset by holding FULL LEVEL and BANK while the Akai MPD16 is unplugged from both power and USB and continuing to hold them while connecting the MPD16 to either USB or DC 9V. Once the FULL LEVEL LED flashes for three seconds, the reset is complete.
Note: Pad sensitivity can never be set, reset, or otherwise cleared or adjusted without using the configuration software via USB connector. In other words, if a driver does not exist for your computer operating system then pad sensitivity will remain at its previous settings and can never be altered.
Integrated Circuit (IC) Information
Microchip 24LC01B, serial EEPROM — This can be read/written via I2C protocol, and likely stores pad configuration data such as key/note number, pad sensitivity, Control Change parameter, and MIDI Channel. These settings are retained in between power on/off events.
Unstable Drivers Fix (Blue Screen of Death, BSOD) Under Windows XP
It’s well-known how unstable the Akai MPD16 drivers can be under Windows XP. If the newest (v2.0) MPD16 drivers do not solve the crashing issue on a PC with Hyper-Threading support then go into BIOS setup and disable Hyper-Threading.
Driver Support (or lack thereof)
As Akai driver support is terrible for legacy products, there is no software support for anything past Windows XP. While the MPD16 can be powered via USB (or 9VDC) and the traditional MIDI OUT port can be connected to any MIDI device, pad sensitivity is inaccessible on a modern system. While pad assignment is possible from the MPD16 itself, this is time consuming and difficult without the bundled editor application which, again, cannot be used without proper drivers. Lastly, using the MPD16 over a USB virtual MIDI port is the only option on computers without a hardware MIDI interface and ties up otherwise available ports even on those that do have physical MIDI jacks.
There is no reason for this other than laziness and/or planned obsolescence on the part of Akai.
Note: Generic drivers are not a solution for this as the MPD16 is not class-compliant, so universal audio/MIDI drivers (such as Korg) will not work even if they are hacked to recognize the MPD16 hardware/vendor/product IDs.
In order to use the MPD16 via USB on a Windows Vista or later system, custom drivers will have to be created. Therefore…
Protocol Reverse Engineering
While a Windows XP virtual machine hosted through Linux is probably what most self-respecting technophiles would use to gather this information, SnoopyPro on a native Windows XP install works very well. In fact, SnoopyPro worked where other packages–including USBTracer, Wireshark+USBPcap, USBLyzer, and HHD USB Device Monitoring Studio–all failed.
Basic USB Info:
Hardware ID: Vendor 0x09e8, Product 0x0062
“AKAIpro MPD16 USB/MIDI PAD CONTROL UNIT”
Protocol Specs:
An output pipe in this context means host-to-device (computer –> MPD16) and an input pipe means device-to-host (MPD16 –> computer), so this is conceptually reversed in the sense that the physical MPD16 MIDI OUT jack would be visualized as an output while the USB pipe carrying the same note/velocity data is technically called an input (as viewed from the perspective of the host computer).
pipe 0x0 [endpoint 0] (control in/out, pack size 8) = All MIDI devices must have this, so there’s nothing of particular note here. The MPD16 identifies itself for proper configuration with the host over this connection.
pipe 0x1 [endpoint 1] (bulk output, packet size 64) = Config In (to MPD16 via USB) — configures pads, etc. via SysEx, probably
pipe 0x81 [endpoint 2] (bulk input, packet size 64) = Config Out (from MPD16 via USB) — sends current pad settings to control software via SysEx Events, probably
Communication is in the form of $1x (in other words, a hex value) where x is the length of the message. All observed strings are 9 bytes in length (therefore start with $19) and have SysEx Begin ($F0), Akai MIDI Vendor ID ($47), Model ID ($62, same as USB PID), an apparent constant of unknown significance ($60), four data bytes, and finally SysEx End ($F7).
The following is the beginning of an initialization routine between the MPD16 and its Utility software:
19 F0 47 62 60 10 01 7E 0F F7
19 F0 47 62 60 10 04 7F 13 F7
19 F0 47 62 60 10 04 00 14 F7
19 F0 47 62 60 15 01 00 16 F7
Note: It is currently unknown what these strings do with 100% certainty, but this is how the Akai MPD16 and the Editor Utility software talk to each other. It’s unclear why these are MIDI SysEx when the MPD16 has neither virtual, nor physical, MIDI IN ports.
The first bytes of the pseudo-SysEx strings should always remain the same (19 F0 47 62 60) and are followed with a “command” byte, two data bytes, a checksum of the previous three bytes, and always SysEx End ($F7).
The command bytes depend upon what setting is being changed or reported:
$10 – Selection (host sent)
$11 – Note Assignment (host sent)
$12 – Pad Sensitivity Assignment (host sent)
$13 – Control Change Assignment (host sent)
$14 – MIDI Channel Assignment (host sent)
$15 – Query (host sent; asks which note or sensitivity value is assigned to a given pad, plus others)
$20 – Note Reply (MPD16 sent; returns a pad’s note assignment in response to type $01 pad queries by host)
$21 – Sensitivity Reply (MPD16 sent; returns a pad’s sensitivity assignment in response to type $02 pad queries by host)
$22 – Reply to type $03 query, unknown (MPD16 sent; returns response to type $03 host query, Control Change maybe)
$23 – Reply to type $05 query, unknown (MPD16 sent; returns response to type $05 host query, MIDI Channel maybe)
SELECTION
19 F0 47 62 60 cm st bn cs F7
cm = selection command, probably — a constant of $10
st = selection type, probably — a constant of $04 when dealing with banks
bn = bank number/ID, probably — either $00 for Bank A, or $7F for Bank B, perhaps
cs = checksum which is the sum of previous three bytes, however this does not hold true for Bank B because SysEx values cannot exceed 127, so the checksum rolls over and becomes $13
Note: Selection commands aren’t necessarily bank related, so the following byte is not always $04. Bank A/B is an example of a specific type, and $01 is seemingly another type of unknown significance.
NOTE ASSIGNMENT
19 F0 47 62 60 cm pn nn cs F7
cm = note assignment command — a constant of $11
pn = pad number ($00~1F) — the pad number is offset by one (Pad 1 = $00, Pad 2 = $01 .. Pad 17 = $10, Pad 32 = $1F)
Note: Pads in Bank A are $00~0F, Bank B are $10~1F
nn = note number — the number in hex equating to a particular note at a given octave (A#-4, E-3, D-2, C#-4, etc.)
cs = a simple addition of previous three bytes, probably serving as a checksum
PAD SENSITIVITY ASSIGNMENT
19 F0 47 62 60 cm pn ss cs F7
cm = sensitivity command — a constant of $12
pn = pad number ($00~0F) — the pad number is offset by one (Pad 1 = $00, Pad 2 = $01 .. Pad 15 = $0E, Pad 16 = $0F)
ss = sensitivity ($00~10) — $00 is -8, $08 is 0, and $10 is +8, etc.
cs = a simple addition of previous three bytes, probably serving as a checksum
Note: Sensitivity has (somewhat oddly) 17 values, as it is not 00~0F as might be expected; -8 to +8 also includes 0, so that zero is truly a neutral/center value.
CONTROL CHANGE ASSIGNMENT
19 F0 47 62 60 cm 00 cc cs F7
cm = control change command — a constant of $13, followed by a null $00 as the first data byte is not needed
cc = control change number (range is 0~119 in decimal, but expressed as hex)
cs = checksum — as one byte is a null, really just cm+cc
MIDI CHANNEL ASSIGNMENT
19 F0 47 62 60 cm 00 mc cs F7
cm = MIDI channel command — a constant of $14, followed by a null $00 as the first data byte is not needed
mc = MIDI channel number — the MIDI channel is offset by one (Ch. 1 = $00, Ch. 2 = $01 .. Ch. 16 = $0F)
cs = checksum — as one byte is a null, really just cm+mc
pipe 0x2 [endpoint 3] (bulk output, packet size 64) = MIDI In (via USB) — N/A, probably (seems pointless for the MPD16 to ever receive standard MIDI events as there’s no MIDI THRU jack)
pipe 0x82 [endpoint 4] (bulk input, packet size 64) = MIDI Out from MPD16 — Note On, Velocity, Control Change (Slider) Events, and Key Aftertouch
pipe 0x82 sends out standard MIDI messages which are preceded by one byte which is in the form of $2x (in other words, a hex value) where x is the length of the message. $21 is a standard MIDI event with a one byte length, $23 is a standard MIDI event with a three byte length, etc.
As an example, the MPD16 constantly sends out an Active Sensing flag to declare to other MIDI devices that it is still alive. The actual MIDI event code for this is $FE. Since this is one byte being sent over pipe 0x82, it is preceded with $21; the total message being “$21 $FE” which is broadcast at regular intervals.
If the slider is used, “$23 $Bx $07 $yy” where $Bx is the MIDI Control Change byte (x is the MIDI channel the MPD16 is currently transmitting on), $07 signifies a Channel Volume event, and $yy is the current channel volume (a decimal value between 0-127, but expressed in hex).
If a pad is hit, “$23 $9x $yy $zz” where $9x is MIDI Note On (x is the MIDI channel the MPD16 is currently transmitting on), $yy is the Note/Key Number, and $zz is Note On Velocity
Note On ($9x, x = MIDI channel subtract 1)
Note/Key Number (0-127, but expressed in hex)
Note On Velocity (1-127, but expressed in hex)
QUERY
19 F0 47 62 60 cm qt pn cs F7
cm = pad query command — a constant of $15
qt = note query when type $01, sensitivity query when type $02, unknown $03, unknown $05
pn = pad number ($00~1F) — the pad number is offset by one (Pad 1 = $00, Pad 2 = $01 .. Pad 17 = $10, Pad 32 = $1F)
Note: A sensitivity query can only be $00~0F as there are 32 virtual pads, but only 16 physical pads.
cs = checksum of previous three bytes
NOTE REPLY
19 F0 47 62 60 cm pn nn cs F7
cm = note reply command — a constant of $20
pn = pad number ($00~1F) — the pad number is offset by one (Pad 1 = $00, Pad 2 = $01 .. Pad 17 = $10, Pad 32 = $1F)
nn = note number — the number in hex equating to a particular note at a given octave (A#-4, E-3, D-2, C#-4, etc.)
cs = checksum of previous three bytes
SENSITIVITY REPLY
19 F0 47 62 60 cm pn nn cs F7
cm = sensitivity reply command — a constant of $21
pn = pad number ($00~0F) — the pad number is offset by one (Pad 1 = $00, Pad 2 = $01 .. Pad 15 = $0E, Pad 16 = $0F)
sn = sensitivity number ($00~10) -8 to +8, with 0 being the center value — 17 values
cs = checksum of previous three bytes
