Diff: BLEMIDI.cpp

Revision:

0:83889dc90473

Child:

1:cba2eba64f5c

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/BLEMIDI.cpp	Thu Apr 02 05:17:14 2015 +0000
@@ -0,0 +1,452 @@
+/* Copyright (c) 2014 mbed.org, MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+ * and associated documentation files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "mbed.h"
+#include "BLEMIDI.h"
+
+void BLEMIDI::onBleDisconnection(Gap::Handle_t handle, Gap::DisconnectionReason_t reason) {
+    device->startAdvertising();
+    isConnected = false;
+}
+
+void BLEMIDI::onBleConnection(Gap::Handle_t handle, Gap::addr_type_t type, const Gap::address_t addr, const Gap::ConnectionParams_t *params) {
+    isConnected = true;
+}
+
+void BLEMIDI::dataWrittenCallback(const GattCharacteristicWriteCBParams *params) {
+    // read characteristic and write serial
+    uint16_t length;
+    uint8_t rxBuffer[20];
+
+    device->readCharacteristicValue(midiCharacteristic->getValueAttribute().getHandle(), rxBuffer, &length);
+
+    if (length > 1) {
+        // parse BLE message
+        uint8_t header = rxBuffer[0];
+        for (int i = 1; i < length; i++) {
+            uint8_t midiEvent = rxBuffer[i];
+
+            if (midiState == MIDI_STATE_TIMESTAMP) {
+                if ((midiEvent & 0x80) == 0) {
+                    // running status
+                    midiState = MIDI_STATE_WAIT;
+                }
+
+                if (midiEvent == 0xf7) {
+                    // maybe error
+                    midiState = MIDI_STATE_TIMESTAMP;
+                    continue;
+                }
+            }
+            if (midiState == MIDI_STATE_TIMESTAMP) {
+                timestamp = ((header & 0x3f) << 7) | (midiEvent & 0x7f);
+                midiState = MIDI_STATE_WAIT;
+            } else if (midiState == MIDI_STATE_WAIT) {
+                switch (midiEvent & 0xf0) {
+                    case 0xf0: {
+                        switch (midiEvent) {
+                            case 0xf0:
+                                sysExBuffer[sysExBufferPos++] = midiEvent;
+                                midiState = MIDI_STATE_SIGNAL_SYSEX;
+                                break;
+
+                            case 0xf1:
+                            case 0xf3:
+                                // 0xf1 MIDI Time Code Quarter Frame. : 2bytes
+                                // 0xf3 Song Select. : 2bytes
+                                midiEventKind = midiEvent;
+                                midiState = MIDI_STATE_SIGNAL_2BYTES_2;
+                                break;
+
+                            case 0xf2:
+                                // 0xf2 Song Position Pointer. : 3bytes
+                                midiEventKind = midiEvent;
+                                midiState = MIDI_STATE_SIGNAL_3BYTES_2;
+                                break;
+
+                            case 0xf6:
+                                // 0xf6 Tune Request : 1byte
+                                onTuneRequest();
+                                midiState = MIDI_STATE_TIMESTAMP;
+                                break;
+                            case 0xf8:
+                                // 0xf8 Timing Clock : 1byte
+                                onTimingClock();
+                                midiState = MIDI_STATE_TIMESTAMP;
+                                break;
+                            case 0xfa:
+                                // 0xfa Start : 1byte
+                                onStart();
+                                midiState = MIDI_STATE_TIMESTAMP;
+                                break;
+                            case 0xfb:
+                                // 0xfb Continue : 1byte
+                                onContinue();
+                                midiState = MIDI_STATE_TIMESTAMP;
+                                break;
+                            case 0xfc:
+                                // 0xfc Stop : 1byte
+                                onStop();
+                                midiState = MIDI_STATE_TIMESTAMP;
+                                break;
+                            case 0xfe:
+                                // 0xfe Active Sensing : 1byte
+                                onActiveSensing();
+                                midiState = MIDI_STATE_TIMESTAMP;
+                                break;
+                            case 0xff:
+                                // 0xff Reset : 1byte
+                                onReset();
+                                midiState = MIDI_STATE_TIMESTAMP;
+                                break;
+
+                            default:
+                                break;
+                        }
+                    }
+                    break;
+                    case 0x80:
+                    case 0x90:
+                    case 0xa0:
+                    case 0xb0:
+                    case 0xe0:
+                        // 3bytes pattern
+                        midiEventKind = midiEvent;
+                        midiState = MIDI_STATE_SIGNAL_3BYTES_2;
+                        break;
+                    case 0xc0: // program change
+                    case 0xd0: // channel after-touch
+                        // 2bytes pattern
+                        midiEventKind = midiEvent;
+                        midiState = MIDI_STATE_SIGNAL_2BYTES_2;
+                        break;
+                    default:
+                        // 0x00 - 0x70: running status
+                        if ((midiEventKind & 0xf0) != 0xf0) {
+                            // previous event kind is multi-bytes pattern
+                            midiEventNote = midiEvent;
+                            midiState = MIDI_STATE_SIGNAL_3BYTES_3;
+                        }
+                        break;
+                }
+            } else if (midiState == MIDI_STATE_SIGNAL_2BYTES_2) {
+                switch (midiEventKind & 0xf0) {
+                    // 2bytes pattern
+                    case 0xc0: // program change
+                        midiEventNote = midiEvent;
+                        onProgramChange(midiEventKind & 0xf, midiEventNote);
+                        midiState = MIDI_STATE_TIMESTAMP;
+                        break;
+                    case 0xd0: // channel after-touch
+                        midiEventNote = midiEvent;
+                        onChannelAftertouch(midiEventKind & 0xf, midiEventNote);
+                        midiState = MIDI_STATE_TIMESTAMP;
+                        break;
+                    case 0xf0: {
+                        switch (midiEventKind) {
+                            case 0xf1:
+                                // 0xf1 MIDI Time Code Quarter Frame. : 2bytes
+                                midiEventNote = midiEvent;
+                                onTimeCodeQuarterFrame(midiEventNote);
+                                midiState = MIDI_STATE_TIMESTAMP;
+                                break;
+                            case 0xf3:
+                                // 0xf3 Song Select. : 2bytes
+                                midiEventNote = midiEvent;
+                                onSongSelect(midiEventNote);
+                                midiState = MIDI_STATE_TIMESTAMP;
+                                break;
+                            default:
+                                // illegal state
+                                midiState = MIDI_STATE_TIMESTAMP;
+                                break;
+                        }
+                    }
+                        break;
+                    default:
+                        // illegal state
+                        midiState = MIDI_STATE_TIMESTAMP;
+                        break;
+                }
+            } else if (midiState == MIDI_STATE_SIGNAL_3BYTES_2) {
+                switch (midiEventKind & 0xf0) {
+                    case 0x80:
+                    case 0x90:
+                    case 0xa0:
+                    case 0xb0:
+                    case 0xe0:
+                    case 0xf0:
+                        // 3bytes pattern
+                        midiEventNote = midiEvent;
+                        midiState = MIDI_STATE_SIGNAL_3BYTES_3;
+                        break;
+                    default:
+                        // illegal state
+                        midiState = MIDI_STATE_TIMESTAMP;
+                        break;
+                }
+            } else if (midiState == MIDI_STATE_SIGNAL_3BYTES_3) {
+                switch (midiEventKind & 0xf0) {
+                    // 3bytes pattern
+                    case 0x80: // note off
+                        midiEventVelocity = midiEvent;
+                        onNoteOff(midiEventKind & 0xf, midiEventNote, midiEventVelocity);
+                        midiState = MIDI_STATE_TIMESTAMP;
+                        break;
+                    case 0x90: // note on
+                        midiEventVelocity = midiEvent;
+                        if (midiEventVelocity == 0) {
+                            onNoteOff(midiEventKind & 0xf, midiEventNote, midiEventVelocity);
+                        } else {
+                            onNoteOn(midiEventKind & 0xf, midiEventNote, midiEventVelocity);
+                        }
+                        midiState = MIDI_STATE_TIMESTAMP;
+                        break;
+                    case 0xa0: // control polyphonic key pressure
+                        midiEventVelocity = midiEvent;
+                        onPolyphonicAftertouch(midiEventKind & 0xf, midiEventNote, midiEventVelocity);
+                        midiState = MIDI_STATE_TIMESTAMP;
+                        break;
+                    case 0xb0: // control change
+                        midiEventVelocity = midiEvent;
+                        onControlChange(midiEventKind & 0xf, midiEventNote, midiEventVelocity);
+                        midiState = MIDI_STATE_TIMESTAMP;
+                        break;
+                    case 0xe0: // pitch bend
+                        midiEventVelocity = midiEvent;
+                        onPitchWheel(midiEventKind & 0xf, (midiEventNote & 0x7f) | ((midiEventVelocity & 0x7f) << 7));
+                        midiState = MIDI_STATE_TIMESTAMP;
+                        break;
+                    case 0xf0: // Song Position Pointer.
+                        midiEventVelocity = midiEvent;
+                        onSongPositionPointer((midiEventNote & 0x7f) | ((midiEventVelocity & 0x7f) << 7));
+                        midiState = MIDI_STATE_TIMESTAMP;
+                        break;
+                    default:
+                        // illegal state
+                        midiState = MIDI_STATE_TIMESTAMP;
+                        break;
+                }
+            } else if (midiState == MIDI_STATE_SIGNAL_SYSEX) {
+                if (midiEvent == 0xf7) {
+                    // the end of message
+                    // last written uint8_t is for timestamp
+                    sysExBuffer[sysExBufferPos - 1] = midiEvent;
+                    onSystemExclusive(sysExBuffer, sysExBufferPos);
+
+                    sysExBufferPos = 0;
+                    midiState = MIDI_STATE_TIMESTAMP;
+                } else {
+                    sysExBuffer[sysExBufferPos++] = midiEvent;
+                }
+            }
+        }
+    }
+}
+
+BLEMIDI::BLEMIDI(BLEDevice *dev) {
+    device = dev;
+    isConnected = false;
+    sysExBufferPos = 0;
+
+    // Advertise packet length is 31 bytes.
+    // device name is upto 4 bytes if the service UUID included
+    const char DEVICE_NAME[] = "MIDI";
+
+    // MIDI characteristic
+    uint8_t midiPayload[20];
+    LongUUIDBytes_t characteristicUuid = {
+        0x77, 0x72, 0xe5, 0xdb, 0x38, 0x68, 0x41, 0x12, 
+        0xa1, 0xa9, 0xf2, 0x66, 0x9d, 0x10, 0x6b, 0xf3
+    };
+    GattCharacteristic midiChar(UUID(characteristicUuid), midiPayload, 0, 20, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY);
+    midiCharacteristic = &midiChar;
+
+    GattCharacteristic *midiChars[] = {midiCharacteristic};
+
+    // MIDI service
+    LongUUIDBytes_t serviceUuid = {
+        0x03, 0xb8, 0x0e, 0x5a, 0xed, 0xe8, 0x4b, 0x33, 
+        0xa7, 0x51, 0x6c, 0xe3, 0x4e, 0xc4, 0xc7, 0x00
+    };
+
+    GattService midiService(UUID(serviceUuid), midiChars, sizeof(midiChars) / sizeof(GattCharacteristic *));
+    uint8_t uuid128_list[] = {
+        0x00, 0xc7, 0xc4, 0x4e, 0xe3, 0x6c, 0x51, 0xa7,
+        0x33, 0x4b, 0xe8, 0xed, 0x5a, 0x0e, 0xb8, 0x03
+    };
+
+    device->init();
+    device->reset();
+    
+    /* setup callbacks */
+    device->onDataWritten(this, &BLEMIDI::dataWrittenCallback);
+
+    device->addService(midiService);
+
+    /* setup advertising */
+    device->accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_128BIT_SERVICE_IDS, (uint8_t*)uuid128_list, sizeof(uuid128_list));
+    device->accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE);
+    device->accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LOCAL_NAME, (uint8_t *)DEVICE_NAME, sizeof(DEVICE_NAME));
+
+    device->setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
+    device->setAdvertisingInterval(160); /* 100ms; in multiples of 0.625ms. */
+ 
+    device->startAdvertising();
+    tick.start();
+}
+
+bool BLEMIDI::connected() {
+    return isConnected;
+}
+
+void BLEMIDI::sendMidiMessage(uint8_t data0) {
+    if (isConnected) {
+        uint8_t midi[3];
+
+        unsigned int ticks = tick.read_ms() & 0x1fff;
+        midi[0] = 0x80 | (ticks >> 7) & 0x3f;
+        midi[1] = ticks & 0x7f;
+        midi[2] = data0;
+        
+        device->updateCharacteristicValue(midiCharacteristic->getValueAttribute().getHandle(), midi, 3);
+    }
+}
+
+void BLEMIDI::sendMidiMessage(uint8_t data0, uint8_t data1) {
+    if (isConnected) {
+        uint8_t midi[4];
+
+        unsigned int ticks = tick.read_ms() & 0x1fff;
+        midi[0] = 0x80 | (ticks >> 7) & 0x3f;
+        midi[1] = ticks & 0x7f;
+        midi[2] = data0;
+        midi[3] = data1;
+        
+        device->updateCharacteristicValue(midiCharacteristic->getValueAttribute().getHandle(), midi, 4);
+    }
+}
+
+void BLEMIDI::sendMidiMessage(uint8_t data0, uint8_t data1, uint8_t data2) {
+    if (isConnected) {
+        uint8_t midi[5];
+
+        unsigned int ticks = tick.read_ms() & 0x1fff;
+        midi[0] = 0x80 | (ticks >> 7) & 0x3f;
+        midi[1] = ticks & 0x7f;
+        midi[2] = data0;
+        midi[3] = data1;
+        midi[4] = data2;
+        
+        device->updateCharacteristicValue(midiCharacteristic->getValueAttribute().getHandle(), midi, 5);
+    }
+}
+
+void BLEMIDI::sendTuneRequest() {
+    sendMidiMessage(0xf6);
+}
+void BLEMIDI::sendTimingClock() {
+    sendMidiMessage(0xf8);
+}
+void BLEMIDI::sendStart() {
+    sendMidiMessage(0xfa);
+}
+void BLEMIDI::sendContinue() {
+    sendMidiMessage(0xfb);
+}
+void BLEMIDI::sendStop() {
+    sendMidiMessage(0xfc);
+}
+void BLEMIDI::sendActiveSensing() {
+    sendMidiMessage(0xfe);
+}
+void BLEMIDI::sendReset() {
+    sendMidiMessage(0xff);
+}
+void BLEMIDI::sendProgramChange(uint8_t channel, uint8_t program) {
+    sendMidiMessage(0xc0 | (channel & 0xf), program);
+}
+void BLEMIDI::sendChannelAftertouch(uint8_t channel, uint8_t pressure) {
+    sendMidiMessage(0xd0 | (channel & 0xf), pressure);
+}
+void BLEMIDI::sendTimeCodeQuarterFrame(uint8_t timing) {
+    sendMidiMessage(0xf1, timing & 0x7f);
+}
+void BLEMIDI::sendSongSelect(uint8_t song) {
+    sendMidiMessage(0xf3, song & 0x7f);
+}
+void BLEMIDI::sendNoteOff(uint8_t channel, uint8_t note, uint8_t velocity) {
+    sendMidiMessage(0x80 | (channel & 0xf), note, velocity);
+}
+void BLEMIDI::sendNoteOn(uint8_t channel, uint8_t note, uint8_t velocity) {
+    sendMidiMessage(0x90 | (channel & 0xf), note, velocity);
+}
+void BLEMIDI::sendPolyphonicAftertouch(uint8_t channel, uint8_t note, uint8_t pressure) {
+    sendMidiMessage(0xa0 | (channel & 0xf), note, pressure);
+}
+void BLEMIDI::sendControlChange(uint8_t channel, uint8_t function, uint8_t value) {
+    sendMidiMessage(0xb0 | (channel & 0xf), function, value);
+}
+void BLEMIDI::sendPitchWheel(uint8_t channel, uint16_t amount) {
+    sendMidiMessage(0xe0 | (channel & 0xf), amount & 0x7f, (amount >> 7) & 0x7f);
+}
+void BLEMIDI::sendSongPositionPointer(uint16_t position) {
+    sendMidiMessage(0xf2, position & 0x7f, (position >> 7) & 0x7f);
+}
+void BLEMIDI::sendSystemExclusive(uint8_t * sysex, uint16_t length) {
+    if (isConnected) {
+        uint8_t midi[20];
+        uint8_t position = 0;
+
+        // header
+        unsigned int ticks = tick.read_ms() & 0x1fff;
+        midi[position++] = 0x80 | (ticks >> 7) & 0x3f;
+        midi[position++] = ticks & 0x7f;
+
+        unsigned int timestamp = tick.read_ms() & 0x1fff;
+        for (int i = 0; i < length; i++) {
+            if (i == length - 1) {
+                // last byte
+                midi[position++] = ticks & 0x7f;
+
+                if (position == 20) {
+                    device->updateCharacteristicValue(midiCharacteristic->getValueAttribute().getHandle(), midi, 20);
+
+                    position = 0;
+                    // header
+                    midi[position++] = 0x80 | (ticks >> 7) & 0x3f;
+                }
+            }
+            midi[position++] = sysex[i];
+            if (position == 20) {
+                device->updateCharacteristicValue(midiCharacteristic->getValueAttribute().getHandle(), midi, 20);
+
+                position = 0;
+                // header
+                midi[position++] = 0x80 | (ticks >> 7) & 0x3f;
+            }
+
+            ticks = tick.read_ms() & 0x1fff;
+        }
+
+        if (position > 0) {
+            // send remains
+            device->updateCharacteristicValue(midiCharacteristic->getValueAttribute().getHandle(), midi, position);
+        }
+    }
+}