Derivative Control Demo in Control Systems Engineering Using Slider in Tkinter

Control systems engineering plays a crucial role in various industries, enabling precise and efficient control of processes and systems. One fundamental concept in control systems is derivative control, which helps improve the system’s response to changes and disturbances. In this blog post, we’ll explore a simple demonstration of derivative control using a slider in Tkinter, a popular Python GUI toolkit.

Understanding Derivative Control

Derivative control is a control strategy that utilizes the derivative of the error signal to adjust the control output. By calculating the rate of change of the error, derivative control can anticipate the system’s response to changes and take corrective actions to minimize the error. It provides a damping effect and improves the system’s stability and responsiveness.

The derivative control algorithm consists of three main components:

Derivative Control Function: The derivative control function calculates the derivative term based on the current error, previous error, and a time interval. The derivative term is obtained by multiplying the derivative gain (Kd) with the difference in error divided by the time interval.
Main Loop: The main loop of the control system continuously monitors the process variable and applies derivative control to update the control output. It calculates the error by subtracting the desired setpoint from the process variable. The derivative control function is then invoked to compute the derivative term. The control output is actuated, and the previous error is updated.
Slider and GUI: To interact with the control system, we’ll create a graphical user interface (GUI) using Tkinter. A slider widget allows us to adjust the feedback stimulus, representing the process variable. Labels display the feedback stimulus value and the computed derivative term in real-time. Additionally, a hyperlink is provided to visit a website for further information.

Implementation with Tkinter

Let’s delve into the implementation of the derivative control demo using Tkinter. Here’s the code:

import tkinter as tk
import time
import webbrowser

# Derivative control function
def derivative_control(error, prev_error, dt):
    # Derivative gain
    Kd = 0.2
    derivative_term = Kd * (error - prev_error) / dt
    return derivative_term

# Main loop
def main_loop():
    setpoint = 50  # Desired setpoint
    process_variable = 0  # Initial process variable
    prev_error = 0  # Previous error
    dt = 0.1 * 9  # Time interval for derivative control
    while True:
        # Read process variable from the slider
        process_variable = slider.get()

        # Calculate the error
        error = setpoint - process_variable

        # Apply derivative control
        derivative_term = derivative_control(error, prev_error, dt)

        # Actuate the control signal (in this example, update the label)
        control_label.configure(text="Derivative Term: {:.2f}".format(derivative_term))

        # Update the previous error
        prev_error = error

        time.sleep(dt)  # Sleep for the time interval


# Callback function for the slider
def slider_callback(value):
    feedback_label.configure(text="Feedback Stimulus: {:.2f}".format(float(value)))

# Open exasub.com in a web browser
def open_link(event):
    webbrowser.open("http://www.exasub.com")

# Create the main Tkinter window
window = tk.Tk()
window.title("Derivative Control Demo")

# Create the slider for adjusting the feedback stimulus
slider = tk.Scale(window, from_=0, to=100, orient=tk.HORIZONTAL, length=300, command=slider_callback)
slider.pack()

# Create a label to display the feedback stimulus value
feedback

_label = tk.Label(window, text="Feedback Stimulus: {:.2f}".format(slider.get()))
feedback_label.pack()

# Create a label to display the derivative term value
control_label = tk.Label(window, text="Derivative Term: ")
control_label.pack()

# Add a link to exasub.com
link = tk.Label(window, text="Visit exasub.com", fg="blue", cursor="hand2", font=("Arial", 14))
link.pack()
link.bind("<Button-1>", open_link)

# Start the main loop in a separate thread
import threading
main_loop_thread = threading.Thread(target=main_loop)
main_loop_thread.start()

# Start the Tkinter event loop
window.mainloop()

Exploring the Code

Let’s break down the code to understand how the derivative control demo works:

We begin by importing the necessary modules: tkinter for GUI, time for time-related operations, and webbrowser for opening web links.
The derivative_control function calculates the derivative control term based on the error, previous error, and a specified time interval. It multiplies the derivative gain (Kd) with the difference in error and divides it by the time interval. Adjusting the value of Kd can impact the system’s response.
The main_loop function serves as the central control loop of the demo. It sets the desired setpoint and initializes variables for the process variable and previous error. The time interval (dt) determines the frequency of derivative control updates. Within the loop, the process variable is read from the slider, the error is calculated, derivative control is applied, and the control output is displayed in the GUI label. The previous error is updated, and the loop pauses for the specified time interval.
The slider_callback function is triggered whenever the slider value changes. It updates the feedback label to display the current value of the feedback stimulus, representing the process variable.
The open_link function opens the “exasub.com” website in a web browser when the “Visit exasub.com” link is clicked. This functionality provides an opportunity to learn more about derivative control or related topics.
The main Tkinter window is created, titled “Derivative Control Demo”.
A slider widget is added to the window, allowing the user to adjust the feedback stimulus. It spans from 0 to 100, is oriented horizontally, and has a length of 300 pixels. The slider_callback function is bound to this slider to update the feedback label.
A label is created to display the current value of the feedback stimulus.
Another label is created to display the computed derivative term. Initially, it displays the placeholder text “Derivative Term: “.
A hyperlink labeled “Visit exasub.com” is added to the window. It appears in blue and changes the cursor to a hand when hovered over. The open_link function is bound to this label to open the specified website.
The main loop is started in a separate thread using the threading module. This allows the control loop to run concurrently with the Tkinter event loop and ensures the GUI remains responsive.
Finally, the Tkinter event loop is started using the mainloop() method of the window object. It listens for user interactions and updates the GUI accordingly.

Running the Derivative Control Demo

To run the derivative control demo, you’ll need to have Python and the Tkinter library installed. Save the code in a Python file (e.g., derivative_control_demo.py) and execute it. A window will appear with a slider and two labels.

Adjusting the slider will update the feedback stimulus

value label in real-time. As you adjust the slider, the derivative control algorithm will calculate the derivative term, which will be displayed in the “Derivative Term” label. The calculated derivative term reflects the system’s response to changes in the feedback stimulus.

Additionally, clicking the “Visit exasub.com” link will open a web browser and direct you to the “exasub.com” website, providing an opportunity to explore further resources on derivative control or related topics.

Conclusion

In this blog post, we’ve explored a derivative control demo implemented using Tkinter in Python. By adjusting a slider representing the feedback stimulus, you can observe the real-time calculation of the derivative term. This demonstration showcases the principles of derivative control and its role in control systems engineering.

Understanding derivative control and its application can be valuable in various fields, such as robotics, industrial automation, and process control. By manipulating the derivative gain and other control parameters, engineers can fine-tune the system’s response to optimize performance, stability, and efficiency.

By experimenting with this derivative control demo and further exploring control systems engineering, you can deepen your understanding of control strategies and their impact on system behavior.