Issues with rotary encoders on arduino mega with a lot of other components

[MoSaye]

hello pieter,

so i have around 64 buttons, 24 potentiometers and 13 rotary encoders, 11 of them are ky040 modules and 2 are 360ppr ones, so when i put the code of the rotary encoders alone they work fine, but when i combine the code of the encoders with the other modules, the encoders giver weird results, and they are not working as intended, keep in mine i cannot have access to an MCP multiplexer, because i live in the middle east, the project is using an arduino mega, and the code is written below, how can i make the readings of the encoders more stable?

#include <Encoder.h>
#include <Control_Surface.h>

HairlessMIDI_Interface midinator {115200};

using namespace MIDI_Notes;



//----------------------------------------------------------------------------------{
  //Faders
CD74HC4067 mux1  {
  A0,
  {2, 3, 4, 5} 
};
  //Pots
CD74HC4067 mux2  {
  A1,
  {6, 7, 8, 9} 
};
  //Buttons
CD74HC4067 mux3  {
  A2,
  {10, 11, 12, 13} 
};
  //Buttons
CD74HC4067 mux4  {
  A3,
  {14, 15, 16, 17} 
};
  //Buttons
CD74HC4067 mux5  {
  A4,
  {18, 19, 20, 21} 
};
  //Buttons
CD74HC4067 mux6  {
  A5,
  {22, 23, 24, 25} 
};
//----------------------------------------------------------------------------------{


CCPotentiometer PotsFaders[] = {
  {mux1.pin(0), {0x00}},
  {mux1.pin(1), {0x01}},
  {mux1.pin(2), {0x02}},
  {mux1.pin(3), {0x03}},
  {mux1.pin(4), {0x04}},
  {mux1.pin(5), {0x05}},
  {mux1.pin(6), {0x06}},
  {mux1.pin(7), {0x07}},
  {mux1.pin(8), {0x08}},
  {mux1.pin(9), {0x09}},
  {mux1.pin(10), {0x0A}},
  //-----
  {mux2.pin(0), {0x10}},
  {mux2.pin(1), {0x11}},
  {mux2.pin(2), {0x12}},
  {mux2.pin(3), {0x13}},
  {mux2.pin(4), {0x14}},
  {mux2.pin(5), {0x15}},
  {mux2.pin(6), {0x16}},
  {mux2.pin(7), {0x17}},
  {mux2.pin(8), {0x18}},
  {mux2.pin(9), {0x19}},
  {mux2.pin(10), {0x1A}},
};


//----------------------------------------------------------------------------------}



NoteButton Buttons[] = {
  {mux3.pin(0), {note:0x00, CHANNEL_1}},
  {mux3.pin(1), {note:0x01, CHANNEL_1}},
  {mux3.pin(2), {note:0x02, CHANNEL_1}},
  {mux3.pin(3), {note:0x03, CHANNEL_1}},
  {mux3.pin(4), {note:0x04, CHANNEL_1}},
  {mux3.pin(5), {note:0x05, CHANNEL_1}},
  {mux3.pin(6), {note:0x06, CHANNEL_1}},
  {mux3.pin(7), {note:0x07, CHANNEL_1}},
  {mux3.pin(8), {note:0x08, CHANNEL_1}},
  {mux3.pin(9), {note:0x09, CHANNEL_1}},
  {mux3.pin(10), {note:0x0A, CHANNEL_1}},
  {mux3.pin(11), {note:0x0B, CHANNEL_1}},
  {mux3.pin(12), {note:0x0C, CHANNEL_1}},
  {mux3.pin(13), {note:0x0D, CHANNEL_1}},
  {mux3.pin(14), {note:0x0E, CHANNEL_1}},
  {mux3.pin(15), {note:0x0F, CHANNEL_1}},
  //----
  {mux4.pin(0), {note:0x10, CHANNEL_1}},
  {mux4.pin(1), {note:0x11, CHANNEL_1}},
  {mux4.pin(2), {note:0x12, CHANNEL_1}},
  {mux4.pin(3), {note:0x13, CHANNEL_1}},
  {mux4.pin(4), {note:0x14, CHANNEL_1}},
  {mux4.pin(5), {note:0x15, CHANNEL_1}},
  {mux4.pin(6), {note:0x16, CHANNEL_1}},
  {mux4.pin(7), {note:0x17, CHANNEL_1}},
  {mux4.pin(8), {note:0x18, CHANNEL_1}},
  {mux4.pin(9), {note:0x19, CHANNEL_1}},
  {mux4.pin(10), {note:0x1A, CHANNEL_1}},
  {mux4.pin(11), {note:0x1B, CHANNEL_1}},
  {mux4.pin(12), {note:0x1C, CHANNEL_1}},
  {mux4.pin(13), {note:0x1D, CHANNEL_1}},
  {mux4.pin(14), {note:0x1D, CHANNEL_1}},
  {mux4.pin(15), {note:0x1F, CHANNEL_1}},
  //=====
  {mux5.pin(0), {note:0x20, CHANNEL_1}},
  {mux5.pin(1), {note:0x21, CHANNEL_1}},
  {mux5.pin(2), {note:0x22, CHANNEL_1}},
  {mux5.pin(3), {note:0x23, CHANNEL_1}},
  {mux5.pin(4), {note:0x24, CHANNEL_1}},
  {mux5.pin(5), {note:0x25, CHANNEL_1}},
  {mux5.pin(6), {note:0x26, CHANNEL_1}},
  {mux5.pin(7), {note:0x27, CHANNEL_1}},
  {mux5.pin(8), {note:0x28, CHANNEL_1}},
  {mux5.pin(9), {note:0x29, CHANNEL_1}},
  {mux5.pin(10), {note:0x2A, CHANNEL_1}},
  {mux5.pin(11), {note:0x2B, CHANNEL_1}},
  {mux5.pin(12), {note:0x2C, CHANNEL_1}},
  {mux5.pin(13), {note:0x2D, CHANNEL_1}},
  {mux5.pin(14), {note:0x2E, CHANNEL_1}},
  {mux5.pin(15), {note:0x2F, CHANNEL_1}},
  //=====
  {mux6.pin(0), {note:0x30, CHANNEL_1}},
  {mux6.pin(1), {note:0x31, CHANNEL_1}},
  {mux6.pin(2), {note:0x32, CHANNEL_1}},
  {mux6.pin(3), {note:0x33, CHANNEL_1}},
  {mux6.pin(4), {note:0x34, CHANNEL_1}},
  {mux6.pin(5), {note:0x35, CHANNEL_1}},
  {mux6.pin(6), {note:0x36, CHANNEL_1}},
  {mux6.pin(7), {note:0x37, CHANNEL_1}},
  {mux6.pin(8), {note:0x38, CHANNEL_1}},
  {mux6.pin(9), {note:0x39, CHANNEL_1}},
  {mux6.pin(10), {note:0x3A, CHANNEL_1}},
  {mux6.pin(11), {note:0x3B, CHANNEL_1}},
  {mux6.pin(12), {note:0x3C, CHANNEL_1}},
  {mux6.pin(13), {note:0x3D, CHANNEL_1}},
  {mux6.pin(14), {note:0x3E, CHANNEL_1}},
  {mux6.pin(15), {note:0x3F, CHANNEL_1}},
};

//----------------------------------------------------------------------------------}


// Instantiate a CCAbsoluteEncoder object
CCAbsoluteEncoder enc {
  {26, 27},       // pins
  {0x20}, // MIDI address (CC number + optional channel)
  1,            // optional multiplier if the control isn't fast enough
};

CCAbsoluteEncoder enc1 {
  {28, 29},       // pins
  {0x21}, // MIDI address (CC number + optional channel)
  1,            // optional multiplier if the control isn't fast enough
};

CCAbsoluteEncoder enc2 {
  {30, 31},       // pins
  {0x22}, // MIDI address (CC number + optional channel)
  1,            // optional multiplier if the control isn't fast enough
};

CCAbsoluteEncoder enc3 {
  {32, 33},       // pins
  {0x23}, // MIDI address (CC number + optional channel)
  1,            // optional multiplier if the control isn't fast enough
};

CCAbsoluteEncoder enc4 {
  {34, 35},       // pins
  {0x24}, // MIDI address (CC number + optional channel)
  1,            // optional multiplier if the control isn't fast enough
};

CCAbsoluteEncoder enc5 {
  {36, 37},       // pins
  {0x25}, // MIDI address (CC number + optional channel)
  1,            // optional multiplier if the control isn't fast enough
};

CCAbsoluteEncoder enc6 {
  {38, 39},       // pins
  {0x26}, // MIDI address (CC number + optional channel)
  1,            // optional multiplier if the control isn't fast enough
};

CCAbsoluteEncoder enc7 {
  {40, 41},       // pins
  {0x27}, // MIDI address (CC number + optional channel)
  1,            // optional multiplier if the control isn't fast enough
};

CCAbsoluteEncoder enc8 {
  {42, 43},       // pins
  {0x28}, // MIDI address (CC number + optional channel)
  1,            // optional multiplier if the control isn't fast enough
};

CCAbsoluteEncoder enc9 {
  {44, 45},       // pins
  {0x29}, // MIDI address (CC number + optional channel)
  1,            // optional multiplier if the control isn't fast enough
};

CCAbsoluteEncoder enc10 {
  {46, 47},       // pins
  {0x2A}, // MIDI address (CC number + optional channel)
  1,            // optional multiplier if the control isn't fast enough
};

CCAbsoluteEncoder enc11 {
  {48, 49},       // pins
  {0x2B}, // MIDI address (CC number + optional channel)
  1,            // optional multiplier if the control isn't fast enough
};

CCRotaryEncoder enc360A {
  {50, 51},       // pins
  {0x2C}, // MIDI address (CC number + optional channel)
  1,            // optional multiplier if the control isn't fast enough
};

CCRotaryEncoder enc360B {
  {52, 53},       // pins
  {0x2D}, // MIDI address (CC number + optional channel)
  1,            // optional multiplier if the control isn't fast enough
};







// Initialize the Control Surface
void setup() {
  RelativeCCSender::setMode(relativeCCmode::MACKIE_CONTROL_RELATIVE);
  Control_Surface.begin();
  Serial.begin(115200);
}

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

[MoSaye]

[Trickster-git]

Hi, i has same problem too, when connect to mega encoder and multiplexor in result encoder worked not correct, if disconnect multiplexer, encoder work fine.

[tttapa]

An encoder requires frequent polling to work correctly. If you turn it too quickly, so that the time between pulses becomes shorter than your polling rate, you will miss pulses, and it no longer works.

Reading the analog values of 24 potentiometers takes an eternity, relatively speaking. The Mega simply cannot do this fast enough, and it cannot poll the encoders while reading the potentiometers at the same time.

There are multiple possible workarounds:

1. Make sure that other parts of the code never take longer than a given threshold, and interleave them with polling of the encoders (e.g. read all encoders after reading a single potentiometer, instead of reading all potentiometers in a single pass).
2. Use a timer interrupt to guarantee a fixed polling rate of the encoders.
3. Use external interrupts to detect encoder pulses without polling.

Option 3 is definitely the best one, but the Mega may not provide enough external and pin change interrupts for this to work. Control Surface enables external interrupts automatically for its default encoder classes, but only for pins that support it (see this table).
To use pin change interrupts (PCINT), you need to do some manual plumbing, but this is relatively easy if you start from this example: https://tttapa.github.io/Control-Surface-doc/Doxygen/d6/dd2/Pin-Change-Interrupt-Encoders_8ino-example.html
Be sure to read the ATmega2560 datasheet, though, the example is for the ATmega328P, which uses slightly different registers.

Option 1 requires changing the whole program, and is not always feasible, especially in a framework like Control Surface, which relies on cooperative multitasking. I have considered some ideas to improve the performance of multiplexers and analogRead in general, but implementing them would complicate things for all users, even for the 99% that don't need such features.

That leaves option 2. You can find code polling 20 encoders using an Arduino Mega in this forum post: https://forum.arduino.cc/t/control-surface-library-encoder-the-full-adventure-with-presonus-studio-one/869572/58
It is based on this example which you can use as a simpler starting point: https://tttapa.github.io/Control-Surface-doc/Doxygen/da/dda/Timer-Interrupt-Encoders_8ino-example.html

[MoSaye]

thanks a lot for the full explanation and the options, I tried the code that polls 20 encoders from the forum post you linked, and it worked great, I will just have to change some wiring and connections to avoid conflicts in the code, I will have to investigate more on whether this can be done with bankable encoders or with the borrowed method to change between absolute and relative encoder methods, if you have any suggestions on this or where to start that will be great.

Thanks again for working on this great library

[tttapa]

Yes, this can be done for Bankable encoders as well. You don't need to do anything special to make them borrowed: the encoders in a RegisterEncoder are shared by default.