Rotary Encoder Module I2C

 /* @brief Read module basic information
  * @param pbuf Address to store the readings
  *             The first element: Module PID
  *             The second element: Module VID
  *             The third element: Firmware version 
  *             The fourth element: Module communication address 
  */
  void readBasicInfo(uint16_t* pbuf);
  /**
  * @brief Get encoder current count value
  * @return Return value: 0-1023
  */
  uint16_t getEncoderValue(void);
  /**
  * @brief Set encoder count value 
  * @param value range[0, 1023], the setting is invalid when out of range
  */
  void setEncoderValue(uint16_t value);
  /**
  * @brief Get encoder current gain coefficient, accuracy value for rotating one detent. 
  * @n Accuracy range:1~51, max is 1(light up one LED about every 2.5 turns), max is 51(light up one LED every detent)
  * @return Return value: 1-51
  */
  uint8_t getGainCoefficient(void);
  /**
  * @brief Set encoder gain coefficient, accuracy value to rotate one detent 
  * @n Accuracy range: 1~51, max is 1(light up one LED about every 2.5 turns), max is 51(light up one LED every detent)
  * @param gainValue Range[1, 51], the setting is invalid when out of range
  */
  void setGainCoefficient(uint8_t gainValue);
  /**
  * @brief Detect if the button is pressed 
  * @return Return true if pressed, otherwise, return false
  */
  bool detectButtonDown(void);

/*!
 * @file        getData.ino
 * @brief       This demo shows how to get basic encoder information, the current count and rotation gain
 * @copyright   Copyright (c) 2010 DFRobot Co.Ltd (http://www.dfrobot.com)
 * @license     The MIT License (MIT)
 * @author      [qsjhyy](yihuan.huang@dfrobot.com)
 * @version     V1.0
 * @date        2021-09-15
 * @url         https://github.com/DFRobot/DFRobot_VisualRotaryEncoder
 */
#include <DFRobot_VisualRotaryEncoder.h>

/**
 * Instantiate an object to drive our sensor;
 * Set address according to encoder DIP switch CH1 and CH2:
 * | 1 | 2 | ADDR |
 * |---|---|------|
 * | 0 | 0 | 0x54 |
 * | 0 | 1 | 0x55 |
 * | 1 | 0 | 0x56 |
 * | 1 | 1 | 0x57 |
 */
DFRobot_VisualRotaryEncoder_I2C sensor(/*i2cAddr = */0x54, /*i2cBus = */&Wire);

void setup()
{
  Serial.begin(115200);

  // initialize sensor
  while( NO_ERR != sensor.begin() ){
    Serial.println("Communication with device failed, please check connection");
    delay(3000);
  }
  Serial.println("Begin ok!");

  /**
   * Retrieve basic information from the sensor and buffer it into basicInfo, the structure that stores information
   * Members of basicInfo structure: PID, VID, version, i2cAddr
   */
  sensor.refreshBasicInfo();

  /* Module PID, default value 0x01F6 (the highest two of the 16-bits data are used to judge SKU type: 00: SEN, 01: DFR, 10: TEL; The next 14 numbers are used as num)(SEN0502) */
  Serial.print("PID: 0x0");
  Serial.println(sensor.basicInfo.PID, HEX);

  /* Module VID, default value 0x3343(for manufacturer DFRobot) */
  Serial.print("VID: 0x");
  Serial.println(sensor.basicInfo.VID, HEX);

  /* Firmware version number: 0x0100 represents V0.1.0.0 */
  Serial.print("versions: 0x0");
  Serial.println(sensor.basicInfo.version, HEX);

  /* Module communication address, default value 0x54, module device address (0x54~0x57) */
  Serial.print("communication address:  0x");
  Serial.println(sensor.basicInfo.i2cAddr, HEX);

  /**
   * Get the encoder current gain factor, and the numerical accuracy for turning one step
   * Accuracy range：1~51，the minimum is 1 (light up one LED about every 2.5 turns), the maximum is 51 (light up one LED every one step rotation)
   * Return value range： 1-51
   */
  uint8_t gainCoefficient = sensor.getGainCoefficient();
  Serial.print("Encoder current gain coefficient: ");
  Serial.println(gainCoefficient);

  Serial.println();
  delay(1000);
}

void loop()
{
  /**
   * Get the encoder current count
   * Return value range： 0-1023
   */
  uint16_t encoderValue = sensor.getEncoderValue();
  Serial.print("The encoder current counts: ");
  Serial.println(encoderValue);

  Serial.println();
  delay(1000);
}

/*!
 * @file        setSensor.ino
 * @brief       This demo shows how to adjust gain factor of the encoder
 * @copyright   Copyright (c) 2010 DFRobot Co.Ltd (http://www.dfrobot.com)
 * @license     The MIT License (MIT)
 * @author      [qsjhyy](yihuan.huang@dfrobot.com)
 * @version     V1.0
 * @date        2021-09-15
 * @url         https://github.com/DFRobot/DFRobot_VisualRotaryEncoder
 */
#include <DFRobot_VisualRotaryEncoder.h>

/**
 * Instantiate an object to drive our sensor;
 * Set address according to encoder DIP switch:
 * | 1 | 2 | ADDR |
 * |---|---|------|
 * | 0 | 0 | 0x54 |
 * | 0 | 1 | 0x55 |
 * | 1 | 0 | 0x56 |
 * | 1 | 1 | 0x57 |
 */
DFRobot_VisualRotaryEncoder_I2C sensor(/*i2cAddr = */0x54, /*i2cBus = */&Wire);

void setup()
{
  Serial.begin(115200);// Init serial port

  // initialize the sensor
  while( NO_ERR != sensor.begin() ){
    Serial.println("Communication with device failed, please check connection");
    delay(3000);
  }
  Serial.println("Begin ok!");

  /**
   * Set the current gain factor of the encoder, accuracy value to rotate one detent 
   * Accuracy range：1~51，the minimum is 1 (light up one LED about every 2.5 turns), the maximum is 51 (light up one LED every one detent rotation)
   * gainValue range[1, 51], the setting is invalid when out of range.
   */
  sensor.setGainCoefficient(10);// The currently set accuracy value: 10

  /**
   * Get the current gain factor of the encoder, accuracy value to rotate one detent
   * Accuracy range：1~51，the minimum is 1 (light up one LED about every 2.5 turns), the maximum is 51 (light up one LED every one detent rotation)
   * return value range: 1-51
   */
  uint8_t gainCoefficient = sensor.getGainCoefficient();
  Serial.print("Encoder current gain coefficient: ");
  Serial.println(gainCoefficient);

  Serial.println();
  delay(1000);
}

void loop()
{
  /**
   * Get the encoder current count value
   * return value range: 0-1023
   */
  uint16_t encoderValue = sensor.getEncoderValue();
  Serial.print("The encoder current counts: ");
  Serial.println(encoderValue);

  Serial.println();
  delay(1000);
}

/*!
 * @file        setSensor.ino
 * @brief       Reset the encoder value to zero when the button is detected to be pressed
 * @copyright   Copyright (c) 2010 DFRobot Co.Ltd (http://www.dfrobot.com)
 * @license     The MIT License (MIT)
 * @author      [qsjhyy](yihuan.huang@dfrobot.com)
 * @version     V1.0
 * @date        2021-09-15
 * @url         https://github.com/DFRobot/DFRobot_VisualRotaryEncoder
 */
#include <DFRobot_VisualRotaryEncoder.h>

/**
 * Instantiate an object to drive our sensor;
 * Set address according to encoder DIP switch:
 * | 1 | 2 | ADDR |
 * |---|---|------|
 * | 0 | 0 | 0x54 |
 * | 0 | 1 | 0x55 |
 * | 1 | 0 | 0x56 |
 * | 1 | 1 | 0x57 |
 */
DFRobot_VisualRotaryEncoder_I2C sensor(/*i2cAddr = */0x54, /*i2cBus = */&Wire);

void setup()
{
  Serial.begin(115200);// Init serial port 

  // Initialize the sensor
  while( NO_ERR != sensor.begin() ){
    Serial.println("Communication with device failed, please check connection");
    delay(3000);
  }
  Serial.println("Begin ok!");

  /**
   * Set the current gain factor of the encoder, accuracy value to rotate one detent
   * accuracy range：1~51，the minimum is 1 (light up one LED about every 2.5 turns), the maximum is 51 (light up one LED every one detent rotation)
   * gainValue range[1, 51], the setting is invalid when out of range.
   */
  sensor.setGainCoefficient(51);// The currently set accuracy value: 51

  /**
   * Get the current gain factor of the encoder, accuracy value to rotate one detent
   * accuracy range：1~51，the minimum is 1 (light up one LED about every 2.5 turns), the maximum is 51 (light up one LED every one detent rotation)
   * return value range: 1-51
   */
  uint8_t gainCoefficient = sensor.getGainCoefficient();
  Serial.print("Encoder current gain coefficient: ");
  Serial.println(gainCoefficient);

  Serial.println();
  delay(1000);
}

void loop()
{
  /**
   * Detect if the button is pressed
   * return true when the button pressed，otherwise, return false
   */
  if(sensor.detectButtonDown()){
    /**
     * Set the encoder count value
     * value range[0, 1023], the setting is invalid when out of range
     * In this example, set the encoder value to zero when detecting the button pressed, and you can see all the LEDs that light up before turning off
     */
    sensor.setEncoderValue(0);
  }

  /**
   * Get the encoder current count 
   * return value range： 0-1023
   */
  uint16_t encoderValue = sensor.getEncoderValue();
  Serial.print("The encoder current counts: ");
  Serial.println(encoderValue);

  Serial.println();
  delay(1000);
}

  /*!
 * @file        04.ino
 * @brief       Set encoder address and then adjust RGB light color through the three cascaded encoders.
 * @copyright   Copyright (c) 2010 DFRobot Co.Ltd (http://www.dfrobot.com)
 * @licence     The MIT License (MIT)
 * @author      [qsjhyy](fengying.nie@dfrobot.com)
 * @version     V0.1
 * @date        2021-09-27
 * @get from    https://www.dfrobot.com
 * @url         
 */
 #include <DFRobot_NeoPixel.h>

// Dynamic variable
volatile float R, G, B;
// Function declaration 
uint32_t rgbToColor(uint8_t r, uint8_t g, uint8_t b);
// Create object 
DFRobot_NeoPixel neoPixel_2;
#include <DFRobot_VisualRotaryEncoder.h>
/*
Instantiate an object to drive our sensor;
Set address according to encoder DIP switch::
| 1 | 2 | ADDR |
|---|---|------|
| 0 | 0 | 0x54 |
| 0 | 1 | 0x55 |
| 1 | 0 | 0x56 |
| 1 | 1 | 0x57 |
*/
DFRobot_VisualRotaryEncoder_I2C sensor_1(/*iicAddr = */0x54, /*iicBus = */&Wire);
DFRobot_VisualRotaryEncoder_I2C sensor_2(/*iicAddr = */0x55, /*iicBus = */&Wire);
DFRobot_VisualRotaryEncoder_I2C sensor_3(/*iicAddr = */0x56, /*iicBus = */&Wire);

void setup()
{
  neoPixel_2.begin(2, 12); //Set RGB light pin to 2, the number of LED to 12 
  neoPixel_2.setBrightness(255);

  Serial.begin(115200);

  // Init sensor 
  while( NO_ERR != sensor_1.begin()&&NO_ERR != sensor_2.begin()&&NO_ERR != sensor_3.begin() ){
    Serial.println("Communication with device failed, please check connection");
    delay(3000);
  }
  Serial.println("Begin ok!");

  /**
   * Set encoder gain coefficient, accuracy value to rotate one detent 
   * Accuracy range: 1~51, the minimum is 1 (light up one LED about every 2.5 turns), the maximum is 51 (light up one LED every one detent rotation)
   * gainValue Range[1, 51], setting invalid when out of range.
   */
  sensor_1.setGainCoefficient(30);
  sensor_2.setGainCoefficient(30);
  sensor_3.setGainCoefficient(30);
  /**
   * Set encoder gain coefficient, accuracy value to rotate one detent 
   * Accuracy range: 1~51, the minimum is 1 (light up one LED about every 2.5 turns), the maximum is 51 (light up one LED every one detent rotation)
   * Return range: 1-51
   */
  uint8_t gainCoefficient_1 = sensor_1.getGainCoefficient();
  uint8_t gainCoefficient_2 = sensor_2.getGainCoefficient();
  uint8_t gainCoefficient_3 = sensor_3.getGainCoefficient();

  Serial.print("Encoder current gain coefficient: ");
  Serial.println(gainCoefficient_1);
  Serial.println(gainCoefficient_2);
  Serial.println(gainCoefficient_3);

  Serial.println();
  delay(1000);
}

void loop()
{
  /**
   * Detect if the button is pressed. 
   * Return true Button pressed, false, button unpressed 
   */
  if(sensor_1.detectButtonDown()){
    /**
     * Set the encoder count value
     * value Range[0, 1023], setting invalid when out of range
     * In this example, when the button is detected to be pressed, reset the encoder value to zero, then all the LEDs that light up before switch off.  
     */
    sensor_1.setEncoderValue(0);
  }

  if(sensor_2.detectButtonDown()){
    /**
     * Set the encoder count value
     * value Range[0, 1023], setting invalid when out of range
     * In this example, when the button is detected to be pressed, reset the encoder value to zero, then all the LEDs that light up before switch off.
     */
    sensor_2.setEncoderValue(0);
  }

  if(sensor_3.detectButtonDown()){
    /**
     * Set the encoder count value
     * value Range[0, 1023], setting invalid when out of range
     * In this example, when the button is detected to be pressed, reset the encoder value to zero, then all the LEDs that light up before switch off.
     */
    sensor_3.setEncoderValue(0);
  }

  /**
   * Get encoder current count value
   * Return value range: 0-1023
   */
  uint16_t encoderValue_1 = sensor_1.getEncoderValue();
  uint16_t encoderValue_2 = sensor_2.getEncoderValue();
  uint16_t encoderValue_3 = sensor_3.getEncoderValue();

  Serial.print("encoderValue_1: ");
  Serial.println(encoderValue_1);
   Serial.print("encoderValue_2: ");
  Serial.println(encoderValue_2);
   Serial.print("encoderValue_3: ");
  Serial.println(encoderValue_2);
  Serial.println();

  R = (map(encoderValue_1, 0, 1023, 0, 255));
  G = (map(encoderValue_2, 0, 1023, 0, 255));
  B = (map(encoderValue_3, 0, 1023, 0, 255));
  neoPixel_2.setRangeColor(0, 11, rgbToColor(round(R), round(G), round(B)));
  Serial.print("R: ");
  Serial.println(round(R));
  Serial.print("G: ");
  Serial.println(round(G));
  Serial.print("B: ");
  Serial.println(round(B));
  Serial.println();
  delay(1000);
}

// Static function 
uint32_t rgbToColor(uint8_t r, uint8_t g, uint8_t b)
{
  return (uint32_t)((((uint32_t)r<<16) | ((uint32_t)g<<8)) | (uint32_t)b);
}

/*!
 * @file        setSensor.ino
 * @brief       This demo shows tha thow to control servo angle by the encoder 
 * @copyright   Copyright (c) 2010 DFRobot Co.Ltd (http://www.dfrobot.com)
 * @licence     The MIT License (MIT)
 * @author      [qsjhyy](yihuan.huang@dfrobot.com)
 * @version     V0.1
 * @date        2021-09-15
 * @get from    https://www.dfrobot.com
 * @url         https://github.com/DFRobot/DFRobot_VisualRotaryEncoder
 */
#include <DFRobot_VisualRotaryEncoder.h>

/*
Instantiate an object to drive our sensor;
Set address according to the encoder DIP:
| 1 | 2 | ADDR |
|---|---|------|
| 0 | 0 | 0x54 |
| 0 | 1 | 0x55 |
| 1 | 0 | 0x56 |
| 1 | 1 | 0x57 |
*/
DFRobot_VisualRotaryEncoder_I2C sensor(/*iicAddr = */0x54, /*iicBus = */&Wire);

#include <Servo.h>

Servo myservo;
int pos = 0;    // Init servo angle
void setup()
{
  myservo.attach(9);  // Set servo connection pin 

  Serial.begin(115200);

  // Init sensor 
  while( NO_ERR != sensor.begin() ){
    Serial.println("Communication with device failed, please check connection");
    delay(3000);
  }
  Serial.println("Begin ok!");

  /**
   * Set encoder gain coefficient, accuracy value to rotate one detent 
   * Accuracy range: 1~51, the minimum is 1 (light up one LED about every 2.5 turns), the maximum is 51 (light up one LED every one detent rotation)
   * Return range: 1-51
   */
  sensor.setGainCoefficient(51);

  /**
   * Get current encoder gain coefficient, accuracy value to rotate one detent 
   * Accuracy range: 1~51, the minimum is 1 (light up one LED about every 2.5 turns), the maximum is 51 (light up one LED every one detent rotation)
   * Return range: 1-51
   */
  uint8_t gainCoefficient = sensor.getGainCoefficient();
  Serial.print("Encoder current gain coefficient: ");
  Serial.println(gainCoefficient);

  Serial.println();
  delay(1000);
}

void loop()
{
  /**
   * Detect if the button is pressed 
   * Return true, button pressed. Return false: button unpressed 
   */
  if(sensor.detectButtonDown()){
    /**
     * Set the encoder count value
     * value Range[0, 1023], setting invalid when out of range
     * In this example, when the button is detected to be pressed, reset the encoder value to zero, then all the LEDs that light up before switch off.
     */
    sensor.setEncoderValue(0);
  }

  /**
   * Get encoder current count value
   * Return value range: 0-1023
   * Map the encoder value to servo angle 
   */
  uint16_t encoderValue = sensor.getEncoderValue();
  Serial.print("The encoder currently counts: ");
  Serial.println(encoderValue);
  pos = map(encoderValue, 0, 1023, 10, 170);
  myservo.write(pos);
  Serial.println();
  delay(1000);
}

/*!
 * @file        setSensor.ino
 * @brief       This demo shows how to control LED light brightness by the encoder. 
 * @copyright   Copyright (c) 2010 DFRobot Co.Ltd (http://www.dfrobot.com)
 * @licence     The MIT License (MIT)
 * @author      [qsjhyy](yihuan.huang@dfrobot.com)
 * @version     V0.1
 * @date        2021-09-15
 * @get from    https://www.dfrobot.com
 * @url         https://github.com/DFRobot/DFRobot_VisualRotaryEncoder
 */
#include <DFRobot_VisualRotaryEncoder.h>

/*
Instantiate an object to drive our sensor;
Set address according to encoder DIP: 
| 1 | 2 | ADDR |
|---|---|------|
| 0 | 0 | 0x54 |
| 0 | 1 | 0x55 |
| 1 | 0 | 0x56 |
| 1 | 1 | 0x57 |
*/
DFRobot_VisualRotaryEncoder_I2C sensor(/*iicAddr = */0x54, /*iicBus = */&Wire);

// #include <Servo.h>

// Servo myservo;
int LED = 0;    // Init LED brightness 
int ledPin = 10;  // Set LED light connection pin 
void setup()
{
  pinMode(ledPin, OUTPUT);

  Serial.begin(115200);

  // Init sensor 
  while( NO_ERR != sensor.begin() ){
    Serial.println("Communication with device failed, please check connection");
    delay(3000);
  }
  Serial.println("Begin ok!");

  /**
   * Set encoder gain coefficient, accuracy value to rotate a detent 
   * Accuracy range: 1~51, the minimum is 1 (light up one LED about every 2.5 turns), the maximum is 51 (light up one LED every one detent rotation)
   * gainValue Range[1, 51], setting invalid when out of range
   */
  sensor.setGainCoefficient(51);

  /**
   * Get current encoder coefficient, accuracy value to rotate one detect. 
   * Accuracy range: 1~51, the minimum is 1 (light up one LED about every 2.5 turns), the maximum is 51 (light up one LED every one detent rotation)
   * Return value range: 1-51
   */
  uint8_t gainCoefficient = sensor.getGainCoefficient();
  Serial.print("Encoder current gain coefficient: ");
  Serial.println(gainCoefficient);

  Serial.println();
  delay(1000);
}

void loop()
{
  /**
   * Detect if the button is pressed 
   * Return true, button pressed. Return false: button unpressed 
   */
  if(sensor.detectButtonDown()){
    /**
     * Set the encoder count value
     * value Range[0, 1023], setting invalid when out of range
     * In this example, when the button is detected to be pressed, reset the encoder value to zero, then all the LEDs that light up before switch off.
     */
    sensor.setEncoderValue(0);
  }

  /**
   * Get encoder current count value 
   * Return value: 0-1023
   * Map enocder value to LED brightness 
   */
  uint16_t encoderValue = sensor.getEncoderValue();
  Serial.print("The encoder currently counts: ");
  Serial.println(encoderValue);
  LED = map(encoderValue, 0, 1023, 0, 255);
  analogWrite(ledPin,LED);   //Write corresponding value to LED   
  Serial.println();
  delay(1000);
}