How to read two rotary encoder data using pigpio c++ library in raspberry pi?

Question

#include <iostream>

#include <pigpio.h>

#include "rotary_encoder.hpp"

void callback(int way)
{
   static int pos = 0;

   pos += way;

   std::cout << "pos=" << pos << std::endl;
}

int main(int argc, char *argv[])
{
   if (gpioInitialise() < 0) return 1;

   re_decoder dec(7, 8, callback);

   sleep(3000);

   dec.re_cancel();

   gpioTerminate();
}

rotary_encoder.hpp

#ifndef ROTARY_ENCODER_HPP
#define ROTARY_ENCODER_HPP

#include <stdint.h>

typedef void (*re_decoderCB_t)(int);

class re_decoder
{
   int mygpioA, mygpioB, levA, levB, lastGpio;

   re_decoderCB_t mycallback;

   void _pulse(int gpio, int level, uint32_t tick);

   /* Need a static callback to link with C. */
   static void _pulseEx(int gpio, int level, uint32_t tick, void *user);


   public:

   re_decoder(int gpioA, int gpioB, re_decoderCB_t callback);
   /*
      This function establishes a rotary encoder on gpioA and gpioB.

      When the encoder is turned the callback function is called.
   */

   void re_cancel(void);
   /*
      This function releases the resources used by the decoder.
   */
};

#endif

rotary_encoder.cpp

#include <iostream>

#include <pigpio.h>

#include "rotary_encoder.hpp"

void re_decoder::_pulse(int gpio, int level, uint32_t tick)
{
   if (gpio == mygpioA) levA = level; else levB = level;

   if (gpio != lastGpio) /* debounce */
   {
      lastGpio = gpio;

      if ((gpio == mygpioA) && (level == 1))
      {
         if (levB) (mycallback)(1);
      }
      else if ((gpio == mygpioB) && (level == 1))
      {
         if (levA) (mycallback)(-1);
      }
   }
}

void re_decoder::_pulseEx(int gpio, int level, uint32_t tick, void *user)
{
   /*
      Need a static callback to link with C.
   */

   re_decoder *mySelf = (re_decoder *) user;

   mySelf->_pulse(gpio, level, tick); /* Call the instance callback. */
}

re_decoder::re_decoder(int gpioA, int gpioB, re_decoderCB_t callback)
{
   mygpioA = gpioA;
   mygpioB = gpioB;

   mycallback = callback;

   levA=0;
   levB=0;

   lastGpio = -1;

   gpioSetMode(gpioA, PI_INPUT);
   gpioSetMode(gpioB, PI_INPUT);

   /* pull up is needed as encoder common is grounded */

   gpioSetPullUpDown(gpioA, PI_PUD_UP);
   gpioSetPullUpDown(gpioB, PI_PUD_UP);

   /* monitor encoder level changes */

   gpioSetAlertFuncEx(gpioA, _pulseEx, this);
   gpioSetAlertFuncEx(gpioB, _pulseEx, this);
}

void re_decoder::re_cancel(void)
{
   gpioSetAlertFuncEx(mygpioA, 0, this);
   gpioSetAlertFuncEx(mygpioB, 0, this);
}

Which changes I have to do in test file?

C + pigpio daemon: http://abyz.me.uk/rpi/pigpio/examples.html#pdif2_RED

Answer 1

From memory you just create another class and instantiate with either the same GPIO (if for some reason you want to read a single encoder twice) or from the GPIO connected to the new encoder.

Below I show an example (I have added a different callback2, you could probably change the code to use the same for both if you wanted to).

#include <iostream>
#include <pigpio.h>
#include "rotary_encoder.hpp"

void callback(int way)
{
   static int pos = 0;

   pos += way;
   std::cout << "pos=" << pos << std::endl;
}

void callback2(int way)
{
   static int pos = 0;

   pos += way;
   std::cout << "pos2=" << pos << std::endl;
}

int main(int argc, char *argv[])
{
   if (gpioInitialise() < 0) return 1;

   re_decoder dec(7, 8, callback);
   re_decoder dec2(17, 18, callback2);

   sleep(3000);

   dec.re_cancel();
   dec2.re_cancel();

   gpioTerminate();
}