Buttons with mplexCallbacks and 32 encoder limit for 74165

[mrdave45]

Hi,
Ive been building the shift register encoder circuit based on 3x 74hc165 to read encoders and 8 buttons.
Ive managed to get the encoder working very nicely on full mode (96 ppr out of a 24ppr rot enc). However, Im struggling to see how I get the buttons read in. I see in one of the libs there's attachButtonCallBack but I have no idea how I should call that.

Also, Ive seen in the documentation that you can only use up to 32 encoders here. Im unsure why that is, wouldnt the shift registers just keep getting clocked for the length on the encoderCount loop? Is there really only a limit of chaining 4 banks togther? On another project ive chained 9 shift regs (AHCT595) together and clocked them at 17Mhz and theyve been fine taking 4.4uS to write to the 72 pins.

If it is something like its writing to a 32bit variable, could that be made a 64 bit variable? Or can i just use another set of pins and have something like:

EncPlex74165 encoders1(encoderCount1, pinLD1, pinCLK1, QH_A1, QH_B1, QH_S1);
EncPlex74165 encoders2(encoderCount2, pinLD2, pinCLK2, QH_A2, QH_B2, QH_S2);

I gather that callbacks is preferable over polliing. I will be incorporating this in to code that writes to i2c oleds as well.

Heres my slightly modified version of the mplexCallbacks code. Any suggestions of where to go next welcome. Thanks.

#include "Arduino.h"
#include "EncoderTool.h"

#if defined(ESP32)
#    define LED_BUILTIN 2
#endif

using namespace EncoderTool;

constexpr unsigned encoderCount = 8; //number of attached  (daisy chain shift regesters for more than 8)

constexpr unsigned QH_A   = 2; // output pin QH of shift register B
constexpr unsigned QH_B   = 3; // output pin QH of shift register A
constexpr unsigned pinLD  = 4; // load pin for all shift registers)
constexpr unsigned pinCLK = 5; // clock pin for all shift registers
constexpr unsigned QH_S   = 6; // output pin QH of shift register S
                               // 74165 datasheet: http://www.ti.com/product/SN74HC165

EncPlex74165 encoders(encoderCount, pinLD, pinCLK, QH_A, QH_B, QH_S);

void onFirstEncoder(int value, int delta)
{
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
}

void onAnyEncoder(uint8_t channel, int value, int delta)
{
    Serial.print("Encoder: ");
    Serial.print(channel);
    Serial.print(" value: ");
    Serial.print(value);
    Serial.print(" delta: ");
    Serial.print(delta);
    Serial.println();
}

void onAnyButton(uint8_t channel, int state)
{
    Serial.print("Button: ");
    Serial.print(channel);
    Serial.print(" state: ");
    Serial.print(state);
    Serial.println();
}

void setup()
{
    pinMode(LED_BUILTIN, OUTPUT);
    encoders.begin(CountMode::full);

    encoders[0].attachCallback(onFirstEncoder); // standard callback
    encoders.attachCallback(onAnyEncoder);
    
}

void loop()
{
    encoders.tick();
}

[luni64]

However, Im struggling to see how I get the buttons read in. I see in one of the libs there's attachButtonCallBack but I have no idea how I should call that.

You can read out the current button state with getButton():

#include "EncoderTool.h"
using namespace EncoderTool;

PolledEncoder enc;

void setup()
{
    enc.begin(1, 2, 3);  // encoder A= pin1, B= pin2, button = pin3
}

void loop()
{
    if(enc.buttonChanged())
    {
        Serial.println(enc.getButton());
    }
    enc.tick();
}

Also, Ive seen in the documentation that you can only use up to 32 encoders here. Im unsure why that is, wouldnt the shift registers just keep getting clocked for the length on the encoderCount loop? Is there really only a limit of chaining 4 banks togther? On another project ive chained 9 shift regs (AHCT595) together and clocked them at 17Mhz and theyve been fine taking 4.4uS to write to the 72 pins.

Actually there is no hard limit. You need to make sure that each encoder is queried often enough (about 5kHz is good). Lets assume you have 100 encoders with buttons, you need to read in 3 pins per encoder and anaylze them. If we assume it takes 5µs per encoder we end up with 500µs for all encoders which gives 1/500µs = 2kHz sampling rate which is quite low. So, ultimately you are limited by the efficiency of the code and the speed of the processor.

I gather that callbacks is preferable over polliing. I will be incorporating this in to code that writes to i2c oleds as well.

Depends on what you want to do. Using callbacks is often more convenient since you can build a "event driven" application.

Heres my slightly modified version of the mplexCallbacks code. Any suggestions of where to go next welcome. Thanks.

I don't quite understand what you want to show with the code? Can you elaborate on that?

[mrdave45]

I don't quite understand what you want to show with the code? Can you elaborate on that?

lol, in hindsight, mostly ineptitude i think.
Usually people want to see the code that one is working with, so i posted this to show it was the multiplexed callback one for anyone looking and that i was trying to add the 3rd shift reg to it.

Thanks for your reply. I will have a play around with the code you posted.

Cheers.