Using Rotary Encoders with Arduino: Interrupts and Code

This tutorial demonstrates how to build an interactive menu system using an Arduino Uno, a rotary encoder, and a Nokia 5110 LCD display. The project involves connecting the display pins (Reset, Data/Command, Chip Select, Data, Clock) to specific Arduino digital pins, wiring the rotary encoder's SW, DT, and CLK pins to analog inputs, and implementing a software architecture with global variables (page, menuitem, frame) to manage menu navigation and state. The menu allows users to scroll through six configurable items using the rotary encoder, with button presses to select options and navigate between main menu and sub-menus for adjusting values like contrast, volume, and settings.

This tutorial demonstrates how to create an interactive menu system using an Arduino UNO, a 1.3-inch OLED display (SH1106), and an EC11 rotary encoder. The system allows users to scroll through menu options using the rotary encoder, with the active menu item highlighted in white with black text while inactive items appear in black with white text. Pressing the encoder toggles the status of LEDs connected to the Arduino. The implementation requires two libraries: one for the rotary encoder and one for the OLED display, and involves defining the menu structure, handling encoder input events, and updating both the display and LED states accordingly.

A rotary encoder is a digital sensor that detects rotational movement by generating square wave signals on CLK and DT pins with a 90-degree phase shift, allowing the Arduino to determine both the direction and amount of rotation by analyzing signal transitions; when combined with an LCD display and push button, it enables creating interactive menu systems where users can navigate options by rotating the encoder and select items by pressing the button.

A rotary encoder is an infinite-rotation sensor with 20 steps per revolution that uses two digital signals (clock and data) to detect rotation direction and position, combined with a button for menu activation; this system can be implemented using Arduino UNO with an I2C LCD 16x2 display to create a menu navigation interface where rotating the encoder changes menu options and pressing the button selects the current option, demonstrating a finite state machine approach to user interface design.

This comprehensive section covers building a menu system using rotary encoders. The core concept is a state machine with three states: main menu, color submenu, and pattern submenu. The encoder's behavior depends on the current state—rotating selects items within the current level, while button presses transition between states. The system controls an RGB LED, allowing users to select colors (red, green, blue, yellow, cyan, magenta, white, black) and blink patterns (solid, slow blink, fast blink, pulse, rainbow). The OLED display shows the current menu with a cursor indicator. This demonstrates how rotary encoders enable intuitive user interfaces for embedded systems.

This video demonstrates how to implement precise DC motor speed control using a PID controller with encoder feedback. The process involves measuring motor velocity through a magnetic encoder, applying a low-pass filter to smooth measurements, and implementing a PI (Proportional-Integral) controller to maintain target speed despite loading variations. The key steps include: (1) Hardware setup with motor driver and encoder; (2) Velocity measurement using encoder signals; (3) Filtering raw encoder data with a low-pass filter; (4) Implementing proportional control to reduce error; (5) Adding integral control to eliminate steady-state error; (6) Tuning controller parameters (Kp and Ki) for stable response. The video shows that while proportional control alone can track speed, it leaves steady-state error, which the integral term eliminates. However, improper parameter tuning can cause overshoot and oscillation. The low-pass filter is essential for reducing high-frequency noise from discrete encoder measurements, especially important at low speeds where quantization effects become more pronounced.

This video demonstrates how to implement a PID (Proportional-Integral-Derivative) controller for speed control of a DC motor equipped with an encoder using Arduino. The process involves three main stages: first reading encoder pulses to measure motor speed by counting rising edges on a digital pin using interrupts; second calculating RPM from pulse counts by applying the formula RPM = (pulses_per_second × 60) / (encoder_resolution × gear_reduction_ratio); and third implementing the PID algorithm using the difference equation derived from the continuous-time PID transfer function, where the output is calculated as u(k) = Kp×error(k) + Ki×Ts/2×(error(k)+error(k-1)) + Kd×(error(k)-error(k-2))/Ts, with error(k) being the difference between setpoint and measured process variable. The final implementation includes an LCD display for real-time monitoring of setpoint and actual RPM values.

This tutorial demonstrates how to control a DC motor's position using an encoder and PID control algorithm. The system uses an Arduino Uno microcontroller connected to a DC motor with an encoder (which detects rotation direction through quadrature signals A and B), a motor driver, and implements a feedback loop where the PID controller calculates the control signal based on the error between the target and measured position, with the proportional term reducing error, the derivative term preventing overshoot, and the integral term eliminating steady-state error; the control signal is then converted to PWM and direction signals to drive the motor toward the desired position.

This video demonstrates how to implement PID (Proportional-Integral-Derivative) position control for a DC motor with encoder feedback using Arduino, where the potentiometer provides the setpoint input and the PID controller continuously adjusts the motor position by calculating error, integrating past errors, and predicting future errors to achieve precise positioning with minimal steady-state error and acceptable overshoot.

This video demonstrates the development and analysis of a closed-loop speed control system for a DC motor using a PID controller in MATLAB/Simulink. The system consists of a 5 HP DC motor with a 150V field supply, where the armature voltage is controlled by a PID controller based on the error between the reference speed and the actual speed feedback. The video explains the complete model setup including the DC motor, controllable voltage source, PID controller, comparator, and speed measurement blocks. It shows how the PID controller parameters (proportional and integral gains) can be tuned to achieve fast response times (settling within approximately 0.3 seconds) and eliminate steady-state error. The demonstration also illustrates how the closed-loop system maintains constant speed even when mechanical load torque increases, unlike an open-loop system which experiences significant speed variations under changing loads.

The encoder interrupt service routine implements quadrature decoding for accurate position tracking. For encoder A interrupt: PORTD is read and masked with 0x0C to isolate pins 2 and 3. If the reading matches the expected pattern indicating clockwise rotation, the click count decreases. If pin 2 is high alone, the B flag is set to prepare for the next interrupt. For encoder B interrupt: similar logic applies, increasing the click count when appropriate. The two interrupts coordinate through shared flags (a_flag and b_flag), where each interrupt sets a flag that allows the other to properly register transitions. This sophisticated interrupt handling enables precise counting of encoder detents even at high speeds, forming the core of the CNC controller's position tracking capability.

This lecture demonstrates how to interface an encoder with the Quadrature Encoder Interface (QEI) module in Tiva Launchpad microcontrollers, explaining the setup of input signals, direction detection, and speed measurement using interrupt service routines (ISR) for real-time position tracking.

The Quadrature Encoder Interface (QEI) module requires proper pin configuration before operation. Pins QEA and QEB share physical locations with analog inputs AN4 and AN5, so analog functionality must be disabled in the ADPCFG register before using them for digital quadrature input. The QEI module operates in different modes controlled by the QEIM three-bit field in the QEA control register, with mode 7 (binary 111) enabling position counting with automatic reset at maximum value. The module automatically increments or decrements the position counter register (PACNT) based on the phase relationship between the quadrature signals, allowing precise rotation measurement without additional software processing.

The Quadrature Encoder Interface (QEI) module in microcontrollers enables closed-loop motor control by measuring both the position and velocity of a rotary encoder connected to a motor shaft. The QEI module processes two pulses (Phase A and Phase B) from the encoder, which are 90 degrees out of phase, allowing the system to determine not only the distance traveled (position) but also the direction of rotation (clockwise or counterclockwise). This bidirectional capability is essential for applications like automotive wheel speed sensors (used in ABS and ESP systems) and modern electronic equipment knobs. When combined with PWM (Pulse Width Modulation) for motor control, the QEI module forms a complete motion control peripheral that enables precise speed regulation through feedback mechanisms, where the measured speed is compared against a target value and adjustments are made to maintain the desired rotational speed.