Untitled

#include "main.h"

// attention la datasheet nous dit : 

#define COMPILE_BLINK                       1 // ok 
#define COMPILE_TEST_USBMIDI                0 // ok 
#define COMPILE_TEST_USBMIDI_EVENTQUEUE     0 // ok 






#if COMPILE_BLINK
    int main()
    {



        while (true) { 

            led = ! led ; 
            ThisThread::sleep_for( BLINKING_RATE );
            
            slider_value = slider.read(); 
            bouton_value = bouton;

            printf("\n slider_value = %f ", slider_value);
            printf("\n bouton_value = %d \n", bouton_value);
            
        }
    }
#endif 








 
#if COMPILE_TEST_USBMIDI
    #include "mbed.h"
    #include "USBMIDI.h"

    USBMIDI midi;

    int main()
    {
        while (1) {
            for (int i = 48; i < 83; i++) { // send some messages!
                led = ! led ;
                midi.write(MIDIMessage::NoteOn(i));
                ThisThread::sleep_for(250ms);
                midi.write(MIDIMessage::NoteOff(i));
                ThisThread::sleep_for(500ms);
            }
        }
    }
#endif 

// a tester pour les callback usb 
// je n'arrive pas a retrouver le bon code pour les DV1... on dirait que la que n'est pas utilisée 
#if COMPILE_TEST_USBMIDI_EVENTQUEUE

    #include "platform/mbed_thread.h"
    #include "USBMIDI.h"

    EventQueue *queue = mbed_event_queue(); // event queue 
    // Blinking rate in milliseconds
    #define BLINKING_RATE_MS 500ms

    // Will use 'pc' for printf
    //Serial pc(SERIAL_TX, SERIAL_RX); 

    // Initialise the digital pin LED1 as an output
    //DigitalOut led1(LED1);
    //DigitalOut led2(LED2);
    //DigitalOut led3(LED3);

    MIDIMessage midimsg;
    USBMIDI *pMidi;

    void onMidiReceived(void);
    void MidiCallback(void);

    //SPI spi1(PD_7, PG_9, PG_11); //SPI(MOSI, MISO, SCLK); -> DAC16-31 ok
    //DigitalOut spi1_nss(PG_10);

    // Postpone the execution MidiCallback from an interrupt handler to a user context.  In a user context
    // functions like 'printf' and spi->write can be used safely.
    void onMidiReceived(void)
    {
        pMidi->attach(NULL); // detach interrupt
        queue->call(MidiCallback);
    }
    

    void MidiCallback(void)
    {
        pMidi->read(&midimsg);
        //led3 = !led3;
        printf("type: %02x\n\r", midimsg.type());
        switch (midimsg.type())
        {
        case MIDIMessage::NoteOnType:
            break;
        case MIDIMessage::NoteOffType:
            break;
        case MIDIMessage::ControlChangeType:
            break;
        case MIDIMessage::PitchWheelType:
            break;
        case MIDIMessage::SysExType:
            printf("data[2]: %02x\n\r", midimsg.data[2]);
            //spi1_nss = 0;
            //spi1.write(0);
            //spi1_nss = 1;
            //led1 = !led1;
            break;
        default:
            break;
        }
        pMidi->attach(onMidiReceived); // reattach interrupt
    }

    
    int main()
    {
        // Initialization for printf
        //pc.baud(115200);
        //fclose(stdout);
        //stdout = pc;
        //fclose(stderr);
        //stderr = pc;

        // Init Midi
        printf("init midi\n\r");
        USBMIDI midi;
        pMidi = &midi;
        printf("midi defined\n\r");

        printf("SystemCoreClock = %d Hz\n", SystemCoreClock);

        pMidi->attach(onMidiReceived); // call back for MIDI messages received
        while (true) {
            //led1 = !led1;
            //thread_sleep_for(BLINKING_RATE_MS);

            for (int i = 48; i < 83; i++) { // send some messages!
                led = ! led ;
                midi.write(MIDIMessage::NoteOn(i));
                ThisThread::sleep_for(250ms);
                midi.write(MIDIMessage::NoteOff(i));
                ThisThread::sleep_for(500ms);
            }
        }
    }
#endif