feat: Serialise USB MIDI packets into the serial RX buffer

src/midi_UsbDefs.h

@@ -127,9 +127,8 @@ struct CodeIndexNumbers
                 return 1;
 
             default:
-                break;
+                return 0; // Can be any length (1, 2 or 3).
         }
-        return 0; // Can be any length (1, 2 or 3).
     }
 };
 

src/midi_UsbPacketInterface.h

@@ -37,7 +37,7 @@ template<typename Buffer>
 bool composeTxPacket(Buffer& inBuffer, midiEventPacket_t& outPacket);
 
 template<typename Buffer>
-bool parseRxPacket(const midiEventPacket_t& inPacket, Buffer& outBuffer);
+void serialiseRxPacket(const midiEventPacket_t& inPacket, Buffer& outBuffer);
 
 END_MIDI_NAMESPACE
 

src/midi_UsbPacketInterface.hpp

@@ -118,9 +118,29 @@ bool composeTxPacket(Buffer& inBuffer, midiEventPacket_t& outPacket)
 }
 
 template<typename Buffer>
-bool parseRxPacket(const midiEventPacket_t& /*inPacket*/, Buffer& /*outBuffer*/)
+void serialiseRxPacket(const midiEventPacket_t& inPacket, Buffer& outBuffer)
 {
-    return false;
+    const byte cin = inPacket.header & 0x0f;
+    const byte messageLength = midi::CodeIndexNumbers::getSize(cin);
+    switch (messageLength)
+    {
+        case 1:
+            outBuffer.write(inPacket.byte1);
+            return;
+        case 2:
+            outBuffer.write(inPacket.byte1);
+            outBuffer.write(inPacket.byte2);
+            return;
+        case 3:
+            outBuffer.write(inPacket.byte1);
+            outBuffer.write(inPacket.byte2);
+            outBuffer.write(inPacket.byte3);
+            return;
+        case 0:
+        default:
+            // Invalid or ignored messages, don't serialise.
+            return;
+    }
 }
 
 END_MIDI_NAMESPACE

test/unit-tests/tests/unit-tests_MidiUsbPacketInterface.cpp

@@ -12,6 +12,7 @@ END_MIDI_NAMESPACE
 BEGIN_UNNAMED_NAMESPACE
 
 using Buffer = midi::RingBuffer<uint8_t, 8>;
+using CIN = midi::CodeIndexNumbers;
 
 TEST(MidiUsbPacketInterfaceTx, EmptyBufferShouldNotComposeAPacket)
 {
@@ -38,7 +39,7 @@ TEST(MidiUsbPacketInterfaceTx, IncompleteDataShouldNotComposeAPacket)
     result = midi::composeTxPacket(buffer, packet);
     EXPECT_TRUE(result) << "Complete data should compose a packet";
     EXPECT_EQ(0, buffer.getLength()) << "Complete packet data should be read out of the buffer";
-    EXPECT_EQ(midi::CodeIndexNumbers::noteOff, packet.header);
+    EXPECT_EQ(CIN::noteOff, packet.header);
     EXPECT_EQ(0x81, packet.byte1);
     EXPECT_EQ(0x12, packet.byte2);
     EXPECT_EQ(0x42, packet.byte3);
@@ -55,7 +56,7 @@ TEST(MidiUsbPacketInterfaceTx, NoteOff)
     buffer.write(0x12);
     buffer.write(0x42);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::noteOff, packet.header);
+    EXPECT_EQ(CIN::noteOff, packet.header);
     EXPECT_EQ(0x80, packet.byte1);
     EXPECT_EQ(0x12, packet.byte2);
     EXPECT_EQ(0x42, packet.byte3);
@@ -71,7 +72,7 @@ TEST(MidiUsbPacketInterfaceTx, NoteOn)
     buffer.write(0x12);
     buffer.write(0x42);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::noteOn, packet.header);
+    EXPECT_EQ(CIN::noteOn, packet.header);
     EXPECT_EQ(0x91, packet.byte1);
     EXPECT_EQ(0x12, packet.byte2);
     EXPECT_EQ(0x42, packet.byte3);
@@ -87,7 +88,7 @@ TEST(MidiUsbPacketInterfaceTx, PolyPressure)
     buffer.write(0x12);
     buffer.write(0x42);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::polyPressure, packet.header);
+    EXPECT_EQ(CIN::polyPressure, packet.header);
     EXPECT_EQ(0xA2, packet.byte1);
     EXPECT_EQ(0x12, packet.byte2);
     EXPECT_EQ(0x42, packet.byte3);
@@ -103,7 +104,7 @@ TEST(MidiUsbPacketInterfaceTx, ControlChange)
     buffer.write(0x12);
     buffer.write(0x42);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::controlChange, packet.header);
+    EXPECT_EQ(CIN::controlChange, packet.header);
     EXPECT_EQ(0xB3, packet.byte1);
     EXPECT_EQ(0x12, packet.byte2);
     EXPECT_EQ(0x42, packet.byte3);
@@ -118,7 +119,7 @@ TEST(MidiUsbPacketInterfaceTx, ProgramChange)
     buffer.write(0xC4);
     buffer.write(0x12);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::programChange, packet.header);
+    EXPECT_EQ(CIN::programChange, packet.header);
     EXPECT_EQ(0xC4, packet.byte1);
     EXPECT_EQ(0x12, packet.byte2);
     EXPECT_EQ(0x00, packet.byte3);
@@ -133,7 +134,7 @@ TEST(MidiUsbPacketInterfaceTx, ChannelPressure)
     buffer.write(0xD5);
     buffer.write(0x12);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::channelPressure, packet.header);
+    EXPECT_EQ(CIN::channelPressure, packet.header);
     EXPECT_EQ(0xD5, packet.byte1);
     EXPECT_EQ(0x12, packet.byte2);
     EXPECT_EQ(0x00, packet.byte3);
@@ -149,7 +150,7 @@ TEST(MidiUsbPacketInterfaceTx, PitchBend)
     buffer.write(0x12);
     buffer.write(0x42);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::pitchBend, packet.header);
+    EXPECT_EQ(CIN::pitchBend, packet.header);
     EXPECT_EQ(0xE6, packet.byte1);
     EXPECT_EQ(0x12, packet.byte2);
     EXPECT_EQ(0x42, packet.byte3);
@@ -165,7 +166,7 @@ TEST(MidiUsbPacketInterfaceTx, Clock)
 
     buffer.write(midi::Clock);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::singleByte, packet.header);
+    EXPECT_EQ(CIN::singleByte, packet.header);
     EXPECT_EQ(midi::Clock, packet.byte1);
     EXPECT_EQ(0x00, packet.byte2);
     EXPECT_EQ(0x00, packet.byte3);
@@ -179,7 +180,7 @@ TEST(MidiUsbPacketInterfaceTx, Start)
 
     buffer.write(midi::Start);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::singleByte, packet.header);
+    EXPECT_EQ(CIN::singleByte, packet.header);
     EXPECT_EQ(midi::Start, packet.byte1);
     EXPECT_EQ(0x00, packet.byte2);
     EXPECT_EQ(0x00, packet.byte3);
@@ -193,7 +194,7 @@ TEST(MidiUsbPacketInterfaceTx, Stop)
 
     buffer.write(midi::Stop);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::singleByte, packet.header);
+    EXPECT_EQ(CIN::singleByte, packet.header);
     EXPECT_EQ(midi::Stop, packet.byte1);
     EXPECT_EQ(0x00, packet.byte2);
     EXPECT_EQ(0x00, packet.byte3);
@@ -207,7 +208,7 @@ TEST(MidiUsbPacketInterfaceTx, Continue)
 
     buffer.write(midi::Continue);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::singleByte, packet.header);
+    EXPECT_EQ(CIN::singleByte, packet.header);
     EXPECT_EQ(midi::Continue, packet.byte1);
     EXPECT_EQ(0x00, packet.byte2);
     EXPECT_EQ(0x00, packet.byte3);
@@ -221,7 +222,7 @@ TEST(MidiUsbPacketInterfaceTx, ActiveSensing)
 
     buffer.write(midi::ActiveSensing);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::singleByte, packet.header);
+    EXPECT_EQ(CIN::singleByte, packet.header);
     EXPECT_EQ(midi::ActiveSensing, packet.byte1);
     EXPECT_EQ(0x00, packet.byte2);
     EXPECT_EQ(0x00, packet.byte3);
@@ -235,7 +236,7 @@ TEST(MidiUsbPacketInterfaceTx, SystemReset)
 
     buffer.write(midi::SystemReset);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::singleByte, packet.header);
+    EXPECT_EQ(CIN::singleByte, packet.header);
     EXPECT_EQ(midi::SystemReset, packet.byte1);
     EXPECT_EQ(0x00, packet.byte2);
     EXPECT_EQ(0x00, packet.byte3);
@@ -251,7 +252,7 @@ TEST(MidiUsbPacketInterfaceTx, TuneRequest)
 
     buffer.write(midi::TuneRequest);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::systemCommon1Byte, packet.header);
+    EXPECT_EQ(CIN::systemCommon1Byte, packet.header);
     EXPECT_EQ(midi::TuneRequest, packet.byte1);
     EXPECT_EQ(0x00, packet.byte2);
     EXPECT_EQ(0x00, packet.byte3);
@@ -266,7 +267,7 @@ TEST(MidiUsbPacketInterfaceTx, SongSelect)
     buffer.write(midi::SongSelect);
     buffer.write(0x12);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::systemCommon2Bytes, packet.header);
+    EXPECT_EQ(CIN::systemCommon2Bytes, packet.header);
     EXPECT_EQ(midi::SongSelect, packet.byte1);
     EXPECT_EQ(0x12, packet.byte2);
     EXPECT_EQ(0x00, packet.byte3);
@@ -282,7 +283,7 @@ TEST(MidiUsbPacketInterfaceTx, SongPosition)
     buffer.write(0x12);
     buffer.write(0x42);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::systemCommon3Bytes, packet.header);
+    EXPECT_EQ(CIN::systemCommon3Bytes, packet.header);
     EXPECT_EQ(midi::SongPosition, packet.byte1);
     EXPECT_EQ(0x12, packet.byte2);
     EXPECT_EQ(0x42, packet.byte3);
@@ -297,7 +298,7 @@ TEST(MidiUsbPacketInterfaceTx, TimeCodeQuarterFrame)
     buffer.write(midi::TimeCodeQuarterFrame);
     buffer.write(0x12);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::systemCommon2Bytes, packet.header);
+    EXPECT_EQ(CIN::systemCommon2Bytes, packet.header);
     EXPECT_EQ(midi::TimeCodeQuarterFrame, packet.byte1);
     EXPECT_EQ(0x12, packet.byte2);
     EXPECT_EQ(0x00, packet.byte3);
@@ -326,7 +327,7 @@ TEST(MidiUsbPacketInterfaceTx, SysExSinglePacket)
     buffer.write(0xf0);
     buffer.write(0xf7);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::sysExEnds2Bytes, packet.header);
+    EXPECT_EQ(CIN::sysExEnds2Bytes, packet.header);
     EXPECT_EQ(0xf0, packet.byte1);
     EXPECT_EQ(0xf7, packet.byte2);
     EXPECT_EQ(0x00, packet.byte3);
@@ -337,7 +338,7 @@ TEST(MidiUsbPacketInterfaceTx, SysExSinglePacket)
     buffer.write(0x12);
     buffer.write(0xf7);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::sysExEnds3Bytes, packet.header);
+    EXPECT_EQ(CIN::sysExEnds3Bytes, packet.header);
     EXPECT_EQ(0xf0, packet.byte1);
     EXPECT_EQ(0x12, packet.byte2);
     EXPECT_EQ(0xf7, packet.byte3);
@@ -355,14 +356,14 @@ TEST(MidiUsbPacketInterfaceTx, SysExTwoPackets)
 
     buffer.write(deviceIdentityRequest, 6);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::sysExStart, packet.header);
+    EXPECT_EQ(CIN::sysExStart, packet.header);
     EXPECT_EQ(0xf0, packet.byte1);
     EXPECT_EQ(0x7e, packet.byte2);
     EXPECT_EQ(0x7f, packet.byte3);
     EXPECT_EQ(3, buffer.getLength());
 
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::sysExEnds3Bytes, packet.header);
+    EXPECT_EQ(CIN::sysExEnds3Bytes, packet.header);
     EXPECT_EQ(0x06, packet.byte1);
     EXPECT_EQ(0x01, packet.byte2);
     EXPECT_EQ(0xf7, packet.byte3);
@@ -380,21 +381,21 @@ TEST(MidiUsbPacketInterfaceTx, SysExMultiplePacketsEndingWith1Byte)
 
     buffer.write(message, 7);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::sysExStart, packet.header);
+    EXPECT_EQ(CIN::sysExStart, packet.header);
     EXPECT_EQ(0xf0, packet.byte1);
     EXPECT_EQ(0x01, packet.byte2);
     EXPECT_EQ(0x02, packet.byte3);
     EXPECT_EQ(4, buffer.getLength());
 
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::sysExContinue, packet.header);
+    EXPECT_EQ(CIN::sysExContinue, packet.header);
     EXPECT_EQ(0x03, packet.byte1);
     EXPECT_EQ(0x04, packet.byte2);
     EXPECT_EQ(0x05, packet.byte3);
     EXPECT_EQ(1, buffer.getLength());
 
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::sysExEnds1Byte, packet.header);
+    EXPECT_EQ(CIN::sysExEnds1Byte, packet.header);
     EXPECT_EQ(0xf7, packet.byte1);
     EXPECT_EQ(0x00, packet.byte2);
     EXPECT_EQ(0x00, packet.byte3);
@@ -412,32 +413,431 @@ TEST(MidiUsbPacketInterfaceTx, SysExMultiplePacketsEndingWith2Bytes)
 
     buffer.write(message, 8);
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::sysExStart, packet.header);
+    EXPECT_EQ(CIN::sysExStart, packet.header);
     EXPECT_EQ(0xf0, packet.byte1);
     EXPECT_EQ(0x01, packet.byte2);
     EXPECT_EQ(0x02, packet.byte3);
     EXPECT_EQ(5, buffer.getLength());
 
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::sysExContinue, packet.header);
+    EXPECT_EQ(CIN::sysExContinue, packet.header);
     EXPECT_EQ(0x03, packet.byte1);
     EXPECT_EQ(0x04, packet.byte2);
     EXPECT_EQ(0x05, packet.byte3);
     EXPECT_EQ(2, buffer.getLength());
 
     EXPECT_TRUE(midi::composeTxPacket(buffer, packet));
-    EXPECT_EQ(midi::CodeIndexNumbers::sysExEnds2Bytes, packet.header);
+    EXPECT_EQ(CIN::sysExEnds2Bytes, packet.header);
     EXPECT_EQ(0x06, packet.byte1);
     EXPECT_EQ(0xf7, packet.byte2);
     EXPECT_EQ(0x00, packet.byte3);
     EXPECT_EQ(0, buffer.getLength());
 }
 
-// -----------------------------------------------------------------------------
+// =============================================================================
 
-TEST(MidiUsbPacketInterfaceRx, PacketParsing)
+TEST(MidiUsbPacketInterfaceRx, InvalidPacketIsNotSerialised)
 {
+    Buffer buffer;
+    midiEventPacket_t packet;
+    packet.header = CIN::reserved;
+    packet.byte1 = 0x01;
+    packet.byte2 = 0x02;
+    packet.byte3 = 0x03;
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_TRUE(buffer.isEmpty());
+}
 
+TEST(MidiUsbPacketInterfaceRx, CableEventsAreNotSerialised)
+{
+    Buffer buffer;
+    midiEventPacket_t packet;
+    packet.header = CIN::cableEvent;
+    packet.byte1 = 0x01;
+    packet.byte2 = 0x02;
+    packet.byte3 = 0x03;
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_TRUE(buffer.isEmpty());
+}
+
+// Channel Voice Messages --
+
+TEST(MidiUsbPacketInterfaceRx, NoteOff)
+{
+    Buffer buffer;
+    midiEventPacket_t packet;
+    packet.header = CIN::noteOff;
+    packet.byte1 = 0x80;
+    packet.byte2 = 0x12;
+    packet.byte3 = 0x42;
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(3, buffer.getLength());
+    EXPECT_EQ(0x80, buffer.read());
+    EXPECT_EQ(0x12, buffer.read());
+    EXPECT_EQ(0x42, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, NoteOn)
+{
+    Buffer buffer;
+    midiEventPacket_t packet;
+    packet.header = CIN::noteOn;
+    packet.byte1 = 0x91;
+    packet.byte2 = 0x12;
+    packet.byte3 = 0x42;
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(3, buffer.getLength());
+    EXPECT_EQ(0x91, buffer.read());
+    EXPECT_EQ(0x12, buffer.read());
+    EXPECT_EQ(0x42, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, PolyPressure)
+{
+    Buffer buffer;
+    midiEventPacket_t packet;
+    packet.header = CIN::polyPressure;
+    packet.byte1 = 0xA2;
+    packet.byte2 = 0x12;
+    packet.byte3 = 0x42;
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(3, buffer.getLength());
+    EXPECT_EQ(0xA2, buffer.read());
+    EXPECT_EQ(0x12, buffer.read());
+    EXPECT_EQ(0x42, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, ControlChange)
+{
+    Buffer buffer;
+    midiEventPacket_t packet;
+    packet.header = CIN::controlChange;
+    packet.byte1 = 0xB3;
+    packet.byte2 = 0x12;
+    packet.byte3 = 0x42;
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(3, buffer.getLength());
+    EXPECT_EQ(0xB3, buffer.read());
+    EXPECT_EQ(0x12, buffer.read());
+    EXPECT_EQ(0x42, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, ProgramChange)
+{
+    Buffer buffer;
+    midiEventPacket_t packet;
+    packet.header = CIN::programChange;
+    packet.byte1 = 0xC4;
+    packet.byte2 = 0x12;
+    packet.byte3 = 0x42; // Should be ignored
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(2, buffer.getLength());
+    EXPECT_EQ(0xC4, buffer.read());
+    EXPECT_EQ(0x12, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, ChannelPressure)
+{
+    Buffer buffer;
+    midiEventPacket_t packet;
+    packet.header = CIN::channelPressure;
+    packet.byte1 = 0xD5;
+    packet.byte2 = 0x12;
+    packet.byte3 = 0x42; // Should be ignored
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(2, buffer.getLength());
+    EXPECT_EQ(0xD5, buffer.read());
+    EXPECT_EQ(0x12, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, PitchBend)
+{
+    Buffer buffer;
+    midiEventPacket_t packet;
+    packet.header = CIN::pitchBend;
+    packet.byte1 = 0xE6;
+    packet.byte2 = 0x12;
+    packet.byte3 = 0x42;
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(3, buffer.getLength());
+    EXPECT_EQ(0xE6, buffer.read());
+    EXPECT_EQ(0x12, buffer.read());
+    EXPECT_EQ(0x42, buffer.read());
+}
+
+// System Real Time Messages --
+
+TEST(MidiUsbPacketInterfaceRx, Clock)
+{
+    midiEventPacket_t packet;
+    Buffer buffer;
+
+    packet.header = CIN::singleByte;
+    packet.byte1 = midi::Clock;
+    packet.byte2 = 0x12; // Should be ignored
+    packet.byte3 = 0x42; // Should be ignored
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(1, buffer.getLength());
+    EXPECT_EQ(midi::Clock, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, Start)
+{
+    midiEventPacket_t packet;
+    Buffer buffer;
+
+    packet.header = CIN::singleByte;
+    packet.byte1 = midi::Start;
+    packet.byte2 = 0x12; // Should be ignored
+    packet.byte3 = 0x42; // Should be ignored
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(1, buffer.getLength());
+    EXPECT_EQ(midi::Start, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, Stop)
+{
+    midiEventPacket_t packet;
+    Buffer buffer;
+
+    packet.header = CIN::singleByte;
+    packet.byte1 = midi::Stop;
+    packet.byte2 = 0x12; // Should be ignored
+    packet.byte3 = 0x42; // Should be ignored
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(1, buffer.getLength());
+    EXPECT_EQ(midi::Stop, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, Continue)
+{
+    midiEventPacket_t packet;
+    Buffer buffer;
+
+    packet.header = CIN::singleByte;
+    packet.byte1 = midi::Continue;
+    packet.byte2 = 0x12; // Should be ignored
+    packet.byte3 = 0x42; // Should be ignored
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(1, buffer.getLength());
+    EXPECT_EQ(midi::Continue, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, ActiveSensing)
+{
+    midiEventPacket_t packet;
+    Buffer buffer;
+
+    packet.header = CIN::singleByte;
+    packet.byte1 = midi::ActiveSensing;
+    packet.byte2 = 0x12; // Should be ignored
+    packet.byte3 = 0x42; // Should be ignored
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(1, buffer.getLength());
+    EXPECT_EQ(midi::ActiveSensing, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, SystemReset)
+{
+    midiEventPacket_t packet;
+    Buffer buffer;
+
+    packet.header = CIN::singleByte;
+    packet.byte1 = midi::SystemReset;
+    packet.byte2 = 0x12; // Should be ignored
+    packet.byte3 = 0x42; // Should be ignored
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(1, buffer.getLength());
+    EXPECT_EQ(midi::SystemReset, buffer.read());
+}
+
+// System Common Messages --
+
+TEST(MidiUsbPacketInterfaceRx, TuneRequest)
+{
+    midiEventPacket_t packet;
+    Buffer buffer;
+
+    packet.header = CIN::systemCommon1Byte;
+    packet.byte1 = midi::TuneRequest;
+    packet.byte2 = 0x12; // Should be ignored
+    packet.byte3 = 0x42; // Should be ignored
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(1, buffer.getLength());
+    EXPECT_EQ(midi::TuneRequest, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, SongSelect)
+{
+    midiEventPacket_t packet;
+    Buffer buffer;
+
+    packet.header = CIN::systemCommon2Bytes;
+    packet.byte1 = midi::SongSelect;
+    packet.byte2 = 0x12;
+    packet.byte3 = 0x42; // Should be ignored
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(2, buffer.getLength());
+    EXPECT_EQ(midi::SongSelect, buffer.read());
+    EXPECT_EQ(0x12, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, SongPosition)
+{
+    midiEventPacket_t packet;
+    Buffer buffer;
+
+    packet.header = CIN::systemCommon2Bytes;
+    packet.byte1 = midi::SongPosition;
+    packet.byte2 = 0x12;
+    packet.byte3 = 0x42; // Should be ignored
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(2, buffer.getLength());
+    EXPECT_EQ(midi::SongPosition, buffer.read());
+    EXPECT_EQ(0x12, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, TimeCodeQuarterFrame)
+{
+    midiEventPacket_t packet;
+    Buffer buffer;
+
+    packet.header = CIN::systemCommon2Bytes;
+    packet.byte1 = midi::TimeCodeQuarterFrame;
+    packet.byte2 = 0x12;
+    packet.byte3 = 0x42; // Should be ignored
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(2, buffer.getLength());
+    EXPECT_EQ(midi::TimeCodeQuarterFrame, buffer.read());
+    EXPECT_EQ(0x12, buffer.read());
+}
+
+// System Exclusive --
+
+TEST(MidiUsbPacketInterfaceRx, SysExSinglePacket2Bytes)
+{
+    midiEventPacket_t packet;
+    Buffer buffer;
+
+    packet.header = CIN::sysExEnds2Bytes;
+    packet.byte1 = 0xf0;
+    packet.byte2 = 0xf7;
+    packet.byte3 = 0x42; // Should be ignored
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(2, buffer.getLength());
+    EXPECT_EQ(0xf0, buffer.read());
+    EXPECT_EQ(0xf7, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, SysExSinglePacket3Bytes)
+{
+    midiEventPacket_t packet;
+    Buffer buffer;
+
+    packet.header = CIN::sysExEnds3Bytes;
+    packet.byte1 = 0xf0;
+    packet.byte2 = 0x42;
+    packet.byte3 = 0xf7;
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(3, buffer.getLength());
+    EXPECT_EQ(0xf0, buffer.read());
+    EXPECT_EQ(0x42, buffer.read());
+    EXPECT_EQ(0xf7, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, SysExTwoPackets)
+{
+    midiEventPacket_t packet;
+    Buffer buffer;
+
+    packet.header = CIN::sysExStart;
+    packet.byte1 = 0xf0;
+    packet.byte2 = 0x01;
+    packet.byte3 = 0x02;
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(3, buffer.getLength());
+    EXPECT_EQ(0xf0, buffer.read());
+    EXPECT_EQ(0x01, buffer.read());
+    EXPECT_EQ(0x02, buffer.read());
+
+    packet.header = CIN::sysExEnds3Bytes;
+    packet.byte1 = 0x03;
+    packet.byte2 = 0x04;
+    packet.byte3 = 0xf7;
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(3, buffer.getLength());
+    EXPECT_EQ(0x03, buffer.read());
+    EXPECT_EQ(0x04, buffer.read());
+    EXPECT_EQ(0xf7, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, SysExMultiplePacketsEndingWith1Byte)
+{
+    midiEventPacket_t packet;
+    Buffer buffer;
+
+    packet.header = CIN::sysExStart;
+    packet.byte1 = 0xf0;
+    packet.byte2 = 0x01;
+    packet.byte3 = 0x02;
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(3, buffer.getLength());
+    EXPECT_EQ(0xf0, buffer.read());
+    EXPECT_EQ(0x01, buffer.read());
+    EXPECT_EQ(0x02, buffer.read());
+
+    packet.header = CIN::sysExContinue;
+    packet.byte1 = 0x03;
+    packet.byte2 = 0x04;
+    packet.byte3 = 0x05;
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(3, buffer.getLength());
+    EXPECT_EQ(0x03, buffer.read());
+    EXPECT_EQ(0x04, buffer.read());
+    EXPECT_EQ(0x05, buffer.read());
+
+    packet.header = CIN::sysExEnds1Byte;
+    packet.byte1 = 0xf7;
+    packet.byte2 = 0x12; // Should be ignored
+    packet.byte3 = 0x42; // Should be ignored
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(1, buffer.getLength());
+    EXPECT_EQ(0xf7, buffer.read());
+}
+
+TEST(MidiUsbPacketInterfaceRx, SysExMultiplePacketsEndingWith2Bytes)
+{
+    midiEventPacket_t packet;
+    Buffer buffer;
+
+    packet.header = CIN::sysExStart;
+    packet.byte1 = 0xf0;
+    packet.byte2 = 0x01;
+    packet.byte3 = 0x02;
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(3, buffer.getLength());
+    EXPECT_EQ(0xf0, buffer.read());
+    EXPECT_EQ(0x01, buffer.read());
+    EXPECT_EQ(0x02, buffer.read());
+
+    packet.header = CIN::sysExContinue;
+    packet.byte1 = 0x03;
+    packet.byte2 = 0x04;
+    packet.byte3 = 0x05;
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(3, buffer.getLength());
+    EXPECT_EQ(0x03, buffer.read());
+    EXPECT_EQ(0x04, buffer.read());
+    EXPECT_EQ(0x05, buffer.read());
+
+    packet.header = CIN::sysExEnds2Bytes;
+    packet.byte1 = 0x06;
+    packet.byte2 = 0xf7; // Should be ignored
+    packet.byte3 = 0x42; // Should be ignored
+    midi::serialiseRxPacket(packet, buffer);
+    EXPECT_EQ(2, buffer.getLength());
+    EXPECT_EQ(0x06, buffer.read());
+    EXPECT_EQ(0xf7, buffer.read());
 }
 
 END_UNNAMED_NAMESPACE