Button stops returning 'Pressed' or 'Released'

[MickeyGentry]

I don't think I'm using the Button class correctly but here goes. I have a physical latching pushbutton and I only want to know when it's been pushed, which would also be latched. As long as it's latched I want to do something. (Run through an array actually but that's not in the code here.) What happens with the snippet below (full code also farther below) is I click the latched pushbutton and it goes 6 or 8 or 9 times and then stops. It's not consistent. Thanks for any help or suggestions of ways to use other classes in Control-Surface for a simple latching pushbutton. AND thanks for providing this library!

    if(clickerButton.update() == 3 ){
      Serial.print("clicker button getState(): ");
      Serial.println(clickerButton.getState());
      Serial.print("clicker button UPDATE: ");
      Serial.println(clickerButton.update());
      // Add code to run through dérive preset set
      for (int i = 0; i <= 4; i++){
        Serial.print(" - preset value: ");
        Serial.println(ipresetSet[i]);
        delay(300);
      }

Full sketch:

#include "SPI.h"
#include "Adafruit_GFX.h"
#include "Adafruit_ILI9341.h"
// Encoder library compiles, size 87%
// #include <EncoderButton.h>
// https://github.com/Stutchbury/EncoderButton/blob/main/examples/Basic/Basic.ino

#include <Control_Surface.h>  // Include the Control Surface library
// https://tttapa.github.io/Control-Surface-doc/Doxygen/d0/d0c/group__Selectors.html


/******************** ADAFRUIT ********************************************/
// For the Adafruit shield, these are the default.
#define TFT_DC 9
#define TFT_CS 10

// Use hardware SPI (on Uno, #13, #12, #11) and the above for CS/DC
Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC);
/************************************************************************/

/******************** Control_Surface ********************************************/
// Instantiate a MIDI over USB interface
 //- not for Rx/Tx
//USBMIDI_Interface midi; 
// For direct connect to USB HOST board via Rx/Tx
HardwareSerialMIDI_Interface midi {Serial1};  

// Instantiate a program changer with 128 programs, max of the C4
// USING UP TO 50 FOR NOW
ProgramChanger<50> programChanger{
  { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
    21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
    41, 42, 43, 44, 45, 46, 47, 48, 49 },
  CHANNEL_1,  // MIDI channel to use
};

// Instantiate a selector to control which one of the programs is active
IncrementDecrementSelector<50> selector = {
  programChanger,  // what to select
  { 5, 6 },        // push button pins (increment, decrement)
  Wrap::Wrap,      // wrap around if min/max program is reached
};

// DErive on/off footswitch toggle
Button clickerButton {12};


// The pin with the LED connected:
const pin_t ledPin = LED_BUILTIN;

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

/*********************** Rotary code *********************************/

#include <RotaryEncoder.h>

#define rtyCLK_PresetSelect 4
#define rtyDT_PresetSelect 3

#define rtyCLK_SpeedSelect 20
#define rtyDT_SpeedSelect 19


// Push buttons for rotaries
Button btnDEriveSelect {2}; //Object from Control_Surface
Button btnRandoSelect {18}; //Object from Control_Surface

// A pointer to the dynamic created rotary encPresetSelect instance.
// This will be done in setup()
RotaryEncoder *encPresetSelect = nullptr;
RotaryEncoder *encSpeedSelect = nullptr;

// used in interrupt code in setup()
void checkPosition()
{
  encPresetSelect->tick(); // just call tick() to check the state.
  encSpeedSelect->tick(); // just call tick() to check the state.
}


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


/**************** PRESET NAMES ******************************************
Strings representing preset names copied from Neuro Desktop
Setting up the strings is a two-step process because the Micro needs to
use the PROGMEMory to store the names. Not enough RAM!
First, define the strings.
****************************************************************/
const char string_1[] PROGMEM = "Chiptune Vibe";
const char string_2[] PROGMEM = "FM Sndz";
const char string_3[] PROGMEM = "Twin Some";
const char string_4[] PROGMEM = "Flanger";
const char string_5[] PROGMEM = "Guitar Basic C";
const char string_6[] PROGMEM = "Tom's Tremelo";
const char string_7[] PROGMEM = "DD wobble fu";
const char string_8[] PROGMEM = "Poppi Filter";
const char string_9[] PROGMEM = "SM Stro Funk";
const char string_10[] PROGMEM = "SM MonoDrtFlt";
const char string_11[] PROGMEM = "SM LoFi Chors";
const char string_12[] PROGMEM = "Rock Organ";
const char string_13[] PROGMEM = "DD Phz Wah";
const char string_14[] PROGMEM = "chinese Trem";
const char string_15[] PROGMEM = "Rising Tremol";
const char string_16[] PROGMEM = "Harmonic Tre";
const char string_17[] PROGMEM = "HP42 Square ";
const char string_18[] PROGMEM = "bnzz-Dirty Trem";
const char string_19[] PROGMEM = "Tremvelope";
const char string_20[] PROGMEM = "Dirty Trem";
const char string_21[] PROGMEM = "octave fuzz";
const char string_22[] PROGMEM = "Bass PolyCho";
const char string_23[] PROGMEM = "Envelope Cho";
const char string_24[] PROGMEM = "Fuzzy Dunlop";
const char string_25[] PROGMEM = "QM Chors";
const char string_26[] PROGMEM = "DD Fuzz Chorus";
const char string_27[] PROGMEM = "ChorusMono";
const char string_28[] PROGMEM = "Classic Phaser";
const char string_29[] PROGMEM = "Slow rotry";
const char string_30[] PROGMEM = "DD Phase Wa";
const char string_31[] PROGMEM = "Phz Slapbac";
const char string_32[] PROGMEM = "Stereo Phaser";
const char string_33[] PROGMEM = "Roy's Phase 9";
const char string_34[] PROGMEM = "EnvPhaser";
const char string_35[] PROGMEM = "3-Stage Phas";
const char string_36[] PROGMEM = "Simple Bit Crsh";
const char string_37[] PROGMEM = "Da Funk";
const char string_38[] PROGMEM = "Sprinkle Donu";
const char string_39[] PROGMEM = "The Funky Ro";
const char string_40[] PROGMEM = "Everybody In ";
const char string_41[] PROGMEM = "N Bitcrshr";
const char string_42[] PROGMEM = "LoweryOrgan";
const char string_43[] PROGMEM = "ORGANSTAR";
const char string_44[] PROGMEM = "BrgainSynth";
const char string_45[] PROGMEM = "Toothy Twins";
const char string_46[] PROGMEM = "HarpsiChord";
const char string_47[] PROGMEM = "flute vibro";
const char string_48[] PROGMEM = "Moog Bass";
const char string_49[] PROGMEM = "Grunty";
const char string_50[] PROGMEM = "fm";

// Then set up a string table in program memory to 
// refer to your string arrays from above.
const char *const string_table[] PROGMEM = {
  string_1,
  string_2,
  string_3,
  string_4,
  string_5,
  string_6,
  string_7,
  string_8,
  string_9,
  string_10,
  string_11,
  string_12,
  string_13,
  string_14,
  string_15,
  string_16,
  string_17,
  string_18,
  string_19,
  string_20,
  string_21,
  string_22,
  string_23,
  string_24,
  string_25,
  string_26,
  string_27,
  string_28,
  string_29,
  string_30,
  string_31,
  string_32,
  string_33,
  string_34,
  string_35,
  string_36,
  string_37,
  string_38,
  string_39,
  string_40,
  string_41,
  string_42,
  string_43,
  string_44,
  string_45,
  string_46,
  string_47,
  string_48,
  string_49,
  string_50
};

char buffer[16];  // make sure this is large enough for the largest string it must hold
                  // 15 character preset names = 16 item buffer
/**************************End Preset Names Arrays************************************/


/************* Preset Back and Forth Vars *******************************/
uint8_t iComparator = 0;    // compare current preset to newly chosen preset

// INT to retrieve or set current preset number as index to string names array
uint8_t iCurrentPreset; 
uint8_t iPreviousPreset; 
uint8_t iNextPreset; 

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

/*** All TFT / AdaFruit display code *************************************/
void resetDisplay(uint8_t iCurrentPreset)
{
    // Display preset number upper top, add '1' to account for zero based arrays

    tft.fillRect(139, 8, 35, 21, ILI9341_GREENYELLOW);
    tft.setTextColor(ILI9341_BLACK);
    tft.setCursor(140, 8);
    tft.print(iCurrentPreset + 1); 

    /* Using the string table in program memory requires the use of special functions to retrieve the data.
     The strcpy_P function copies a string from program space to a string in RAM ("buffer").
     Make sure your receiving string in RAM is large enough to hold whatever
     you are retrieving from program space. 
    */

    // set previous and next preset names accounding for 
    // wrap around of 50 names list
    iPreviousPreset = iCurrentPreset - 1;
    if (iCurrentPreset == 0) 
      iPreviousPreset = 49;

    iNextPreset = iCurrentPreset + 1;
    if (iCurrentPreset == 49) 
      iNextPreset = 0;

// Create rectangles to clear text without resetting the whole screen.

    // draw line rectagle around current preset 
    tft.drawRect(3, 88, 285, 54, ILI9341_BLACK);
    tft.fillRect(5, 90, 281, 50, ILI9341_WHITE);

    // Display Current preset name
    strcpy_P(buffer, (char *)pgm_read_word(&(string_table[iCurrentPreset]))); 
    tft.setTextColor(ILI9341_BLACK);
    tft.setCursor(11, 105); // indent current preset to 11 pixels
    tft.print(buffer); // Display present name

    // display previous preset name
    tft.fillRect(5, 40, 270, 25, ILI9341_GREENYELLOW);
    strcpy_P(buffer, (char *)pgm_read_word(&(string_table[iPreviousPreset]))); 
    tft.setTextColor(ILI9341_MAGENTA);
    tft.setCursor(6, 40);
    tft.print(buffer); // Display present name

    // display next preset name
    tft.fillRect(5, 185, 270, 25, ILI9341_GREENYELLOW);
    strcpy_P(buffer, (char *)pgm_read_word(&(string_table[iNextPreset]))); 
    tft.setTextColor(ILI9341_BLUE);
    tft.setCursor(6, 185);
    tft.print(buffer); // Display present name

}

/******************** derive array code *********************************
RunDerive() will be called every loop so we can't define the arrays and
indexes inside the function. Otherwise the array will be cleared again and
again.

*/
// declare int array for 5 items, zero based
// dérive Type 1 has 5 presets for running through
int ipresetSet[5];
int index = 0;
/************************************************************************/
void RunDerive(){

// WORKING BUT TOGGLE on SEEMS TO NOT STAY ON!!!!

  /* Add 5 numeric values to the ipresetSet array */      

  if (btnDEriveSelect.update() == Button::Falling) {

    if(index > 4)
      index = 0;
    // Store preset number
    ipresetSet[index] = selector.get();
    Serial.print("Current preset index: ");
    Serial.print(index);
    Serial.print(" - preset value: ");
    Serial.println(ipresetSet[index]);
    ++index;
  }
  
/* When array is loaded, or anytime really, 
  check for toggle switch down, if down
  send array values in a speed controlled loop
  via 'selector.set(pos)' where 'pos' is the 
  value returned from the array.

  If btnRandoSelect is pressed change from running 
  through the array in a loop to running through
  the array randomly, randomize 0 to 4 as index numbers
  //**************************************************************
  // Speed TEST code and Rando
  encSpeedSelect->tick(); // just call tick() to check the state.


  if (btnRandoSelect.update() == Button::Falling) {
    
    //digitalWrite(ledPin,HIGH);
    Serial.println(encSpeedSelect->getPosition());
  }
  //**************************************************************
// Toggle footswitch TEST code
    // outputs a 0/'Pressed' or a 3/'Released'. */
    if(clickerButton.update() == 3 ){
      Serial.print("clicker button getState(): ");
      Serial.println(clickerButton.getState());
      Serial.print("clicker button UPDATE: ");
      Serial.println(clickerButton.update());
      // Add code to run through dérive preset set
      for (int i = 0; i <= 4; i++){
        Serial.print(" - preset value: ");
        Serial.println(ipresetSet[i]);
        delay(300);
      }


    /*
      Serial.print("clicker button getState(): ");
      Serial.println(clickerButton.getState());
      Serial.print("clicker button UPDATE: ");
      Serial.println(clickerButton.update());
      //delay(100);  // this will be set by the rotary encSpeedSelect

    */
    }

}
//***********************************************************************
/*************************** derive array code END **********************/


void setup() {
  Control_Surface.begin();  // Initialize Control Surface

  // use FOUR3 mode when rtyCLK_PresetSelect, rtyDT_PresetSelect signals are always HIGH in latch position.
  encPresetSelect = new RotaryEncoder(rtyDT_PresetSelect, rtyCLK_PresetSelect, RotaryEncoder::LatchMode::FOUR3);
  encSpeedSelect = new RotaryEncoder(rtyDT_SpeedSelect, rtyCLK_SpeedSelect, RotaryEncoder::LatchMode::FOUR3);

  // register interrupt routines
  attachInterrupt(digitalPinToInterrupt(rtyCLK_PresetSelect), checkPosition, CHANGE);
  attachInterrupt(digitalPinToInterrupt(rtyDT_PresetSelect), checkPosition, CHANGE);

  attachInterrupt(digitalPinToInterrupt(rtyCLK_SpeedSelect), checkPosition, CHANGE);
  attachInterrupt(digitalPinToInterrupt(rtyDT_SpeedSelect), checkPosition, CHANGE);

  // set up for display
  tft.begin();
  tft.setRotation(3);
  tft.setTextWrap(false);    
  tft.setTextSize(3);
  
  // 'clear' screen
  tft.fillScreen(ILI9341_GREENYELLOW);
  // starting display
  resetDisplay(0);
}

void loop() {
  Control_Surface.loop(); // Update the Control Surface


RunDerive();


//***********************************************************
// Preset selection and check for 50 presets turnaround
  static int pos = 0;
  encPresetSelect->tick(); // just call tick() to check the state.

  // Get rotary number
  int newPos = encPresetSelect->getPosition();
    // Implement turn around
    if(newPos > 49){
      encPresetSelect->setPosition(0);
      newPos = 0;
    }
    if(newPos < 0){
      encPresetSelect->setPosition(49);
      newPos = 49;
    }
      
  if (pos != newPos) {
    // Serial.print("pos:");
    // Serial.print(newPos);
    // Serial.print(" dir:");
    // Serial.println((int)(encPresetSelect->getDirection()));
    pos = newPos;

    selector.set(pos);
  } // if
//**************************************************************

  // access the Control_Surface object 'selector' and return the preset number it sent to the pedal
  iCurrentPreset = selector.get();


  // Only update the display when the preset choice changes
  if (iComparator != iCurrentPreset)
  {
    // Comport changes via buttons with rotary settings
    encPresetSelect->setPosition(iCurrentPreset);
    resetDisplay(iCurrentPreset);

    // Output slows dramaically when displaying
    //Serial.println(iCurrentPreset);
    // set comparator to the current preset
    iComparator = iCurrentPreset;
  }
} //loop

[tttapa]

What happens with the snippet below (full code also farther below) is I click the latched pushbutton and it goes 6 or 8 or 9 times and then stops. It's not consistent.

I'm not sure I understand what you mean. Could you demonstrate with a shorter example?

The Button class only returns one of Button::{Falling,Rising,Pressed,Released}. The Button::update() function reads the input pin and returns the new state or state transition, and the Button::getState() function always returns the same value as the previous call to Button::update().

[MickeyGentry]

Great thank you. I’m going to restructure what I have and try again. If I have the same problem I’ll make a simple sketch and try to recreate it.

Thanks again.

[MickeyGentry]

Welp, if you knock the switch around on the desk and it randomly returns Pressed or Falling the problem ain’t the code.

It’s probably 40 years old but clean and clicky. Oh well, game over thanks for playing.

[MickeyGentry]

So I put a different switch in place and tried again. In the On position the code always returns it as Pressed or Falling. When I switch it off the loop stops but if I just touch the switch it starts up again as if it’s returning a Pressed or Falling. So basically the same problem.

I double checked if the metal button was grounding out, it’s not.

Is this a switch problem or perhaps the debounce is too short?

Thoughts?

thanks!

[tttapa]

This does not sound right. Could you post a minimal example?

Quickly scanning through your long code: where is the call to clickerButton.begin()?

[MickeyGentry]

There is no call to .begin() for clickerButton or the other buttons, but the others are working as expected so I didn’t know that was needed. I can certainly add that referencing the examples and see how it goes.

I know you asked for a simple sketch and I tried to make one with just

#include <Control_Surface.h>
…
void setup() {
  Control_Surface.begin();
  …
void loop() {
  Control_Surface.loop();
  …

It compiled but wouldn’t run anything. Not much help I know. I will copy one of your simple examples and drop my switch into it.

I was pretty much resigned to just not using that physical toggle switch. This is a prototype pedal so it’s not essential. If you’re saying that kind of switch can work, maybe you’ve used them, I will work with it a bit more.

I DO appreciate your help and the library.

[MickeyGentry]

Quick update. I used your CountPressedButtons.ino to test the latching switch with the other switches and it worked fine. No 'ghost' on or off when touching it.

Lemmy try calling the .begin() like it's supposed to be! I'll let you know how it goes.

thanks.

[MickeyGentry]

Final update, it works right when it's coded right! I put in the.begin() calls for all the buttons and it's all good. I guess those darn little pull up resistors are needed!

Thanks again for your help.

[tttapa]

It compiled but wouldn’t run anything. Not much help I know. I will copy one of your simple examples and drop my switch into it.

Possible issue: Control_Surface.begin() will throw an error if no MIDI interfaces are available.