Different MIDI Notes for Button Press and Release Function

Hi,

This is my first post in this group. Thanks in advance for all support.

I am using Arduino Uno to convert a button press on a breadboard to generate a MIDI note and it works fine.

The problem is that I need a note to be generated on button press and a different note on Button Release.

I am using the following code.

#include <MIDI.h>
#include “Controller.h”

/*************************************************************
MIDI CONTROLLER

by Notes and Volts

Version 1.2 Arduino UNO ONLY!
*************************************************************/

MIDI_CREATE_DEFAULT_INSTANCE();

//************************************************************
//SET THE NUMBER OF CONTROLS USED***********************
//************************************************************
//—How many buttons are connected directly to pins?---------
byte NUMBER_BUTTONS = 2;
//—How many potentiometers are connected directly to pins?–
byte NUMBER_POTS = 0;
//—How many buttons are connected to a multiplexer?---------
byte NUMBER_MUX_BUTTONS = 0;
//—How many potentiometers are connected to a multiplexer?–
byte NUMBER_MUX_POTS = 0;
//************************************************************

//ANY MULTIPLEXERS? (74HC4067)*********************************
//MUX address pins must be connected to Arduino UNO pins 2,3,4,5
//A0 = PIN2, A1 = PIN3, A2 = PIN4, A3 = PIN5
//*******************************************************************
//Mux NAME (OUTPUT PIN, , How Many Mux Pins?(8 or 16) , Is It Analog?);

//Mux M1(10, 16, false); //Digital multiplexer on Arduino pin 10
//Mux M2(A5, 8, true); //Analog multiplexer on Arduino analog pin A0
//*******************************************************************

//DEFINE DIRECTLY CONNECTED POTENTIOMETERS*********************
//Pot (Pin Number, Command, CC Control, Channel Number)
//Command parameter is for future use

//Pot PO1(A0, 0, 1, 1);
//Pot PO2(A1, 0, 10, 1);
//Pot PO3(A2, 0, 22, 1);
//Pot PO4(A3, 0, 118, 1);
//Pot PO5(A4, 0, 30, 1);
//Pot PO6(A5, 0, 31, 1);
//*******************************************************************
//Add pots used to array below like this-> Pot POTS[] {&PO1, &PO2, &PO3, &PO4, &PO5, &PO6};
Pot POTS[] {};
//
*****************************************************************

//DEFINE DIRECTLY CONNECTED BUTTONS****************************
//Button (Pin Number, Command, Note Number, Channel, Debounce Time)
//** Command parameter 0=NOTE 1=CC 2=Toggle CC **

//Button BU1(2, 0, 60, 1, 5 );
Button BU2(3, 0, 61, 1, 1 );
//Button BU3(4, 0, 62, 1, 5 );
//Button BU4(5, 0, 63, 1, 5 );
Button BU5(6, 1, 64, 1, 1 );
//Button BU6(7, 0, 65, 1, 5 );
//Button BU7(8, 1, 64, 1, 5 );
//Button BU8(9, 2, 64, 1, 5 );
//*******************************************************************
//Add buttons used to array below like this-> Button BUTTONS[] {&BU1, &BU2, &BU3, &BU4, &BU5, &BU6, &BU7, &BU8};
Button BUTTONS[] {&BU2, &BU5};
//
*****************************************************************

//DEFINE BUTTONS CONNECTED TO MULTIPLEXER**********************
//Button::Button(Mux mux, byte muxpin, byte command, byte value, byte channel, byte debounce)
//** Command parameter 0=NOTE 1=CC 2=Toggle CC **

//Button MBU1(M1, 0, 0, 70, 1, 5);
//Button MBU2(M1, 1, 1, 71, 1, 5);
//Button MBU3(M1, 2, 2, 72, 1, 5);
//Button MBU4(M1, 3, 0, 73, 1, 5);
//Button MBU5(M1, 4, 0, 74, 1, 5);
//Button MBU6(M1, 5, 0, 75, 1, 5);
//Button MBU7(M1, 6, 0, 76, 1, 5);
//Button MBU8(M1, 7, 0, 77, 1, 5);
//Button MBU9(M1, 8, 0, 78, 1, 5);
//Button MBU10(M1, 9, 0, 79, 1, 5);
//Button MBU11(M1, 10, 0, 80, 1, 5);
//Button MBU12(M1, 11, 0, 81, 1, 5);
//Button MBU13(M1, 12, 0, 82, 1, 5);
//Button MBU14(M1, 13, 0, 83, 1, 5);
//Button MBU15(M1, 14, 0, 84, 1, 5);
//Button MBU16(M1, 15, 0, 85, 1, 5);
//*******************************************************************
////Add multiplexed buttons used to array below like this-> Button *MUXBUTTONS {&MBU1, &MBU2, &MBU3, &MBU4, &MBU5, &MBU6…};
Button *MUXBUTTONS {};

//*******************************************************************

//DEFINE POTENTIOMETERS CONNECTED TO MULTIPLEXER****************
//Pot::Pot(Mux mux, byte muxpin, byte command, byte control, byte channel)
//Command parameter is for future use

//Pot MPO1(M2, 0, 0, 1, 1);
//Pot MPO2(M2, 1, 0, 7, 1);
//Pot MPO3(M2, 2, 0, 50, 1);
//Pot MPO4(M2, 3, 0, 55, 2);
//Pot MPO5(M2, 4, 0, 50, 1);
//Pot MPO6(M2, 5, 0, 55, 2);
//Pot MPO7(M2, 6, 0, 50, 1);
//Pot MPO8(M2, 7, 0, 55, 2);
//Pot MPO9(M2, 8, 0, 50, 1);
//Pot MPO10(M2, 9, 0, 55, 2);
//Pot MPO11(M2, 10, 0, 50, 1);
//Pot MPO12(M2, 11, 0, 55, 2);
//Pot MPO13(M2, 12, 0, 50, 1);
//Pot MPO14(M2, 13, 0, 55, 2);
//Pot MPO15(M2, 14, 0, 50, 1);
//Pot MPO16(M2, 15, 0, 55, 2);
//*******************************************************************
//Add multiplexed pots used to array below like this-> Pot MUXPOTS[] {&MPO1, &MPO2, &MPO3, &MPO4, &MPO5, &MPO6…};
Pot MUXPOTS[] {};
//
*****************************************************************

void setup() {
MIDI.begin(MIDI_CHANNEL_OFF);
}

void loop() {
if (NUMBER_BUTTONS != 0) updateButtons();
if (NUMBER_POTS != 0) updatePots();
if (NUMBER_MUX_BUTTONS != 0) updateMuxButtons();
if (NUMBER_MUX_POTS != 0) updateMuxPots();
}

//*****************************************************************
void updateButtons() {

// Cycle through Button array
for (int i = 0; i < NUMBER_BUTTONS; i = i + 1) {
byte message = BUTTONS*->getValue();*

  • // Button is pressed*
  • if (message == 0) {*
    _ switch (BUTTONS*->Bcommand) {_
    _
    case 0: //Note*_
    MIDI.sendNoteOn(BUTTONS_->Bvalue, 127, BUTTONS*->Bchannel);
    break;
    case 1: //CC*

    MIDI.sendControlChange(BUTTONS->Bvalue, 127, BUTTONS*->Bchannel);
    break;
    case 2: //Toggle*

    if (BUTTONS*->Btoggle == 0) {
    MIDI.sendControlChange(BUTTONS->Bvalue, 127, BUTTONS->Bchannel);
    BUTTONS->Btoggle = 1;
    }
    else if (BUTTONS->Btoggle == 1) {
    MIDI.sendControlChange(BUTTONS->Bvalue, 0, BUTTONS->Bchannel);
    BUTTONS->Btoggle = 0;
    }
    break;
    }
    }
    // Button is not pressed*

    * if (message == 1) {
    switch (BUTTONS->Bcommand) {
    case 0:
    MIDI.sendNoteOff(BUTTONS->Bvalue, 0, BUTTONS->Bchannel);
    break;
    case 1:
    MIDI.sendControlChange(BUTTONS->Bvalue, 0, BUTTONS->Bchannel);
    break;
    }
    }
    }
    }
    //
    void updateMuxButtons() {
    // Cycle through Mux Button array_

    for (int i = 0; i < NUMBER_MUX_BUTTONS; i = i + 1) {

    _ MUXBUTTONS->muxUpdate();

    byte message = MUXBUTTONS->getValue();

    // Button is pressed

    if (message == 0) {

    switch (MUXBUTTONS->Bcommand) {

    case 0: //Note

    MIDI.sendNoteOn(MUXBUTTONS->Bvalue, 127, MUXBUTTONS->Bchannel);

    break;

    case 1: //CC

    MIDI.sendControlChange(MUXBUTTONS->Bvalue, 127, MUXBUTTONS->Bchannel);

    break;

    case 2: //Toggle

    if (MUXBUTTONS->Btoggle == 0) {

    MIDI.sendControlChange(MUXBUTTONS->Bvalue, 127, MUXBUTTONS->Bchannel);

    MUXBUTTONS->Btoggle = 1;

    }

    else if (MUXBUTTONS->Btoggle == 1) {

    MIDI.sendControlChange(MUXBUTTONS->Bvalue, 0, MUXBUTTONS->Bchannel);

    MUXBUTTONS->Btoggle = 0;

    }

    break;

    }

    }

    // Button is not pressed

    if (message == 1) {

    switch (MUXBUTTONS->Bcommand) {

    case 0:

    MIDI.sendNoteOff(MUXBUTTONS->Bvalue, 0, MUXBUTTONS->Bchannel);

    break;

    case 1:

    MIDI.sendControlChange(MUXBUTTONS->Bvalue, 0, MUXBUTTONS->Bchannel);

    * break;
    }
    }
    }
    }
    //***********************************************************************
    void updatePots() {_

    for (int i = 0; i < NUMBER_POTS; i = i + 1) {
    _ byte potmessage = POTS->getValue();
    if (potmessage != 255) MIDI.sendControlChange(POTS->Pcontrol, potmessage, POTS->Pchannel);
    }
    }
    //***********************************************************************
    void updateMuxPots() {_

    for (int i = 0; i < NUMBER_MUX_POTS; i = i + 1) {
    _ MUXPOTS->muxUpdate();
    byte potmessage = MUXPOTS->getValue();
    if (potmessage != 255) MIDI.sendControlChange(MUXPOTS->Pcontrol, potmessage, MUXPOTS->Pchannel);
    }
    }*

    Please let me know the changes I need to make.
    Thank you._

CODE ATTACHED.

MIDI_Controller_v1-2.ino (2.55 KB)

Hello, try the bounce library. It can check for falling edge and rising edge => the button is pressed / released.

You can find an overview of its basic usage here: Bounce Library, for Easily Reading Pushbuttons or Mechanical Sensors With Contacts That "Bounce"

Hope that helps

Are you building a midi controller that uses buttons only?