Update CustomBaudRate.ino

override DefaultSerialSettings to override BaudRate (and not DefaultSettings )

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,66 @@
+---
+name: Bug report
+about: Report something that does not work as intended
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+<!-- 
+Before opening an issue, check if your problem already has been solved by looking in:
+- The existing issues: https://github.com/FortySevenEffects/arduino_midi_library/issues
+- The discussions: https://github.com/FortySevenEffects/arduino_midi_library/discussions
+
+Consider opening a discussion instead of an issue if you need help with your project:
+https://github.com/FortySevenEffects/arduino_midi_library/discussions/new
+-->
+
+## Context
+
+Please answer a few questions to help us understand your problem better and guide you to a solution:
+
+<!-- Tip: place the letter x in the checkboxes to tick them:
+- [ ] Unticked checkbox
+- [x] Ticked checkbox
+
+You can also tick them by clicking after you've submitted your issue.
+ -->
+
+- What board are you using ?
+    - `example: Arduino Leonardo`
+    - _Please list any shields or other **relevant** hardware you're using_
+- What version of the Arduino IDE are you using ?
+    - `example: 1.8.5`
+- How are you using MIDI ?
+    - [ ]  Hardware Serial (DIN plugs)
+    - [ ]  USB
+    - [ ]  Other (please specify)
+- Is your problem related to:
+    - [ ]  MIDI Input (reading messages from other devices)
+    - [ ]  MIDI Output (sending messages to other devices)
+- How comfortable are you with code ?
+    - [ ]  Complete beginner
+    - [ ]  I've done basic projects
+    - [ ]  I know my way around C/C++
+    - [ ]  Advanced / professional
+
+## Describe your project and what you expect to happen:
+
+<!--
+Example: When I press a switch on my pedalboard, it sends a SysEx message that I'd like to receive on my Arduino.
+
+Note: Attachments (circuit diagrams, code examples) are most welcome and will help us understand your needs better and find a suitable solution for your issue.
+-->
+
+## Describe your problem (what does not work):
+
+<!-- 
+Example: I cannot receive SysEx messages coming from my AxeFX 2
+-->
+
+## Steps to reproduce
+
+<!--
+Please list the steps you took to hit the problem, so we can try and reproduce it.
+-->

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Discussions
+    url: https://github.com/FortySevenEffects/arduino_midi_library/discussions
+    about: Not a bug or a feature request ? Discuss your problem, ask for help or show what you've built in Discussions.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: new feature
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/workflows/cmake.yml

@@ -0,0 +1,59 @@
+name: CMake
+
+on:
+  push:
+  pull_request:
+    branches: [ master ]
+
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: Debug
+  GENERATE_COVERAGE: true
+  LCOV_ROOT: ${{github.workspace}}/lcov
+
+jobs:
+  build:
+    # The CMake configure and build commands are platform agnostic and should work equally
+    # well on Windows or Mac.  You can convert this to a matrix build if you need
+    # cross-platform coverage.
+    # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: recursive
+
+    - name: Install lcov
+      run: |
+        mkdir -p "$LCOV_ROOT"
+        wget https://github.com/linux-test-project/lcov/releases/download/v1.15/lcov-1.15.tar.gz --output-document="$LCOV_ROOT/lcov.tar.gz"
+        tar -xf "$LCOV_ROOT/lcov.tar.gz" --strip-components=1 -C "$LCOV_ROOT"
+        echo "$LCOV_ROOT/bin" >> $GITHUB_PATH
+      shell: bash
+
+    - name: Configure CMake
+      # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
+      # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
+      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DBUILDER_ENABLE_PROFILING=true
+
+    - name: Build
+      # Build your program with the given configuration
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+
+    - name: Run Unit Tests
+      working-directory: ${{github.workspace}}/build
+      run: ctest --verbose
+
+    - name: Generate code coverage report
+      working-directory: ${{github.workspace}}/build
+      run: |
+        lcov --directory . --capture --output-file coverage.info
+        lcov --remove coverage.info '/usr/*' "${{github.workspace}}/test/*" "${{github.workspace}}/external/*" --output-file coverage.info
+        lcov --list coverage.info
+
+    - uses: coverallsapp/github-action@9ba913c152ae4be1327bfb9085dc806cedb44057
+      name: Upload code coverage report to Coveralls
+      with:
+        path-to-lcov: ${{github.workspace}}/build/coverage.info
+        github-token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/platformio.yml

@@ -0,0 +1,62 @@
+name: PlatformIO
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  platformio:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        example:
+          - AltPinSerial
+          - Basic_IO
+          - Bench
+          - Callbacks
+          - Chaining
+          - DualMerger
+          - ErrorCallback
+          - Input
+          - RPN_NRPN
+          - SimpleSynth
+          - CustomBaudRate
+        board:
+          - uno
+          - due
+          - zero
+          - leonardo
+          - micro
+          - nanoatmega328
+          - megaatmega2560
+          - teensy2
+          - teensy30
+          - teensy31
+          - teensylc
+    steps:
+    - uses: actions/checkout@v2
+    - name: Cache pip
+      uses: actions/cache@v2
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
+        restore-keys: ${{ runner.os }}-pip-
+    - name: Cache PlatformIO
+      uses: actions/cache@v2
+      with:
+        path: ~/.platformio
+        key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
+    - name: Set up Python
+      uses: actions/setup-python@v2
+    - name: Install PlatformIO
+      run: |
+        python -m pip install --upgrade pip
+        pip install --upgrade platformio
+        pip install "click!=8.0.2" # See platformio/platformio-core#4078
+    - name: Run PlatformIO
+      run: pio ci --lib="." --board="${{matrix.board}}"
+      env:
+        PLATFORMIO_CI_SRC: examples/${{ matrix.example }}

.travis.yml

@@ -1,104 +0,0 @@
-# Kudos to these guys:
-# https://github.com/Return-To-The-Roots/s25client/blob/master/.travis.yml
-# http://docs.platformio.org/en/stable/ci/travis.html
-
-sudo: false
-language: python
-
-os:
-    - linux
-
-python:
-    - "2.7"
-
-# Cache PlatformIO packages using Travis CI container-based infrastructure
-cache:
-    directories:
-        - "~/.platformio"
-
-env:
-    global:
-        - BUILD_TYPE=Debug
-    matrix:
-        - BUILD_UNIT_TESTS=1
-        - PLATFORMIO_CI_SRC=examples/Basic_IO
-        - PLATFORMIO_CI_SRC=examples/Bench
-        - PLATFORMIO_CI_SRC=examples/Callbacks
-        - PLATFORMIO_CI_SRC=examples/DualMerger
-        - PLATFORMIO_CI_SRC=examples/ErrorCallback
-        - PLATFORMIO_CI_SRC=examples/Input
-        - PLATFORMIO_CI_SRC=examples/RPN_NRPN
-        - PLATFORMIO_CI_SRC=examples/SimpleSynth
-        - PLATFORMIO_CI_SRC=examples/AltPinSerial
-
-addons:
-    apt:
-        sources:
-            - ubuntu-toolchain-r-test
-        packages:
-            - g++-4.8
-            - cmake
-
-install:
-    - |
-        if [ "${BUILD_UNIT_TESTS}" ]; then
-            # GCov 4.6 cannot handle the file structure
-            export CXX="g++-4.8"
-            export GCOV="gcov-4.8"
-
-            # Install newer lcov (1.9 seems to fail: http://gronlier.fr/blog/2015/01/adding-code-coverage-to-your-c-project/)
-            export LCOV_ROOT="$HOME/lcov"
-            mkdir -p "$LCOV_ROOT"
-            wget http://ftp.de.debian.org/debian/pool/main/l/lcov/lcov_1.14.orig.tar.gz --output-document="$LCOV_ROOT/lcov.tar.gz"
-            tar xf "$LCOV_ROOT/lcov.tar.gz" --strip-components=1 -C $LCOV_ROOT
-            export PATH="$LCOV_ROOT/bin:$PATH"
-            which lcov
-
-            # Install coveralls tool
-            gem install coveralls-lcov
-            export GENERATE_COVERAGE=1
-        else
-            # Install PlatformIO
-            pip install -U platformio
-        fi
-
-script:
-    # Build unit tests & generate code coverage
-    - |
-        if [ "${BUILD_UNIT_TESTS}" ]; then
-            mkdir build && cd build
-            cmake -DCMAKE_CXX_COMPILER=$COMPILER -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DBUILDER_ENABLE_PROFILING=${GENERATE_COVERAGE} --generator="Unix Makefiles" ..
-            make all
-            ctest --verbose
-        fi
-
-    # Build current example
-    - |
-        if [ ! "${BUILD_UNIT_TESTS}" ]; then
-            platformio ci --lib="."       \
-                --board="uno"             \
-                --board="due"             \
-                --board="zero"            \
-                --board="leonardo"        \
-                --board="micro"           \
-                --board="nanoatmega328"   \
-                --board="megaatmega2560"  \
-                --board="teensy2"         \
-                --board="teensy30"        \
-                --board="teensy31"        \
-                --board="teensylc"
-        fi
-
-after_success:
-    - |
-        if [ "${GENERATE_COVERAGE}" ]; then
-            # Generate code coverage information & send to Coveralls
-            rm -rf ./external/google-test/googletest/CMakeFiles/gtest.dir/src/gtest-all.cc.gcda
-            lcov --gcov-tool $GCOV --directory . --capture --output-file coverage.info
-            lcov --gcov-tool $GCOV --remove coverage.info 'test/*' '/usr/*' 'external/*' --output-file coverage.info
-            lcov --list coverage.info
-            coveralls-lcov --repo-token ${COVERALLS_TOKEN} coverage.info
-        fi
-
-notifications:
-    email: false

.vscode/settings.json

@@ -8,6 +8,7 @@
         "string": "cpp",
         "string_view": "cpp",
         "vector": "cpp",
-        "istream": "cpp"
+        "istream": "cpp",
+        "system_error": "cpp"
     }
 }

README.md

@@ -1,9 +1,10 @@
 # Arduino MIDI Library
 
-[![Build Status](https://travis-ci.org/FortySevenEffects/arduino_midi_library.svg?branch=master)](https://travis-ci.org/FortySevenEffects/arduino_midi_library)
-[![Coveralls](https://img.shields.io/coveralls/FortySevenEffects/arduino_midi_library.svg?maxAge=3600)](https://coveralls.io/github/FortySevenEffects/arduino_midi_library)
 [![GitHub release](https://img.shields.io/github/release/FortySevenEffects/arduino_midi_library.svg?maxAge=3600)](https://github.com/FortySevenEffects/arduino_midi_library/releases/latest)
 [![License](https://img.shields.io/github/license/FortySevenEffects/arduino_midi_library.svg?maxAge=3600)](LICENSE)
+[![Build](https://github.com/FortySevenEffects/arduino_midi_library/actions/workflows/cmake.yml/badge.svg?branch=master)](https://github.com/FortySevenEffects/arduino_midi_library/actions/workflows/cmake.yml)
+[![Examples](https://github.com/FortySevenEffects/arduino_midi_library/actions/workflows/platformio.yml/badge.svg?branch=master)](https://github.com/FortySevenEffects/arduino_midi_library/actions/workflows/platformio.yml)
+[![Coveralls](https://img.shields.io/coveralls/FortySevenEffects/arduino_midi_library.svg?maxAge=3600)](https://coveralls.io/github/FortySevenEffects/arduino_midi_library)
 
 This library adds MIDI I/O communications to an Arduino board.
 
@@ -24,7 +25,7 @@ This library adds MIDI I/O communications to an Arduino board.
 ### Getting Started
 
 1. Use the Arduino Library Manager to install the library.
-   ![Type "MIDI" in the Arduino IDE Library Manager](res/library-manager.jpg)
+   ![Type "MIDI I/Os for Arduino" in the Arduino IDE Library Manager](res/library-manager.png)
 
 2. Start coding:
 
@@ -111,9 +112,9 @@ protocol bridges.
 
 -   Software Thru is enabled by default on Serial, but not on other transports.
 
-## Contact
+## Contact & Contribution
 
-To report a bug, contribute, discuss on usage, or simply request support, please [create an issue here](https://github.com/FortySevenEffects/arduino_midi_library/issues/new).
+To report a bug, contribute, discuss on usage, or request support, please [discuss it here](https://github.com/FortySevenEffects/arduino_midi_library/discussions/new).
 
 You can also contact me on Twitter: [@fortysevenfx](https://twitter.com/fortysevenfx).
 
@@ -129,6 +130,10 @@ Special thanks to all who have contributed to this open-source project !
 -   [@per1234](https://github.com/per1234)
 -   [@LnnrtS](https://github.com/LnnrtS)
 -   [@DavidMenting](https://github.com/DavidMenting)
+-   [@Rolel](https://github.com/Rolel)
+-   [@kant](https://github.com/kant)
+-   [@paul-emile-element](https://github.com/paul-emile-element)
+-   [@muxa](https://github.com/muxa)
 
 You want to help ? Check out the [contribution guidelines](./CONTRIBUTING.md).
 

doc/Doxyfile

@@ -38,7 +38,7 @@ PROJECT_NAME           = "Arduino MIDI Library"
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = "Version 5.0.1"
+PROJECT_NUMBER         = "Version 5.0.2"
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

doc/midi_DoxygenMainPage.h

@@ -12,7 +12,7 @@
 // Examples
 
 /*!
- \example MIDI_Basic_IO.ino
+ \example Basic_IO.ino
  This example shows how to perform simple input and output MIDI. \n
  \n
  When any message arrives to the Arduino, the LED is turned on,
@@ -29,15 +29,15 @@
  */
 
 /*!
- \example MIDI_Callbacks.ino
+ \example Callbacks.ino
  This example shows how to use callbacks for easier MIDI input handling. \n
  */
 
 /*!
- \example MIDI_Bench.ino
- \example MIDI_DualMerger.ino
- \example MIDI_Input.ino
- \example MIDI_SimpleSynth.ino
+ \example Bench.ino
+ \example DualMerger.ino
+ \example Input.ino
+ \example SimpleSynth.ino
  */
 
 // -----------------------------------------------------------------------------

doc/sysex-codec.md

@@ -62,7 +62,7 @@ becomes:
 ```
 
 The order of the bits in the "header" byte is reversed.
-To follow this beheaviour, set the inFlipHeaderBits argument to true.
+To follow this behaviour, set the inFlipHeaderBits argument to true.
 
 Example:
 ```c++

examples/AltPinSerial/AltPinSerial.ino

@@ -5,7 +5,7 @@
 // Here, when receiving any message on channel 4, the Arduino
 // will blink a led and play back a note for 1 second.
 
-#if defined(ARDUINO_SAM_DUE) || defined(SAMD_SERIES)
+#if defined(ARDUINO_SAM_DUE) || defined(SAMD_SERIES) || defined(_VARIANT_ARDUINO_ZERO_)
    /* example not relevant for this hardware (SoftwareSerial not supported) */
    MIDI_CREATE_DEFAULT_INSTANCE();
 #else

examples/Chaining/Chaining.ino

@@ -0,0 +1,37 @@
+#include <MIDI.h>
+
+MIDI_CREATE_DEFAULT_INSTANCE();
+
+void setup()
+{
+    pinMode(2, INPUT);
+    
+    MIDI // chaining MIDI commands - order is from top to bottom (turnThruOff,... begin)
+        .turnThruOff()
+        // using a lamdba function for this callbacks
+        .setHandleNoteOn([](byte channel, byte note, byte velocity)
+            {
+                // Do whatever you want when a note is pressed.
+
+                // Try to keep your callbacks short (no delays ect)
+                // otherwise it would slow down the loop() and have a bad impact
+                // on real-time performance.
+            })
+        .setHandleNoteOff([](byte channel, byte note, byte velocity)
+            {
+                // Do something when the note is released.
+                // Note that NoteOn messages with 0 velocity are interpreted as NoteOffs.
+            })
+        .begin(MIDI_CHANNEL_OMNI); // Initiate MIDI communications, listen to all channels
+}
+
+void loop()
+{
+    // Call MIDI.read the fastest you can for real-time performance.
+    MIDI.read();
+
+    if (digitalRead(2))
+        MIDI // chained sendNoteOn commands
+            .sendNoteOn(42, 127, 1)
+            .sendNoteOn(40, 54, 1);
+}

examples/CustomBaudRate/CustomBaudRate.ino

@@ -0,0 +1,32 @@
+#include <MIDI.h>
+
+// Override the default MIDI baudrate to
+// a decoding program such as Hairless MIDI (set baudrate to 115200)
+struct CustomBaudRateSettings : public MIDI_NAMESPACE::DefaultSerialSettings {
+  static const long BaudRate = 115200;
+};
+
+#if defined(ARDUINO_SAM_DUE) || defined(USBCON) || defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MKL26Z64__)
+    // Leonardo, Due and other USB boards use Serial1 by default.
+    MIDI_NAMESPACE::SerialMIDI<HardwareSerial, CustomBaudRateSettings> serialMIDI(Serial1);
+    MIDI_NAMESPACE::MidiInterface<MIDI_NAMESPACE::SerialMIDI<HardwareSerial, CustomBaudRateSettings>> MIDI((MIDI_NAMESPACE::SerialMIDI<HardwareSerial, CustomBaudRateSettings>&)serialMIDI);
+#else
+    MIDI_NAMESPACE::SerialMIDI<HardwareSerial, CustomBaudRateSettings> serialMIDI(Serial);
+    MIDI_NAMESPACE::MidiInterface<MIDI_NAMESPACE::SerialMIDI<HardwareSerial, CustomBaudRateSettings>> MIDI((MIDI_NAMESPACE::SerialMIDI<HardwareSerial, CustomBaudRateSettings>&)serialMIDI);
+#endif
+
+void setup() {
+  pinMode(LED_BUILTIN, OUTPUT);
+  MIDI.begin(MIDI_CHANNEL_OMNI);
+}
+
+void loop() {
+  if (MIDI.read())                    // If we have received a message
+  {
+    digitalWrite(LED_BUILTIN, HIGH);
+    MIDI.sendNoteOn(42, 127, 1);    // Send a Note (pitch 42, velo 127 on channel 1)
+    delay(1000);                // Wait for a second
+    MIDI.sendNoteOff(42, 0, 1);     // Stop the note
+    digitalWrite(LED_BUILTIN, LOW);
+  }
+}

keywords.txt

@@ -146,7 +146,18 @@ GeneralPurposeController1	LITERAL1
 GeneralPurposeController2	LITERAL1
 GeneralPurposeController3	LITERAL1
 GeneralPurposeController4	LITERAL1
+BankSelectLSB	LITERAL1
+ModulationWheelLSB	LITERAL1
+BreathControllerLSB	LITERAL1
+FootControllerLSB	LITERAL1
+PortamentoTimeLSB	LITERAL1
 DataEntryLSB	LITERAL1
+ChannelVolumeLSB	LITERAL1
+BalanceLSB	LITERAL1
+PanLSB	LITERAL1
+ExpressionControllerLSB	LITERAL1
+EffectControl1LSB	LITERAL1
+EffectControl2LSB	LITERAL1
 Sustain	LITERAL1
 Portamento	LITERAL1
 Sostenuto	LITERAL1

library.json

@@ -1,6 +1,6 @@
 {
     "name": "MIDI Library",
-    "version": "5.0.1",
+    "version": "5.0.2",
     "keywords": "midi",
     "description": "Enables MIDI I/O communications on the Arduino serial ports",
     "license": "MIT",

library.properties

@@ -1,5 +1,5 @@
 name=MIDI Library
-version=5.0.1
+version=5.0.2
 author=Francois Best, lathoub
 maintainer=Francois Best <contact@francoisbest.com>
 sentence=MIDI I/Os for Arduino

src/MIDI.h

@@ -62,94 +62,94 @@ public:
     inline ~MidiInterface();
 
 public:
-    void begin(Channel inChannel = 1);
+    MidiInterface& begin(Channel inChannel = 1);
 
     // -------------------------------------------------------------------------
     // MIDI Output
 
 public:
-    inline void sendNoteOn(DataByte inNoteNumber,
+    inline MidiInterface& sendNoteOn(DataByte inNoteNumber,
                            DataByte inVelocity,
                            Channel inChannel);
 
-    inline void sendNoteOff(DataByte inNoteNumber,
+    inline MidiInterface& sendNoteOff(DataByte inNoteNumber,
                             DataByte inVelocity,
                             Channel inChannel);
 
-    inline void sendProgramChange(DataByte inProgramNumber,
+    inline MidiInterface& sendProgramChange(DataByte inProgramNumber,
                                   Channel inChannel);
 
-    inline void sendControlChange(DataByte inControlNumber,
+    inline MidiInterface& sendControlChange(DataByte inControlNumber,
                                   DataByte inControlValue,
                                   Channel inChannel);
 
-    inline void sendPitchBend(int inPitchValue,    Channel inChannel);
-    inline void sendPitchBend(double inPitchValue, Channel inChannel);
+    inline MidiInterface& sendPitchBend(int inPitchValue,    Channel inChannel);
+    inline MidiInterface& sendPitchBend(double inPitchValue, Channel inChannel);
 
-    inline void sendPolyPressure(DataByte inNoteNumber,
+    inline MidiInterface& sendPolyPressure(DataByte inNoteNumber,
                                  DataByte inPressure,
                                  Channel inChannel) __attribute__ ((deprecated));
 
-    inline void sendAfterTouch(DataByte inPressure,
+    inline MidiInterface& sendAfterTouch(DataByte inPressure,
                                Channel inChannel);
-    inline void sendAfterTouch(DataByte inNoteNumber,
+    inline MidiInterface& sendAfterTouch(DataByte inNoteNumber,
                                DataByte inPressure,
                                Channel inChannel);
 
-    inline void sendSysEx(unsigned inLength,
+    inline MidiInterface& sendSysEx(unsigned inLength,
                           const byte* inArray,
                           bool inArrayContainsBoundaries = false);
 
-    inline void sendTimeCodeQuarterFrame(DataByte inTypeNibble,
+    inline MidiInterface& sendTimeCodeQuarterFrame(DataByte inTypeNibble,
                                          DataByte inValuesNibble);
-    inline void sendTimeCodeQuarterFrame(DataByte inData);
+    inline MidiInterface& sendTimeCodeQuarterFrame(DataByte inData);
 
-    inline void sendSongPosition(unsigned inBeats);
-    inline void sendSongSelect(DataByte inSongNumber);
-    inline void sendTuneRequest();
+    inline MidiInterface& sendSongPosition(unsigned inBeats);
+    inline MidiInterface& sendSongSelect(DataByte inSongNumber);
+    inline MidiInterface& sendTuneRequest();
 
-    inline void sendCommon(MidiType inType, unsigned = 0);
+    inline MidiInterface& sendCommon(MidiType inType, unsigned = 0);
 
-    inline void sendClock()         { sendRealTime(Clock); };
-    inline void sendStart()         { sendRealTime(Start); };
-    inline void sendStop()          { sendRealTime(Stop);  };
-    inline void sendTick()          { sendRealTime(Tick);  };
-    inline void sendContinue()      { sendRealTime(Continue);  };
-    inline void sendActiveSensing() { sendRealTime(ActiveSensing);  };
-    inline void sendSystemReset()   { sendRealTime(SystemReset);  };
+    inline MidiInterface& sendClock()         { return sendRealTime(Clock); };
+    inline MidiInterface& sendStart()         { return sendRealTime(Start); };
+    inline MidiInterface& sendStop()          { return sendRealTime(Stop);  };
+    inline MidiInterface& sendTick()          { return sendRealTime(Tick);  };
+    inline MidiInterface& sendContinue()      { return sendRealTime(Continue);  };
+    inline MidiInterface& sendActiveSensing() { return sendRealTime(ActiveSensing);  };
+    inline MidiInterface& sendSystemReset()   { return sendRealTime(SystemReset);  };
 
-    inline void sendRealTime(MidiType inType);
+    inline MidiInterface& sendRealTime(MidiType inType);
 
-    inline void beginRpn(unsigned inNumber,
+    inline MidiInterface& beginRpn(unsigned inNumber,
                          Channel inChannel);
-    inline void sendRpnValue(unsigned inValue,
+    inline MidiInterface& sendRpnValue(unsigned inValue,
                              Channel inChannel);
-    inline void sendRpnValue(byte inMsb,
+    inline MidiInterface& sendRpnValue(byte inMsb,
                              byte inLsb,
                              Channel inChannel);
-    inline void sendRpnIncrement(byte inAmount,
+    inline MidiInterface& sendRpnIncrement(byte inAmount,
                                  Channel inChannel);
-    inline void sendRpnDecrement(byte inAmount,
+    inline MidiInterface& sendRpnDecrement(byte inAmount,
                                  Channel inChannel);
-    inline void endRpn(Channel inChannel);
+    inline MidiInterface& endRpn(Channel inChannel);
 
-    inline void beginNrpn(unsigned inNumber,
+    inline MidiInterface& beginNrpn(unsigned inNumber,
                           Channel inChannel);
-    inline void sendNrpnValue(unsigned inValue,
+    inline MidiInterface& sendNrpnValue(unsigned inValue,
                               Channel inChannel);
-    inline void sendNrpnValue(byte inMsb,
+    inline MidiInterface& sendNrpnValue(byte inMsb,
                               byte inLsb,
                               Channel inChannel);
-    inline void sendNrpnIncrement(byte inAmount,
+    inline MidiInterface& sendNrpnIncrement(byte inAmount,
                                   Channel inChannel);
-    inline void sendNrpnDecrement(byte inAmount,
+    inline MidiInterface& sendNrpnDecrement(byte inAmount,
                                   Channel inChannel);
-    inline void endNrpn(Channel inChannel);
+    inline MidiInterface& endNrpn(Channel inChannel);
 
-    inline void send(const MidiMessage&);
+    inline MidiInterface& send(const MidiMessage&);
 
 public:
-    void send(MidiType inType,
+    MidiInterface& send(MidiType inType,
               DataByte inData1,
               DataByte inData2,
               Channel inChannel);
@@ -172,7 +172,7 @@ public:
 
 public:
     inline Channel getInputChannel() const;
-    inline void setInputChannel(Channel inChannel);
+    inline MidiInterface& setInputChannel(Channel inChannel);
 
 public:
     static inline MidiType getTypeFromStatusByte(byte inStatus);
@@ -183,29 +183,29 @@ public:
     // Input Callbacks
 
 public:
-    inline void setHandleMessage(void (*fptr)(const MidiMessage&)) { mMessageCallback = fptr; };
-    inline void setHandleError(ErrorCallback fptr) { mErrorCallback = fptr; }
-    inline void setHandleNoteOff(NoteOffCallback fptr) { mNoteOffCallback = fptr; }
-    inline void setHandleNoteOn(NoteOnCallback fptr) { mNoteOnCallback = fptr; }
-    inline void setHandleAfterTouchPoly(AfterTouchPolyCallback fptr) { mAfterTouchPolyCallback = fptr; }
-    inline void setHandleControlChange(ControlChangeCallback fptr) { mControlChangeCallback = fptr; }
-    inline void setHandleProgramChange(ProgramChangeCallback fptr) { mProgramChangeCallback = fptr; }
-    inline void setHandleAfterTouchChannel(AfterTouchChannelCallback fptr) { mAfterTouchChannelCallback = fptr; }
-    inline void setHandlePitchBend(PitchBendCallback fptr) { mPitchBendCallback = fptr; }
-    inline void setHandleSystemExclusive(SystemExclusiveCallback fptr) { mSystemExclusiveCallback = fptr; }
-    inline void setHandleTimeCodeQuarterFrame(TimeCodeQuarterFrameCallback fptr) { mTimeCodeQuarterFrameCallback = fptr; }
-    inline void setHandleSongPosition(SongPositionCallback fptr) { mSongPositionCallback = fptr; }
-    inline void setHandleSongSelect(SongSelectCallback fptr) { mSongSelectCallback = fptr; }
-    inline void setHandleTuneRequest(TuneRequestCallback fptr) { mTuneRequestCallback = fptr; }
-    inline void setHandleClock(ClockCallback fptr) { mClockCallback = fptr; }
-    inline void setHandleStart(StartCallback fptr) { mStartCallback = fptr; }
-    inline void setHandleTick(TickCallback fptr) { mTickCallback = fptr; }
-    inline void setHandleContinue(ContinueCallback fptr) { mContinueCallback = fptr; }
-    inline void setHandleStop(StopCallback fptr) { mStopCallback = fptr; }
-    inline void setHandleActiveSensing(ActiveSensingCallback fptr) { mActiveSensingCallback = fptr; }
-    inline void setHandleSystemReset(SystemResetCallback fptr) { mSystemResetCallback = fptr; }
+    inline MidiInterface& setHandleMessage(void (*fptr)(const MidiMessage&)) { mMessageCallback = fptr; return *this; };
+    inline MidiInterface& setHandleError(ErrorCallback fptr) { mErrorCallback = fptr; return *this; };
+    inline MidiInterface& setHandleNoteOff(NoteOffCallback fptr) { mNoteOffCallback = fptr; return *this; };
+    inline MidiInterface& setHandleNoteOn(NoteOnCallback fptr) { mNoteOnCallback = fptr; return *this; };
+    inline MidiInterface& setHandleAfterTouchPoly(AfterTouchPolyCallback fptr) { mAfterTouchPolyCallback = fptr; return *this; };
+    inline MidiInterface& setHandleControlChange(ControlChangeCallback fptr) { mControlChangeCallback = fptr; return *this; };
+    inline MidiInterface& setHandleProgramChange(ProgramChangeCallback fptr) { mProgramChangeCallback = fptr; return *this; };
+    inline MidiInterface& setHandleAfterTouchChannel(AfterTouchChannelCallback fptr) { mAfterTouchChannelCallback = fptr; return *this; };
+    inline MidiInterface& setHandlePitchBend(PitchBendCallback fptr) { mPitchBendCallback = fptr; return *this; };
+    inline MidiInterface& setHandleSystemExclusive(SystemExclusiveCallback fptr) { mSystemExclusiveCallback = fptr; return *this; };
+    inline MidiInterface& setHandleTimeCodeQuarterFrame(TimeCodeQuarterFrameCallback fptr) { mTimeCodeQuarterFrameCallback = fptr; return *this; };
+    inline MidiInterface& setHandleSongPosition(SongPositionCallback fptr) { mSongPositionCallback = fptr; return *this; };
+    inline MidiInterface& setHandleSongSelect(SongSelectCallback fptr) { mSongSelectCallback = fptr; return *this; };
+    inline MidiInterface& setHandleTuneRequest(TuneRequestCallback fptr) { mTuneRequestCallback = fptr; return *this; };
+    inline MidiInterface& setHandleClock(ClockCallback fptr) { mClockCallback = fptr; return *this; };
+    inline MidiInterface& setHandleStart(StartCallback fptr) { mStartCallback = fptr; return *this; };
+    inline MidiInterface& setHandleTick(TickCallback fptr) { mTickCallback = fptr; return *this; };
+    inline MidiInterface& setHandleContinue(ContinueCallback fptr) { mContinueCallback = fptr; return *this; };
+    inline MidiInterface& setHandleStop(StopCallback fptr) { mStopCallback = fptr; return *this; };
+    inline MidiInterface& setHandleActiveSensing(ActiveSensingCallback fptr) { mActiveSensingCallback = fptr; return *this; };
+    inline MidiInterface& setHandleSystemReset(SystemResetCallback fptr) { mSystemResetCallback = fptr; return *this; };
 
-    inline void disconnectCallbackFromType(MidiType inType);
+    inline MidiInterface& disconnectCallbackFromType(MidiType inType);
 
 private:
     void launchCallback();
@@ -239,9 +239,9 @@ public:
     inline Thru::Mode getFilterMode() const;
     inline bool getThruState() const;
 
-    inline void turnThruOn(Thru::Mode inThruFilterMode = Thru::Full);
-    inline void turnThruOff();
-    inline void setThruFilterMode(Thru::Mode inThruFilterMode);
+    inline MidiInterface& turnThruOn(Thru::Mode inThruFilterMode = Thru::Full);
+    inline MidiInterface& turnThruOff();
+    inline MidiInterface& setThruFilterMode(Thru::Mode inThruFilterMode);
 
 private:
     void thruFilter(byte inChannel);
@@ -254,7 +254,7 @@ private:
     inline void handleNullVelocityNoteOnAsNoteOff();
     inline bool inputFilter(Channel inChannel);
     inline void resetInput();
-    inline void UpdateLastSentTime();
+    inline void updateLastSentTime();
 
     // -------------------------------------------------------------------------
     // Transport

src/MIDI.hpp

@@ -48,7 +48,7 @@ inline MidiInterface<Transport, Settings, Platform>::MidiInterface(Transport& in
     , mReceiverActiveSensingActivated(false)
     , mLastError(0)
 {
-        mSenderActiveSensingPeriodicity = Settings::SenderActiveSensingPeriodicity;
+    mSenderActiveSensingPeriodicity = Settings::SenderActiveSensingPeriodicity;
 }
 
 /*! \brief Destructor for MidiInterface.
@@ -69,7 +69,7 @@ inline MidiInterface<Transport, Settings, Platform>::~MidiInterface()
  - Full thru mirroring
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::begin(Channel inChannel)
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::begin(Channel inChannel)
 {
     // Initialise the Transport layer
     mTransport.begin();
@@ -95,6 +95,8 @@ void MidiInterface<Transport, Settings, Platform>::begin(Channel inChannel)
 
     mThruFilterMode = Thru::Full;
     mThruActivated  = mTransport.thruActivated;
+
+    return *this;
 }
 
 // -----------------------------------------------------------------------------
@@ -115,33 +117,38 @@ void MidiInterface<Transport, Settings, Platform>::begin(Channel inChannel)
  them thru.
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::send(const MidiMessage& inMessage)
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::send(const MidiMessage& inMessage)
 {
     if (!inMessage.valid)
-        return;
+        return *this;
 
     if (mTransport.beginTransmission(inMessage.type))
     {
-        const StatusByte status = getStatus(inMessage.type, inMessage.channel);
-        mTransport.write(status);
-
-        if (inMessage.type != MidiType::SystemExclusive)
+        if (inMessage.isSystemRealTime())
         {
+            mTransport.write(inMessage.type);
+        } else if (inMessage.isChannelMessage())
+        {
+            const StatusByte status = getStatus(inMessage.type, inMessage.channel);
+            mTransport.write(status);
             if (inMessage.length > 1) mTransport.write(inMessage.data1);
             if (inMessage.length > 2) mTransport.write(inMessage.data2);
-        } else
+        } else if (inMessage.type == MidiType::SystemExclusive)
         {
-            // sysexArray does not contain the start and end tags
-            mTransport.write(MidiType::SystemExclusiveStart);
-
-            for (size_t i = 0; i < inMessage.getSysExSize(); i++)
+            const unsigned size = inMessage.getSysExSize();
+            for (size_t i = 0; i < size; i++)
                 mTransport.write(inMessage.sysexArray[i]);
-
-            mTransport.write(MidiType::SystemExclusiveEnd);
+        } else // at this point, it it assumed to be a system common message
+        {
+            mTransport.write(inMessage.type);
+            if (inMessage.length > 1) mTransport.write(inMessage.data1);
+            if (inMessage.length > 2) mTransport.write(inMessage.data2);
         }
     }
     mTransport.endTransmission();
-    UpdateLastSentTime();
+    updateLastSentTime();
+
+    return *this;
 }
 
 
@@ -157,7 +164,7 @@ void MidiInterface<Transport, Settings, Platform>::send(const MidiMessage& inMes
  from your code, at your own risks.
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::send(MidiType inType,
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::send(MidiType inType,
                                                DataByte inData1,
                                                DataByte inData2,
                                                Channel inChannel)
@@ -169,7 +176,7 @@ void MidiInterface<Transport, Settings, Platform>::send(MidiType inType,
             inChannel == MIDI_CHANNEL_OMNI ||
             inType < 0x80)
         {
-            return; // Don't send anything
+            return *this; // Don't send anything
         }
         // Protection: remove MSBs on data
         inData1 &= 0x7f;
@@ -202,13 +209,15 @@ void MidiInterface<Transport, Settings, Platform>::send(MidiType inType,
             }
 
             mTransport.endTransmission();
-            UpdateLastSentTime();
+            updateLastSentTime();
         }
     }
     else if (inType >= Clock && inType <= SystemReset)
     {
         sendRealTime(inType); // System Real-time and 1 byte.
     }
+
+    return *this;
 }
 
 // -----------------------------------------------------------------------------
@@ -223,11 +232,11 @@ void MidiInterface<Transport, Settings, Platform>::send(MidiType inType,
  http://www.phys.unsw.edu.au/jw/notes.html
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::sendNoteOn(DataByte inNoteNumber,
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendNoteOn(DataByte inNoteNumber,
                                                      DataByte inVelocity,
                                                      Channel inChannel)
 {
-    send(NoteOn, inNoteNumber, inVelocity, inChannel);
+    return send(NoteOn, inNoteNumber, inVelocity, inChannel);
 }
 
 /*! \brief Send a Note Off message
@@ -242,11 +251,11 @@ void MidiInterface<Transport, Settings, Platform>::sendNoteOn(DataByte inNoteNum
  http://www.phys.unsw.edu.au/jw/notes.html
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::sendNoteOff(DataByte inNoteNumber,
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendNoteOff(DataByte inNoteNumber,
                                                       DataByte inVelocity,
                                                       Channel inChannel)
 {
-    send(NoteOff, inNoteNumber, inVelocity, inChannel);
+    return send(NoteOff, inNoteNumber, inVelocity, inChannel);
 }
 
 /*! \brief Send a Program Change message
@@ -254,10 +263,10 @@ void MidiInterface<Transport, Settings, Platform>::sendNoteOff(DataByte inNoteNu
  \param inChannel       The channel on which the message will be sent (1 to 16).
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::sendProgramChange(DataByte inProgramNumber,
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendProgramChange(DataByte inProgramNumber,
                                                             Channel inChannel)
 {
-    send(ProgramChange, inProgramNumber, 0, inChannel);
+    return send(ProgramChange, inProgramNumber, 0, inChannel);
 }
 
 /*! \brief Send a Control Change message
@@ -267,11 +276,11 @@ void MidiInterface<Transport, Settings, Platform>::sendProgramChange(DataByte in
  @see MidiControlChangeNumber
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::sendControlChange(DataByte inControlNumber,
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendControlChange(DataByte inControlNumber,
                                                             DataByte inControlValue,
                                                             Channel inChannel)
 {
-    send(ControlChange, inControlNumber, inControlValue, inChannel);
+    return send(ControlChange, inControlNumber, inControlValue, inChannel);
 }
 
 /*! \brief Send a Polyphonic AfterTouch message (applies to a specified note)
@@ -282,11 +291,11 @@ void MidiInterface<Transport, Settings, Platform>::sendControlChange(DataByte in
  library, @see sendAfterTouch to send polyphonic and monophonic AfterTouch messages.
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::sendPolyPressure(DataByte inNoteNumber,
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendPolyPressure(DataByte inNoteNumber,
                                                            DataByte inPressure,
                                                            Channel inChannel)
 {
-    send(AfterTouchPoly, inNoteNumber, inPressure, inChannel);
+    return send(AfterTouchPoly, inNoteNumber, inPressure, inChannel);
 }
 
 /*! \brief Send a MonoPhonic AfterTouch message (applies to all notes)
@@ -294,10 +303,10 @@ void MidiInterface<Transport, Settings, Platform>::sendPolyPressure(DataByte inN
  \param inChannel     The channel on which the message will be sent (1 to 16).
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::sendAfterTouch(DataByte inPressure,
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendAfterTouch(DataByte inPressure,
                                                          Channel inChannel)
 {
-    send(AfterTouchChannel, inPressure, 0, inChannel);
+    return send(AfterTouchChannel, inPressure, 0, inChannel);
 }
 
 /*! \brief Send a Polyphonic AfterTouch message (applies to a specified note)
@@ -307,11 +316,11 @@ void MidiInterface<Transport, Settings, Platform>::sendAfterTouch(DataByte inPre
  @see Replaces sendPolyPressure (which is now deprecated).
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::sendAfterTouch(DataByte inNoteNumber,
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendAfterTouch(DataByte inNoteNumber,
                                                          DataByte inPressure,
                                                          Channel inChannel)
 {
-    send(AfterTouchPoly, inNoteNumber, inPressure, inChannel);
+    return send(AfterTouchPoly, inNoteNumber, inPressure, inChannel);
 }
 
 /*! \brief Send a Pitch Bend message using a signed integer value.
@@ -321,11 +330,11 @@ void MidiInterface<Transport, Settings, Platform>::sendAfterTouch(DataByte inNot
  \param inChannel     The channel on which the message will be sent (1 to 16).
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::sendPitchBend(int inPitchValue,
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendPitchBend(int inPitchValue,
                                                         Channel inChannel)
 {
     const unsigned bend = unsigned(inPitchValue - int(MIDI_PITCHBEND_MIN));
-    send(PitchBend, (bend & 0x7f), (bend >> 7) & 0x7f, inChannel);
+    return send(PitchBend, (bend & 0x7f), (bend >> 7) & 0x7f, inChannel);
 }
 
 
@@ -336,12 +345,12 @@ void MidiInterface<Transport, Settings, Platform>::sendPitchBend(int inPitchValu
  \param inChannel     The channel on which the message will be sent (1 to 16).
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::sendPitchBend(double inPitchValue,
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendPitchBend(double inPitchValue,
                                                         Channel inChannel)
 {
-    const int scale = inPitchValue > 0.0 ? MIDI_PITCHBEND_MAX : MIDI_PITCHBEND_MIN;
+    const int scale = inPitchValue > 0.0 ? MIDI_PITCHBEND_MAX : - MIDI_PITCHBEND_MIN;
     const int value = int(inPitchValue * double(scale));
-    sendPitchBend(value, inChannel);
+    return sendPitchBend(value, inChannel);
 }
 
 /*! \brief Generate and send a System Exclusive frame.
@@ -354,7 +363,7 @@ void MidiInterface<Transport, Settings, Platform>::sendPitchBend(double inPitchV
  with previous versions of the library.
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::sendSysEx(unsigned inLength,
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendSysEx(unsigned inLength,
                                                     const byte* inArray,
                                                     bool inArrayContainsBoundaries)
 {
@@ -372,11 +381,13 @@ void MidiInterface<Transport, Settings, Platform>::sendSysEx(unsigned inLength,
             mTransport.write(MidiType::SystemExclusiveEnd);
 
         mTransport.endTransmission();
-        UpdateLastSentTime();
+        updateLastSentTime();
    }
 
     if (Settings::UseRunningStatus)
         mRunningStatus_TX = InvalidType;
+
+    return *this;
 }
 
 /*! \brief Send a Tune Request message.
@@ -385,9 +396,9 @@ void MidiInterface<Transport, Settings, Platform>::sendSysEx(unsigned inLength,
  it should tune its oscillators (if equipped with any).
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::sendTuneRequest()
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendTuneRequest()
 {
-    sendCommon(TuneRequest);
+    return sendCommon(TuneRequest);
 }
 
 /*! \brief Send a MIDI Time Code Quarter Frame.
@@ -397,11 +408,11 @@ void MidiInterface<Transport, Settings, Platform>::sendTuneRequest()
  See MIDI Specification for more information.
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::sendTimeCodeQuarterFrame(DataByte inTypeNibble,
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendTimeCodeQuarterFrame(DataByte inTypeNibble,
                                                                             DataByte inValuesNibble)
 {
     const byte data = byte((((inTypeNibble & 0x07) << 4) | (inValuesNibble & 0x0f)));
-    sendTimeCodeQuarterFrame(data);
+    return sendTimeCodeQuarterFrame(data);
 }
 
 /*! \brief Send a MIDI Time Code Quarter Frame.
@@ -411,25 +422,25 @@ void MidiInterface<Transport, Settings, Platform>::sendTimeCodeQuarterFrame(Data
                 you can send the byte here.
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::sendTimeCodeQuarterFrame(DataByte inData)
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendTimeCodeQuarterFrame(DataByte inData)
 {
-    sendCommon(TimeCodeQuarterFrame, inData);
+    return sendCommon(TimeCodeQuarterFrame, inData);
 }
 
 /*! \brief Send a Song Position Pointer message.
  \param inBeats    The number of beats since the start of the song.
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::sendSongPosition(unsigned inBeats)
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendSongPosition(unsigned inBeats)
 {
-    sendCommon(SongPosition, inBeats);
+    return sendCommon(SongPosition, inBeats);
 }
 
 /*! \brief Send a Song Select message */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::sendSongSelect(DataByte inSongNumber)
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendSongSelect(DataByte inSongNumber)
 {
-    sendCommon(SongSelect, inSongNumber);
+    return sendCommon(SongSelect, inSongNumber);
 }
 
 /*! \brief Send a Common message. Common messages reset the running status.
@@ -440,7 +451,7 @@ void MidiInterface<Transport, Settings, Platform>::sendSongSelect(DataByte inSon
  \param inData1   The byte that goes with the common message.
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::sendCommon(MidiType inType, unsigned inData1)
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendCommon(MidiType inType, unsigned inData1)
 {
     switch (inType)
     {
@@ -451,7 +462,7 @@ void MidiInterface<Transport, Settings, Platform>::sendCommon(MidiType inType, u
             break;
         default:
             // Invalid Common marker
-            return;
+            return *this;
     }
 
     if (mTransport.beginTransmission(inType))
@@ -471,15 +482,19 @@ void MidiInterface<Transport, Settings, Platform>::sendCommon(MidiType inType, u
                 break;
             case TuneRequest:
                 break;
+            // LCOV_EXCL_START - Coverage blind spot
             default:
-                break; // LCOV_EXCL_LINE - Coverage blind spot
+                break;
+            // LCOV_EXCL_STOP
         }
         mTransport.endTransmission();
-        UpdateLastSentTime();
+        updateLastSentTime();
     }
 
     if (Settings::UseRunningStatus)
         mRunningStatus_TX = InvalidType;
+
+    return *this;
 }
 
 /*! \brief Send a Real Time (one byte) message.
@@ -489,7 +504,7 @@ void MidiInterface<Transport, Settings, Platform>::sendCommon(MidiType inType, u
  @see MidiType
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::sendRealTime(MidiType inType)
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendRealTime(MidiType inType)
 {
     // Do not invalidate Running Status for real-time messages
     // as they can be interleaved within any message.
@@ -506,13 +521,15 @@ void MidiInterface<Transport, Settings, Platform>::sendRealTime(MidiType inType)
             {
                 mTransport.write((byte)inType);
                 mTransport.endTransmission();
-                UpdateLastSentTime();
+                updateLastSentTime();
             }
             break;
         default:
             // Invalid Real Time marker
             break;
     }
+
+    return *this;
 }
 
 /*! \brief Start a Registered Parameter Number frame.
@@ -520,7 +537,7 @@ void MidiInterface<Transport, Settings, Platform>::sendRealTime(MidiType inType)
  \param inChannel The channel on which the message will be sent (1 to 16).
 */
 template<class Transport, class Settings, class Platform>
-inline void MidiInterface<Transport, Settings, Platform>::beginRpn(unsigned inNumber,
+inline MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::beginRpn(unsigned inNumber,
                                                           Channel inChannel)
 {
     if (mCurrentRpnNumber != inNumber)
@@ -531,6 +548,8 @@ inline void MidiInterface<Transport, Settings, Platform>::beginRpn(unsigned inNu
         sendControlChange(RPNMSB, numMsb, inChannel);
         mCurrentRpnNumber = inNumber;
     }
+
+    return *this;
 }
 
 /*! \brief Send a 14-bit value for the currently selected RPN number.
@@ -538,13 +557,15 @@ inline void MidiInterface<Transport, Settings, Platform>::beginRpn(unsigned inNu
  \param inChannel The channel on which the message will be sent (1 to 16).
 */
 template<class Transport, class Settings, class Platform>
-inline void MidiInterface<Transport, Settings, Platform>::sendRpnValue(unsigned inValue,
+inline MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendRpnValue(unsigned inValue,
                                                               Channel inChannel)
 {;
     const byte valMsb = 0x7f & (inValue >> 7);
     const byte valLsb = 0x7f & inValue;
     sendControlChange(DataEntryMSB, valMsb, inChannel);
     sendControlChange(DataEntryLSB, valLsb, inChannel);
+
+    return *this;
 }
 
 /*! \brief Send separate MSB/LSB values for the currently selected RPN number.
@@ -553,32 +574,38 @@ inline void MidiInterface<Transport, Settings, Platform>::sendRpnValue(unsigned
  \param inChannel The channel on which the message will be sent (1 to 16).
 */
 template<class Transport, class Settings, class Platform>
-inline void MidiInterface<Transport, Settings, Platform>::sendRpnValue(byte inMsb,
+inline MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendRpnValue(byte inMsb,
                                                               byte inLsb,
                                                               Channel inChannel)
 {
     sendControlChange(DataEntryMSB, inMsb, inChannel);
     sendControlChange(DataEntryLSB, inLsb, inChannel);
+
+    return *this;
 }
 
 /* \brief Increment the value of the currently selected RPN number by the specified amount.
  \param inAmount The amount to add to the currently selected RPN value.
 */
 template<class Transport, class Settings, class Platform>
-inline void MidiInterface<Transport, Settings, Platform>::sendRpnIncrement(byte inAmount,
+inline MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendRpnIncrement(byte inAmount,
                                                                   Channel inChannel)
 {
     sendControlChange(DataIncrement, inAmount, inChannel);
+
+    return *this;
 }
 
 /* \brief Decrement the value of the currently selected RPN number by the specified amount.
  \param inAmount The amount to subtract to the currently selected RPN value.
 */
 template<class Transport, class Settings, class Platform>
-inline void MidiInterface<Transport, Settings, Platform>::sendRpnDecrement(byte inAmount,
+inline MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendRpnDecrement(byte inAmount,
                                                                   Channel inChannel)
 {
     sendControlChange(DataDecrement, inAmount, inChannel);
+
+    return *this;
 }
 
 /*! \brief Terminate an RPN frame.
@@ -586,11 +613,13 @@ This will send a Null Function to deselect the currently selected RPN.
  \param inChannel The channel on which the message will be sent (1 to 16).
 */
 template<class Transport, class Settings, class Platform>
-inline void MidiInterface<Transport, Settings, Platform>::endRpn(Channel inChannel)
+inline MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::endRpn(Channel inChannel)
 {
     sendControlChange(RPNLSB, 0x7f, inChannel);
     sendControlChange(RPNMSB, 0x7f, inChannel);
     mCurrentRpnNumber = 0xffff;
+
+    return *this;
 }
 
 
@@ -600,7 +629,7 @@ inline void MidiInterface<Transport, Settings, Platform>::endRpn(Channel inChann
  \param inChannel The channel on which the message will be sent (1 to 16).
 */
 template<class Transport, class Settings, class Platform>
-inline void MidiInterface<Transport, Settings, Platform>::beginNrpn(unsigned inNumber,
+inline MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::beginNrpn(unsigned inNumber,
                                                            Channel inChannel)
 {
     if (mCurrentNrpnNumber != inNumber)
@@ -611,6 +640,8 @@ inline void MidiInterface<Transport, Settings, Platform>::beginNrpn(unsigned inN
         sendControlChange(NRPNMSB, numMsb, inChannel);
         mCurrentNrpnNumber = inNumber;
     }
+
+    return *this;
 }
 
 /*! \brief Send a 14-bit value for the currently selected NRPN number.
@@ -618,13 +649,15 @@ inline void MidiInterface<Transport, Settings, Platform>::beginNrpn(unsigned inN
  \param inChannel The channel on which the message will be sent (1 to 16).
 */
 template<class Transport, class Settings, class Platform>
-inline void MidiInterface<Transport, Settings, Platform>::sendNrpnValue(unsigned inValue,
+inline MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendNrpnValue(unsigned inValue,
                                                                Channel inChannel)
-{;
+{
     const byte valMsb = 0x7f & (inValue >> 7);
     const byte valLsb = 0x7f & inValue;
     sendControlChange(DataEntryMSB, valMsb, inChannel);
     sendControlChange(DataEntryLSB, valLsb, inChannel);
+
+    return *this;
 }
 
 /*! \brief Send separate MSB/LSB values for the currently selected NRPN number.
@@ -633,32 +666,38 @@ inline void MidiInterface<Transport, Settings, Platform>::sendNrpnValue(unsigned
  \param inChannel The channel on which the message will be sent (1 to 16).
 */
 template<class Transport, class Settings, class Platform>
-inline void MidiInterface<Transport, Settings, Platform>::sendNrpnValue(byte inMsb,
+inline MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendNrpnValue(byte inMsb,
                                                                byte inLsb,
                                                                Channel inChannel)
 {
     sendControlChange(DataEntryMSB, inMsb, inChannel);
     sendControlChange(DataEntryLSB, inLsb, inChannel);
+
+    return *this;
 }
 
 /* \brief Increment the value of the currently selected NRPN number by the specified amount.
  \param inAmount The amount to add to the currently selected NRPN value.
 */
 template<class Transport, class Settings, class Platform>
-inline void MidiInterface<Transport, Settings, Platform>::sendNrpnIncrement(byte inAmount,
+inline MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendNrpnIncrement(byte inAmount,
                                                                    Channel inChannel)
 {
     sendControlChange(DataIncrement, inAmount, inChannel);
+
+    return *this;
 }
 
 /* \brief Decrement the value of the currently selected NRPN number by the specified amount.
  \param inAmount The amount to subtract to the currently selected NRPN value.
 */
 template<class Transport, class Settings, class Platform>
-inline void MidiInterface<Transport, Settings, Platform>::sendNrpnDecrement(byte inAmount,
+inline MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::sendNrpnDecrement(byte inAmount,
                                                                    Channel inChannel)
 {
     sendControlChange(DataDecrement, inAmount, inChannel);
+
+    return *this;
 }
 
 /*! \brief Terminate an NRPN frame.
@@ -666,11 +705,20 @@ This will send a Null Function to deselect the currently selected NRPN.
  \param inChannel The channel on which the message will be sent (1 to 16).
 */
 template<class Transport, class Settings, class Platform>
-inline void MidiInterface<Transport, Settings, Platform>::endNrpn(Channel inChannel)
+inline MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::endNrpn(Channel inChannel)
 {
     sendControlChange(NRPNLSB, 0x7f, inChannel);
     sendControlChange(NRPNMSB, 0x7f, inChannel);
     mCurrentNrpnNumber = 0xffff;
+
+    return *this;
+}
+
+template<class Transport, class Settings, class Platform>
+inline void MidiInterface<Transport, Settings, Platform>::updateLastSentTime()
+{
+    if (Settings::UseSenderActiveSensing && mSenderActiveSensingPeriodicity)
+        mLastMessageSentTime = Platform::now();
 }
 
 /*! @} */ // End of doc group MIDI Output
@@ -980,9 +1028,10 @@ bool MidiInterface<Transport, Settings, Platform>::parse()
                         resetInput();
                         return false;
                     }
-
+                // LCOV_EXCL_START - Coverage blind spot
                 default:
-                    break; // LCOV_EXCL_LINE - Coverage blind spot
+                    break;
+                // LCOV_EXCL_STOP
             }
         }
 
@@ -1037,6 +1086,7 @@ bool MidiInterface<Transport, Settings, Platform>::parse()
             mMessage.data1 = mPendingMessage[1];
             // Save data2 only if applicable
             mMessage.data2 = mPendingMessageExpectedLength == 3 ? mPendingMessage[2] : 0;
+            mMessage.length = mPendingMessageExpectedLength;
 
             // Reset local variables
             mPendingMessageIndex = 0;
@@ -1202,9 +1252,11 @@ inline Channel MidiInterface<Transport, Settings, Platform>::getInputChannel() c
  if you want to listen to all channels, and MIDI_CHANNEL_OFF to disable input.
  */
 template<class Transport, class Settings, class Platform>
-inline void MidiInterface<Transport, Settings, Platform>::setInputChannel(Channel inChannel)
+inline MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::setInputChannel(Channel inChannel)
 {
     mInputChannel = inChannel;
+
+    return *this;
 }
 
 // -----------------------------------------------------------------------------
@@ -1259,7 +1311,7 @@ bool MidiInterface<Transport, Settings, Platform>::isChannelMessage(MidiType inT
  When a message of this type is received, no function will be called.
  */
 template<class Transport, class Settings, class Platform>
-void MidiInterface<Transport, Settings, Platform>::disconnectCallbackFromType(MidiType inType)
+MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::disconnectCallbackFromType(MidiType inType)
 {
     switch (inType)
     {
@@ -1285,6 +1337,8 @@ void MidiInterface<Transport, Settings, Platform>::disconnectCallbackFromType(Mi
         default:
             break;
     }
+
+    return *this;
 }
 
 /*! @} */ // End of doc group MIDI Callbacks
@@ -1327,9 +1381,11 @@ void MidiInterface<Transport, Settings, Platform>::launchCallback()
 
         case SystemReset:           if (mSystemResetCallback != nullptr)           mSystemResetCallback();    break;
 
+        // LCOV_EXCL_START - Unreacheable code, but prevents unhandled case warning.
         case InvalidType:
         default:
-            break; // LCOV_EXCL_LINE - Unreacheable code, but prevents unhandled case warning.
+            break;
+        // LCOV_EXCL_STOP
     }
 }
 
@@ -1349,10 +1405,12 @@ void MidiInterface<Transport, Settings, Platform>::launchCallback()
  @see Thru::Mode
  */
 template<class Transport, class Settings, class Platform>
-inline void MidiInterface<Transport, Settings, Platform>::setThruFilterMode(Thru::Mode inThruFilterMode)
+inline MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::setThruFilterMode(Thru::Mode inThruFilterMode)
 {
     mThruFilterMode = inThruFilterMode;
     mThruActivated  = mThruFilterMode != Thru::Off;
+
+    return *this;
 }
 
 template<class Transport, class Settings, class Platform>
@@ -1368,25 +1426,23 @@ inline bool MidiInterface<Transport, Settings, Platform>::getThruState() const
 }
 
 template<class Transport, class Settings, class Platform>
-inline void MidiInterface<Transport, Settings, Platform>::turnThruOn(Thru::Mode inThruFilterMode)
+inline MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::turnThruOn(Thru::Mode inThruFilterMode)
 {
     mThruActivated = true;
     mThruFilterMode = inThruFilterMode;
+
+    return *this;
 }
 
 template<class Transport, class Settings, class Platform>
-inline void MidiInterface<Transport, Settings, Platform>::turnThruOff()
+inline MidiInterface<Transport, Settings, Platform>& MidiInterface<Transport, Settings, Platform>::turnThruOff()
 {
     mThruActivated = false;
     mThruFilterMode = Thru::Off;
+
+    return *this;
 }
 
-template<class Transport, class Settings, class Platform>
-inline void MidiInterface<Transport, Settings, Platform>::UpdateLastSentTime()
-{
-    if (Settings::UseSenderActiveSensing && mSenderActiveSensingPeriodicity)
-        mLastMessageSentTime = Platform::now();
-}
 
 /*! @} */ // End of doc group MIDI Thru
 

src/midi_Defs.h

@@ -164,8 +164,22 @@ enum MidiControlChangeNumber: uint8_t
     GeneralPurposeController2   = 17,
     GeneralPurposeController3   = 18,
     GeneralPurposeController4   = 19,
-
+    // CC20 to CC31 undefined
+    BankSelectLSB               = 32,
+    ModulationWheelLSB          = 33,
+    BreathControllerLSB         = 34,
+    // CC35 undefined
+    FootControllerLSB           = 36,
+    PortamentoTimeLSB           = 37,
     DataEntryLSB                = 38,
+    ChannelVolumeLSB            = 39,
+    BalanceLSB                  = 40,
+    // CC41 undefined
+    PanLSB                      = 42,
+    ExpressionControllerLSB     = 43,
+    EffectControl1LSB           = 44,
+    EffectControl2LSB           = 45,
+    // CC46 to CC63 undefined
 
     // Switches ----------------------------------------------------------------
     Sustain                     = 64,
@@ -203,6 +217,7 @@ enum MidiControlChangeNumber: uint8_t
     NRPNMSB                     = 99,   ///< Non-Registered Parameter Number (MSB)
     RPNLSB                      = 100,  ///< Registered Parameter Number (LSB)
     RPNMSB                      = 101,  ///< Registered Parameter Number (MSB)
+    // CC102 to CC119 undefined
 
     // Channel Mode messages ---------------------------------------------------
     AllSoundOff                 = 120,

src/midi_Message.h

@@ -54,6 +54,20 @@ struct Message
         memset(sysexArray, 0, sSysExMaxSize * sizeof(DataByte));
     }
 
+    inline Message(const Message& inOther)
+        : channel(inOther.channel)
+        , type(inOther.type)
+        , data1(inOther.data1)
+        , data2(inOther.data2)
+        , valid(inOther.valid)
+        , length(inOther.length)
+    {
+        if (type == midi::SystemExclusive)
+        {
+            memcpy(sysexArray, inOther.sysexArray, sSysExMaxSize * sizeof(DataByte));
+        }
+    }
+
     /*! The maximum size for the System Exclusive array.
     */
     static const unsigned sSysExMaxSize = SysExMaxSize;
@@ -94,12 +108,24 @@ struct Message
     /*! Total Length of the message.
      */
     unsigned length;
-    
+
     inline unsigned getSysExSize() const
     {
         const unsigned size = unsigned(data2) << 8 | data1;
         return size > sSysExMaxSize ? sSysExMaxSize : size;
     }
+    inline bool isSystemRealTime () const
+    {
+          return (type & 0xf8) == 0xf8;
+    }
+    inline bool isSystemCommon () const
+    {
+          return (type & 0xf8) == 0xf0;
+    }
+    inline bool isChannelMessage () const
+    {
+          return (type & 0xf0) != 0xf0;
+    }
 };
 
 END_MIDI_NAMESPACE

src/midi_Settings.h

@@ -38,12 +38,12 @@ BEGIN_MIDI_NAMESPACE
  macro to create your instance. The settings you don't override will keep their
  default value. Eg:
  \code{.cpp}
- struct MySettings : public midi::DefaultSettings
+ struct MySettings : public MIDI_NAMESPACE::DefaultSettings
  {
     static const unsigned SysExMaxSize = 1024; // Accept SysEx messages up to 1024 bytes long.
  };
 
- MIDI_CREATE_CUSTOM_INSTANCE(HardwareSerial, Serial2, midi, MySettings);
+ MIDI_CREATE_CUSTOM_INSTANCE(HardwareSerial, Serial2, MIDI, MySettings);
  \endcode
  */
 struct DefaultSettings

src/serialMIDI.h

@@ -63,6 +63,11 @@ public:
         #endif
 	}
 
+    void end()
+    {
+        mSerial.end();
+    }
+
 	bool beginTransmission(MidiType)
 	{
 		return true;
@@ -91,6 +96,8 @@ private:
     SerialPort& mSerial;
 };
 
+END_MIDI_NAMESPACE
+
 /*! \brief Create an instance of the library attached to a serial port.
  You can use HardwareSerial or SoftwareSerial for the serial port.
  Example: MIDI_CREATE_INSTANCE(HardwareSerial, Serial2, midi2);
@@ -113,5 +120,11 @@ private:
         MIDI_CREATE_INSTANCE(HardwareSerial, Serial,  MIDI);
 #endif
 
-
-END_MIDI_NAMESPACE
+/*! \brief Create an instance of the library attached to a serial port with
+ custom settings.
+ @see DefaultSettings
+ @see MIDI_CREATE_INSTANCE
+ */
+#define MIDI_CREATE_CUSTOM_INSTANCE(Type, SerialPort, Name, Settings)           \
+    MIDI_NAMESPACE::SerialMIDI<Type> serial##Name(SerialPort);\
+    MIDI_NAMESPACE::MidiInterface<MIDI_NAMESPACE::SerialMIDI<Type>, Settings> Name((MIDI_NAMESPACE::SerialMIDI<Type>&)serial##Name);