TLDR: Isn't MIDIUSB_buzzer.ino the example that you're looking for?
I wish you hadn't mentioned "tinyUSB", because that's a whole different thing.
Or Adafruit, because the library you linked doesn't seem to have anything to do with them, either. (it GitHub - arduino-libraries/MIDIUSB: A MIDI library over USB, based on PluggableUSB I hope?) Note that the "pluggable USB" required by this library is the (default) alternative to the TinyUSB that Adafruit likes - they're not compatible...
It does indeed look poorly documented. In particular, there's no clue in the documentation how to tell whether any Midi Events have been received. 
Now, reading source code is a skill that doesn't necessarily require being able to write code, and just because you're not an experienced programmer doesn't mean you shouldn't or can't do it. (In fact, reading other peoples' code is a great way to learn more. If you've been cut&pasting from examples, you've already been doing it SOME.) (and... you'd be surprised at how much of "professional software engineering" consists of figuring out what others' code does, vs writing code from scratch. (alas, it is frequently more difficult to figure our existing code, or it seems that way.))
Fortunately, the midiUSB library is pretty simple.
First, let's look at MIDIUSB.h - that's the file that your sketch includes, so sooner or later, it will declare all of the functions that are usable. We want to look for the "Public:" part of some "class", and we find:
public:
/// Creates a MIDI USB device with 2 endpoints
MIDI_(void);
/// Returns the number of bytes currently available from RX
uint32_t available(void);
/// Reads a new MIDI message from USB
midiEventPacket_t read(void);
/// Flushes TX MIDI channel
void flush(void);
/// Sends a MIDI message to USB
void sendMIDI(midiEventPacket_t event);
/// Sends a MIDI buffer of length size to USB
size_t write(const uint8_t *buffer, size_t size);
/// NIY
operator bool();
};
Hey! Check out the functions that aren't mentioned in the docs! There's write(), and operator bool(), and the really promising looking available() - if available() is at all compatible with other Arduino IO functions, it will tell us whether there are any MIDI messages available.
We also need information about the midiEventPacket_t data type that read() returns; that seems to have been moved to a separate file MIDIUSB_Defs.h, which has:
typedef struct
{
uint8_t header;
uint8_t byte1;
uint8_t byte2;
uint8_t byte3;
} midiEventPacket_t;
That's a bit strange to me, since I though MIDI messages were variable length. I guess they're only variable length went sent via UART - the code in the examples says:
// First parameter is the event type (0x09 = note on, 0x08 = note off).
// Second parameter is note-on/note-off, combined with the channel.
// Channel can be anything between 0-15. Typically reported to the user as 1-16.
// Third parameter is the note number (48 = middle C).
// Fourth parameter is the velocity (64 = normal, 127 = fastest).
So... I guess that's OK. It'd be nice if there were definitions for all those message types., but... oh well.
hey, there's even an example (not a very fleshed-out example) of read() in MIDIUSB/MIDIUSB_read.ino at master · arduino-libraries/MIDIUSB · GitHub
It doesn't use available(); instead it checks for the message header being zero:
void loop() {
midiEventPacket_t rx;
do {
rx = MidiUSB.read();
if (rx.header != 0) {
// does stuff
That's ... consistent with the way that Serial.read() behaves - return a special value if there is no data. We can check the implementation of read() in the .cpp file:
if (USB_Available(MIDI_RX)) {
accept();
c = buffer->midiEvent[buffer->tail];
} else {
c.header = 0;
:
return c;
Sure enough - if no data is available, we'll get a msg.header of zero.
And there's another example MIDIUSB_buzzer.ino that actually plays notes based on received MIDI messages! It also more-or-less confirms that there are no symbolic constants for the message types
So... that's how I'd go about figuring out how to use the library based on the source code. It's a shame I didn't notice the badly-named "buzzer" example to start with...