Declared "MIDI_CREATE_INSTANCE(HardwareSerial, Serial1, MIDI);" and MIDI is still Out Of Scope!

[ruiseixasm]

Hi,

I'm doing a project that is split in multiple header files in a single namespace. In a crude way my project looks like this:

The file MidiInclude.h is like this:

#ifndef MIDIINCLUDE_H_INCLUDED
#define MIDIINCLUDE_H_INCLUDED

#include <Arduino.h>
#include <MIDI.h>

namespace MidiProject {
    MidiClass {
        public:
            static void initiateMidi();
            static void sendMidi();
    };
}

#endif // MIDIINCLUDE_H_INCLUDED

The file MidiInclude.cpp is like this:

#include "MidiInclude.h"

namespace MidiProject {

    MIDI_CREATE_INSTANCE(HardwareSerial, Serial1, MIDI);

    MidiClass::initiateMidi() {
        MIDI.begin(MIDI_CHANNEL_OMNI);
        MIDI.setThruFilterMode(midi::Thru::Off);
    }

    MidiClass::sendMidi() {
        MIDI.sendNoteOff(60, 100, 1); // **Compiles and works fine**
        delay(1000);
        MIDI.sendNoteOff(60, 0, 1); // **Compiles and works fine**
    }
}

Now the MainProject.h file:

#ifndef MAINPROJECT_H_INCLUDED
#define MAINPROJECT_H_INCLUDED

#include <Arduino.h>
#include "MidiInclude.h"

namespace MidiProject {
    ProjectClass {
        public:
            static void initiateMidi();
            static void sendMidi();
    };
}

#endif // MAINPROJECT_H_INCLUDED

The MainProject.cpp file:

#include "MainProject.h"
namespace MidiProject {

    ProjectClass::initiateMidi() {
        MidiClass::initiateMidi(); // **Compiles and works fine**
    }

    ProjectClass::sendMidi() {
        MIDI.sendNoteOff(60, 100, 1); // **ERROR: 'MIDI' was not declared in this scope**
        delay(1000);
        MIDI.sendNoteOff(60, 0, 1); // **ERROR: 'MIDI' was not declared in this scope**
    }
}

I don't understand why the MainProject Class doesn't 'see' the MIDI object!

Finally the main.cpp file is like this:

#include "MainProject.h"

void setup() {
	MidiProject::ProjectClass::initiateMidi();
	MidiProject::ProjectClass::sendMidi();
}

void loop() {
    // Empty
}

Thanks.

[franky47]

That would be because the MIDI_CREATE_INSTANCE macro is called in a .cpp file, which limits the scope of the created MIDI object to that compilation unit.

To use it somewhere else, you'd have to declare it first as extern in MidiInclude.h, as such:

#ifndef MIDIINCLUDE_H_INCLUDED
#define MIDIINCLUDE_H_INCLUDED

#include <Arduino.h>
#include <MIDI.h>

namespace MidiProject {

    extern midi::MidiInterface<midi::SerialMIDI<HardwareSerial>> MIDI;

    // ↓ I assume there was a missing class or struct keyword here?
    class MidiClass {
        public:
            static void initiateMidi();
            static void sendMidi();
    };
}

#endif // MIDIINCLUDE_H_INCLUDED

[ruiseixasm]

Ok, thanks, I will check that, meanwhile I try with success the use of function pointers. So:

The new file MidiInclude.h is now like this:

#ifndef MIDIINCLUDE_H_INCLUDED
#define MIDIINCLUDE_H_INCLUDED

#include <Arduino.h>
#include <MIDI.h>

namespace MidiProject {
    class MidiClass {
        public:
            typedef byte Channel;
            using NoteCallBack = void (*)(Channel channel, byte note, byte velocity);
            static void initiateMidi();
            static void sendMidi();

            static void sendMidiNoteOff(Channel, byte, byte);
            static void sendMidiNoteOn(Channel, byte, byte);
            static void setFunctionNoteOff(NoteCallBack);
            static void setFunctionNoteOn(NoteCallBack);
            static void callFunctionNoteOff(Channel, byte, byte);
            static void callFunctionNoteOn(Channel, byte, byte);
        private:
            static NoteCallBack functionNoteOff;
            static NoteCallBack functionNoteOn;

    };
}

#endif // MIDIINCLUDE_H_INCLUDED

The new file MidiInclude.cpp is now like this:

#include "MidiInclude.h"

namespace MidiProject {

    MIDI_CREATE_INSTANCE(HardwareSerial, Serial1, MIDI);

    MidiClass::NoteCallBack MidiClass::functionNoteOff = nullptr;
    MidiClass::NoteCallBack MidiClass::functionNoteOn = nullptr;

    void MidiClass::initiateMidi() {
        MIDI.begin(MIDI_CHANNEL_OMNI);
        MIDI.setThruFilterMode(midi::Thru::Off);
    }

    void MidiClass::sendMidi() {
        MIDI.sendNoteOn(60, 100, 1); // **Compiles and works fine**
        delay(1000);
        MIDI.sendNoteOff(60, 0, 1); // **Compiles and works fine**
    }

    // Typical midi sends
    void MidiClass::sendMidiNoteOff (Channel channel, byte note, byte velocity) {
        MIDI.sendNoteOff(velocity, note, channel);
    }
    void MidiClass::sendMidiNoteOn (Channel channel, byte note, byte velocity) {
        MIDI.sendNoteOff(velocity, note, channel);
    }
	
    // Sets the pointers to the MainProject Functions
    void MidiClass::setFunctionNoteOff (NoteCallBack note_call_back) {
        functionNoteOff = note_call_back;
    }
    void MidiClass::setFunctionNoteOn (NoteCallBack note_call_back) {
        functionNoteOn = note_call_back;
    }

    // Calls the MainProject Functions
    void MidiClass::callFunctionNoteOff (Channel channel, byte note, byte velocity) {
        functionNoteOff(velocity, note, channel);
    }
    void MidiClass::callFunctionNoteOn (Channel channel, byte note, byte velocity) {
        functionNoteOn(velocity, note, channel);
    }
}

The new file MainProject.h is now like this:

#ifndef MAINPROJECT_H_INCLUDED
#define MAINPROJECT_H_INCLUDED

#include <Arduino.h>
#include "MidiInclude.h"

namespace MidiProject {
    class ProjectClass {
        public:
            static void sendProjectNoteOn(byte, byte, byte);
            static void sendProjectNoteOff(byte, byte, byte);

            static void initiateMidi();
            static void sendMidi();
    };
}

#endif // MAINPROJECT_H_INCLUDED

The new file MainProject.cpp is now like this:

#include "MainProject.h"

namespace MidiProject {

    void ProjectClass::initiateMidi() {
        MidiClass::initiateMidi(); // **Compiles and works fine**
        MidiClass::setFunctionNoteOff(sendProjectNoteOff);
        MidiClass::setFunctionNoteOn(sendProjectNoteOn);
    }
    void ProjectClass::sendMidi() {
        MidiClass::callFunctionNoteOn(1, 100, 60); //  **OK: Compiles and works fine**
        delay(1000);
        MidiClass::callFunctionNoteOff(1, 100, 60); // **OK: Compiles and works fine**
    }

    void ProjectClass::sendProjectNoteOff(byte velocity, byte note, byte channel) {
        // Do Stuff from MainProject SCOPE (NOT POSSIBLE BEFORE)
        MidiClass::sendMidiNoteOff(channel, note, velocity);
    }

    void ProjectClass::sendProjectNoteOn(byte velocity, byte note, byte channel) {
        // Do Stuff from MainProject SCOPE (NOT POSSIBLE BEFORE)
        MidiClass::sendMidiNoteOn(channel, note, velocity);
    }
}

The file main.cpp remains the same. Yes that keyword extern I didn't realize it was for these cases.

[franky47]

That's a lot of encapsulation though.. There's nothing wrong in having the MIDI object as a global variable, everything related to IO is static in a microcontroller anyway.

[fapplin]

OK. I'm not using OOP in what I'm doing. I just have straight C code broken in to files. One of them is a callbacks.cpp and a callbacks.h where I define the callbacks I'm using. How do I access MIDI (the object) in my files - as in MIDI.sendPitchBend (newValue, channel);? And, in my main Setup() and Loop()?

callbacks.cpp

#include <MIDI.h>
#include "globals.h"
#include "scales.h"
#include "callbacks.h"

void doPitchBend(byte channel, int bend)
{
  int newValue;
  
   newValue = map(bend, 0, 127, 0, 16383); //map(value, fromLow, fromHigh, toLow, toHigh)
   MIDI.sendPitchBend  (newValue, channel);
}

callbacks.h

#ifndef CALLBACKS_H

#define CALLBACKS_H

extern "C" void doPitchBend(byte channel, int bend);

#endif

[franky47]

Same answer as above, minus the OOP encapsulation: you declare the MIDI object as extern in a shared header file (eg: midiInterface.h), and you create it in its associated compilation unit (midiInterface.cpp, using the macro).

Then you can include midiInterface.h wherever you need to reference that MIDI object, and the linker will do the rest.

[fapplin]

Got it! Thanks again for the help!