Fuzzy Logic Control with Arduino: Practical Application and Implementation

Fuzzy Logic Control (FLC) is an intelligent control approach that allows for smooth and adaptive adjustments in systems where precise responses are challenging to measure or control. In this blog post, we’ll discuss how to implement fuzzy logic control with an Arduino, using a flame sensor and a unipolar stepper motor as a practical example. This project will demonstrate how fuzzy logic can be used to gradually adjust motor speed based on flame intensity, making it an ideal use case for safety or ventilation systems that need adaptive control.

What is Fuzzy Logic Control?

Fuzzy logic control differs from traditional binary logic by utilizing a range of values between 0 and 1, rather than absolute true or false values. It uses linguistic variables such as “low,” “medium,” and “high” for decision-making. This approach makes FLC highly effective for scenarios where input measurements may be imprecise or where conditions vary dynamically.

If you’re interested in exploring other adaptive control systems for Arduino, consider reading our guides on Feedforward Control System with Arduino and Adaptive Control System with Arduino.

Components Needed

To implement a fuzzy control system with Arduino, flame sensor, and unipolar stepper motor, you’ll need:

• Arduino (e.g., Uno)
• Flame sensor module (analog output)
• Unipolar stepper motor
• Stepper motor driver (ULN2003 or similar)
• Power source suitable for the stepper motor
• Jumper wires and breadboard

For additional guidance on using flame sensors with Arduino, you may find this guide on Arduino-Based Smoke and Motion Detection helpful.

System Overview

In this setup, the flame sensor detects flame intensity and sends an analog signal to the Arduino. The Arduino then uses fuzzy logic to calculate an appropriate speed for the unipolar stepper motor, increasing the motor’s speed as the flame intensity grows. This type of adaptive control can be useful in applications like smoke exhaust or air circulation control in environments where a fire risk is present.

Step 1: Setting Up the Flame Sensor and Stepper Motor

Connecting the Flame Sensor

1. Connect the flame sensor’s VCC and GND to the 5V and GND pins on the Arduino.
2. Connect the analog output pin of the flame sensor to an analog input pin (e.g., A0) on the Arduino.

Connecting the Unipolar Stepper Motor and Driver

1. Connect the four control pins of the unipolar stepper motor driver to four digital output pins on the Arduino (e.g., D8, D3, D4, and D5).
2. Connect the motor’s power supply (make sure it’s appropriate for the motor specifications) to the driver.
3. Ensure that the Arduino and motor driver share a common ground.

Circuit Diagram

Below is the circuit diagram of Arduino as Fuzzy logic controller with practical application of sensing flame and then turning on a FAN according the magnitude of the flame. 

If you're new to using different control setups with Arduino, our post on On-Off Control System with Arduino for Home Automation provides a good introduction to controlling various devices.

Step 2: Implementing Fuzzy Logic in Code

The fuzzy logic approach here defines fuzzy sets and rules to categorize the flame intensity and map it to appropriate stepper motor speeds.

Code Example

  
#include <Stepper.h>

const int flameSensorPin = A0; // Analog pin for flame sensor
const int STEPS_PER_REV = 200; // Adjust for your stepper motor
Stepper myStepper(STEPS_PER_REV, 8, 10, 9, 11); // Example pins for ULN2003

void setup() {
  Serial.begin(9600);
  myStepper.setSpeed(0); // Initial speed set to zero
}

void loop() {
  // Read analog value from flame sensor (0-1023)
  int flameValue = analogRead(flameSensorPin);

  // Determine motor speed based on flame intensity using fuzzy logic
  int motorSpeed = fuzzyLogicMotorSpeed(flameValue);

  // Set stepper motor speed
  myStepper.setSpeed(motorSpeed);

  // Move the motor by one step in the forward direction
  myStepper.step(1);

  // Print values for debugging
  Serial.print("Flame Sensor Value: ");
  Serial.print(flameValue);
  Serial.print(" | Motor Speed: ");
  Serial.println(motorSpeed);

  delay(100); // Adjust delay as needed
}

// Fuzzy Logic Control function to determine motor speed
int fuzzyLogicMotorSpeed(int flameValue) {
  int motorSpeed;

  // Fuzzy conditions for low, medium, and high flame intensity
  if (flameValue < 300) { // Low intensity
    motorSpeed = map(flameValue, 0, 300, 0, 30); // Map flame value to 0-30 RPM
  } else if (flameValue >= 300 && flameValue <= 700) { // Medium intensity
    motorSpeed = map(flameValue, 300, 700, 30, 100); // Map flame value to 30-100 RPM
  } else { // High intensity
    motorSpeed = map(flameValue, 700, 1023, 100, 200); // Map flame value to 100-200 RPM
  }

  return motorSpeed;
}

Code Breakdown

1. Reading Flame Sensor: The analog reading from the flame sensor is stored in flameValue.
2. Fuzzy Logic Control: The fuzzyLogicMotorSpeed function defines fuzzy rules for flame intensity:
   • Low intensity (0-300): Low motor speed (0-30 RPM).
   • Medium intensity (300-700): Medium motor speed (30-100 RPM).
   • High intensity (700-1023): High motor speed (100-200 RPM).
3. Setting Motor Speed: The myStepper.setSpeed(motorSpeed); command adjusts the motor speed, and myStepper.step(1); keeps the motor continuously moving.

Video demonstration

Practical Applications of Fuzzy Logic Control with Arduino

1. Fire and Smoke Exhaust Systems

This setup can serve as an exhaust fan controller, adjusting motor speed based on detected flame intensity. This system helps increase ventilation dynamically, providing greater air circulation when flames are present.

2. Temperature-Responsive Ventilation

This type of system can also be adapted for ventilation based on temperature, where fuzzy logic helps smoothly control fan or exhaust motor speed. For more on temperature control, check out our Feedforward Control System with Arduino and Arduino-Based Adaptive Control Systems guides.

3. Precision Cooling in Industrial Settings

By setting up fuzzy logic-based exhaust or fan systems, factories or workshops can implement responsive cooling solutions that dynamically adjust based on detected heat or flame intensity, offering enhanced safety and energy efficiency.

Conclusion

Fuzzy Logic Control with Arduino allows for adaptive, rule-based adjustments ideal for applications where control responses need to match variable input intensities. In this project, we used fuzzy logic to control the speed of a unipolar stepper motor in response to flame intensity. This approach can be extended to other environmental inputs, such as temperature or smoke density, by changing the sensor and motor thresholds.

For additional control system examples, see our related guides on Sliding Mode Control with Arduino and On-Off Control Systems with Arduino, which provide different approaches to adaptive and responsive control setups.