The LM35 is a precision temperature sensor that provides an analog voltage output proportional to the measured temperature. It's popular among electronics enthusiasts for its simplicity, accuracy, and ease of use with microcontrollers like Arduino and ESP32.

In this tutorial, you’ll learn how LM35 works, how to interface it with Arduino and ESP32, and how to build two practical projects — a basic temperature reader and an IoT-based web server display.

What Is an LM35 Sensor?

The LM35 is an analog temperature sensor that outputs voltage linearly related to the Celsius temperature. It doesn’t require calibration and provides a direct temperature-to-voltage conversion, making it extremely beginner-friendly.

Manufacturer: Texas Instruments
Output Type: Analog (10mV/°C)
Operating Range: -55°C to +150°C
Accuracy: ±0.5°C (at room temperature)

Key Features and Specifications of LM35

How the LM35 Sensor Works: Principle of Operation

The LM35 works on the principle that the output voltage changes linearly with temperature.
For every 1°C rise, the output increases by 10 mV.

So if the LM35 outputs 250 mV, the temperature is 25°C.
Formula:

This linear relationship makes the LM35 simple to use — no complex calibration or signal conditioning is required.

That means:

• 0°C → 0V
• 25°C → 250mV
• 100°C → 1.0V

Since the ESP32 ADC reads voltage in a range (0–3.3V), we can compute the temperature as:

$T(^{0}C)=(\frac{ADC_{value}}{4095})\cdot3.3\cdot100$

Understanding the LM35 Pin Configuration and Circuit Diagram

LM35 Pinout Explained

LM35 Wiring and Power Requirements

• For Arduino, power it with 5V.
• For ESP32, use 3.3V.
• Always use a common ground between LM35 and the microcontroller.
• Optionally, add a 0.1 µF capacitor between VOUT and GND to stabilize readings.

Using LM35 with Arduino: Step-by-Step Guide

Components Required for Arduino + LM35 Project

• Arduino Uno (or Nano)
• LM35 temperature sensor
• Jumper wires
• Breadboard
• (Optional) 16x2 LCD display

Circuit Diagram for LM35 with Arduino

Connections:

• LM35 VCC → 5V
• LM35 GND → GND
• LM35 VOUT → A0 (analog pin)

Arduino Code to Read Temperature from LM35

const int sensorPin = A0;
float temperature;

void setup() {
  Serial.begin(9600);
}

void loop() {
  int sensorValue = analogRead(sensorPin);
  float voltage = (sensorValue / 1023.0) * 5.0;
  temperature = voltage * 100; // 10mV per degree Celsius
  Serial.print("Temperature: ");
  Serial.print(temperature);
  Serial.println(" °C");
  delay(1000);
}

Displaying Temperature on Serial Monitor or LCD

• Open Serial Monitor (Ctrl + Shift + M).
• You’ll see continuous readings like:
  Temperature: 27.35 °C
  Temperature: 27.42 °C
• To display it on an LCD, use the LiquidCrystal library and connect pins RS, E, D4–D7 accordingly.

Using LM35 with ESP32: IoT-Based Temperature Monitoring

Components Required for ESP32 + LM35 Project

• ESP32 board
• LM35 temperature sensor
• Breadboard and jumper wires
• (Optional) Wi-Fi network for IoT display

Circuit Diagram for LM35 with ESP32

Connections:

• LM35 VCC → 3.3V
• LM35 GND → GND
• LM35 VOUT → GPIO34 (analog input)

ESP32 Code to Read Temperature from LM35

const int sensorPin = 34;
float temperature;

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

void loop() {
  int sensorValue = analogRead(sensorPin);
  float voltage = (sensorValue / 4095.0) * 3.3;
  temperature = voltage * 100;
  Serial.print("Temperature: ");
  Serial.print(temperature);
  Serial.println(" °C");
  delay(2000);
}

Displaying Temperature on a Web Server (IoT Project)

Below is a full example code that:

1. Reads temperature from LM35.
2. Connects to Wi-Fi.
3. Hosts a simple webpage showing live temperature readings.

#include <WiFi.h>
#include <WebServer.h>

// Replace with your Wi-Fi credentials
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";

const int lm35_pin = 34; // Analog pin for LM35
WebServer server(80);    // Web server on port 80

float read_temperature() {
  int adc_value = analogRead(lm35_pin);
  float voltage = (adc_value / 4095.0) * 3.3;  // Convert ADC reading to voltage
  float temperature_c = voltage * 100;         // 10mV per °C
  return temperature_c;
}


String html_page(float temp_c) {
  String html = "<!DOCTYPE html><html><head><meta name='viewport' content='width=device-width, initial-scale=1.0'>";
  html += "<title>ESP32 LM35 Temperature</title>";
  html += "<style>body{font-family:Arial;text-align:center;background:#111;color:#0ff;}h1{color:#00ffff;}</style>";
  html += "</head><body>";
  html += "<h1>ESP32 LM35 Temperature Monitor</h1>";
  html += "<h2>Current Temperature: " + String(temp_c, 2) + " °C</h2>";
  html += "<meta http-equiv='refresh' content='2'>"; // auto-refresh every 2 seconds
  html += "</body></html>";
  return html;
}


void handle_root() {
  float temp = read_temperature();
  server.send(200, "text/html", html_page(temp));
}

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nConnected!");
  Serial.print("ESP32 IP address: ");
  Serial.println(WiFi.localIP());

  server.on("/", handle_root);
  server.begin();
  Serial.println("Web server started!");
}

void loop() {
  server.handleClient();
}

Accessing the Web Page

1. Upload the sketch to your ESP32.
2. Open the Serial Monitor at 115200 baud.
3. Wait until you see:
   Connected!
   ESP32 IP address: 192.168.1.xxx
4. Open that IP in your browser (e.g., http://192.168.1.45)
5. You’ll see a temperature dashboard refreshing every 2 seconds!

Troubleshooting Common Issues

Incorrect Temperature Readings

• Check voltage reference (5V or 3.3V).
• Ensure correct analog pin.
• Add a capacitor between VOUT and GND to reduce noise.

Sensor Noise and Calibration Tips

• Use shielded cables for long distances.
• Calibrate by comparing with a digital thermometer.

Applications of LM35 in Real-Life Projects

Home Automation Systems

• Temperature-controlled fans or air conditioners.

Environmental Monitoring and IoT Systems

• Smart agriculture
• Weather monitoring stations
• IoT dashboards (via Blynk, ThingSpeak, etc.)

Advantages and Limitations of LM35 Sensor

Benefits of Using LM35

• Linear and accurate output
• Low cost and easy to interface
• No external calibration needed

Limitations and Alternatives

• Analog-only output (needs ADC)
• Not waterproof
• Alternatives: DHT11, DS18B20, TMP36

FAQs: How to Use LM35 Temperature Sensor with Arduino and ESP32

1. What voltage does LM35 require?
It operates between 4V and 30V, commonly powered by 5V (Arduino) or 3.3V (ESP32).

2. Can I use LM35 with ESP8266 or Raspberry Pi?
Yes, but ensure you use analog-to-digital conversion, as some boards (like ESP8266) have limited ADC support.

3. Why are my readings unstable?
Add a capacitor (0.1 µF) across output and ground to filter noise.

4. How accurate is the LM35 sensor?
±0.5°C at room temperature and ±1°C across a wide range.

5. Can LM35 measure below 0°C?
Yes, but output voltage may go negative, requiring offset circuitry.

6. Which IoT platforms support LM35 + ESP32 projects?
Popular ones include Blynk, ThingSpeak, and Google Firebase.

Conclusion

The LM35 temperature sensor is a simple, reliable, and precise device for temperature measurement and monitoring. Whether you’re using Arduino for basic sensor readings or ESP32 for IoT web dashboards, the LM35 offers versatility and accuracy.

Experimenting with LM35 is an excellent way to start learning about analog sensors, ADC conversion, and IoT data visualization.

For more information, visit the Texas Instruments LM35 Datasheet.

The post How to Use LM35 Temperature Sensor with Arduino and ESP32: Complete Guide with Example Projects appeared first on Teach Me Microcontrollers!.

Components Needed

• Arduino Uno (or similar) – 1
• LED bar graph display (10-segment) – 1
• Push buttons – 2
• Resistors (10kΩ for pull-downs) – 2
• Resistors (220Ω or 330Ω for LEDs) – 10
• Breadboard – 1
• Jumper wires

Wiring Diagram

1. LED Bar Graph:
   • Connect the cathodes of the LEDs to GND through a 220Ω resistor.
   • Connect each anode to Arduino pins D2 to D11.
2. Buttons:
   • Connect one leg of each button to GND through a 10kΩ resistor (pull-down configuration).
   • Connect the other leg to D12 (Player 1) and D13 (Player 2).

Gameplay Overview

• A "marker" (one lit LED) starts in the middle of the LED bar graph.
• Players press their respective buttons to move the marker toward their end.
• The game ends when the marker reaches one side, indicating the winner.

Code

Here's the Arduino sketch for the Tug of War game:

// Tug of War Game for Arduino

const int ledPins[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11}; // LED pins
const int numLeds = 10; // Number of LEDs
const int button1Pin = 12; // Player 1 button
const int button2Pin = 13; // Player 2 button

int markerPosition = numLeds / 2; // Start in the middle

void setup() {
   // Initialize LED pins as output
   for (int i = 0; i < numLeds; i++) {
       pinMode(ledPins[i], OUTPUT);
   }

   // Initialize button pins as input
   pinMode(button1Pin, INPUT);
   pinMode(button2Pin, INPUT);

   // Light up the starting LED
   updateLeds();
}

void loop() {
   // Read button states
   int button1State = digitalRead(button1Pin);
   int button2State = digitalRead(button2Pin);

   // Check if Player 1 presses their button
   if (button1State == HIGH) {
      markerPosition = max(0, markerPosition - 1); // Move left
      updateLeds();
      delay(200); // Debounce delay
   }

   // Check if Player 2 presses their button
   if (button2State == HIGH) {
      markerPosition = min(numLeds - 1, markerPosition + 1); // Move right
      updateLeds();
      delay(200); // Debounce delay
   }

   // Check for win condition
   if (markerPosition == 0) {
      gameOver(1); // Player 1 wins
   } else if (markerPosition == numLeds - 1) {
      gameOver(2); // Player 2 wins
   }
}

void updateLeds() {
  for (int i = 0; i < numLeds; i++) {
     digitalWrite(ledPins[i], i == markerPosition ? HIGH : LOW);
  }
}


void gameOver(int winner) {
   for (int i = 0; i < 5; i++) {
   
      // Flash LEDs to indicate the winner
      for (int j = 0; j < numLeds; j++) {
         digitalWrite(ledPins[j], HIGH);
      }

      delay(200);
      for (int j = 0; j < numLeds; j++) {
         digitalWrite(ledPins[j], LOW);
      }

      delay(200);
   }

   // Display winner LED permanently
   if (winner == 1) {
      digitalWrite(ledPins[0], HIGH); // Player 1 wins
   } else {
      digitalWrite(ledPins[numLeds - 1], HIGH); // Player 2 wins
   }

   while (true) {} // Stop the game
}

Explanation

1. LED Control:
   • The updateLeds() function ensures only one LED (the marker) is lit at any time, based on the markerPosition.
2. Button Handling:
   • The loop checks if either button is pressed and adjusts the marker's position accordingly.
   • A debounce delay is added to prevent multiple detections from a single press.
3. Win Condition:
   • If the marker reaches the first or last LED, the game ends, and the LEDs flash to indicate the winner.
4. Game Over:
   • After flashing, the winner's LED stays lit, and the game stops.

Testing and Adjustments

• Ensure proper wiring of LEDs and buttons before uploading the code.
• Adjust the debounce delay (200 ms) if buttons feel too slow or too fast.
• Try increasing the number of LEDs for a longer game.

The post Arduino Digital Tug of War appeared first on Teach Me Microcontrollers!.

Project Overview

In this project, we'll use the following components:

• Arduino UNO (or similar) board: The brain of the system.
• Ultrasonic sensor (HC-SR04): Measures the distance to an object by sending out ultrasonic waves and calculating the time it takes for the echo to return.
• Buzzer: Produces beeping sounds that speed up as the distance to an obstacle decreases.

How It Works

The ultrasonic sensor sends a pulse and waits for it to bounce back from an obstacle. Based on the time taken for the pulse to return, the Arduino calculates the distance to the object. Depending on the distance, the buzzer emits beeps at different rates — the closer the object, the faster the beeping.

When the trigger pin is held high, the ultrasonic sensor module begins emitting a signal until that pin is pulled low. If the signal encounters an obstacle, it will bounce back to the sensor. As a result, the "echo" of the signal is used to measure the distance: the duration between the sending of the signal and the return of the signal can be read on the echo pin as a pulse.

The distance in centimeters between the HC-SR04 and the obstacle can then be calculated using

where 0.034 is the speed of sound: 340 m/s

This system mimics the parking sensors commonly found in modern cars, providing audible feedback to the driver as they approach a barrier or obstacle.

Components Needed

1. Arduino UNO or any other Arduino board
2. Ultrasonic sensor (HC-SR04)
3. Active Buzzer
4. Jumper wires
5. Breadboard
6. USB cable (to connect Arduino to a computer)
7. Power source (if needed)

Circuit Diagram

To set up the Arduino parking sensor, connect the components as follows:

• Ultrasonic Sensor (HC-SR04):
  • VCC to Arduino 5V
  • GND to Arduino GND
  • Trig to Arduino Pin 9
  • Echo to Arduino Pin 10
• Buzzer:
  • Positive terminal to Arduino Pin 11
  • Negative terminal to Arduino GND

Code

Here’s the Arduino sketch to make the parking sensor functional:

// Define pins for ultrasonic sensor and buzzer
const int trigPin = 9;
const int echoPin = 10;
const int buzzerPin = 11;

// Variables for distance calculation
long duration;
int distance;

void setup() {
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(buzzerPin, OUTPUT);
  
  Serial.begin(9600); // Initialize serial communication for debugging
}


void loop() {
  // Clear the trigPin by setting it LOW
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
 
  // Trigger the sensor by setting trigPin HIGH for 10 microseconds
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echoPin and calculate the duration
  duration = pulseIn(echoPin, HIGH);

  // Calculate distance in centimeters (speed of sound = 343 m/s)
  distance = duration * 0.034 / 2;

  // Print the distance for debugging purposes
  Serial.print("Distance: ");
  Serial.println(distance);

  // Control the buzzer based on distance
  if (distance <= 10) {
    // Very close, fast beeping
    tone(buzzerPin, 1000);
    delay(100);
    noTone(buzzerPin);
    delay(100);
  } else if (distance <= 30) {
    // Medium distance, slower beeping
    tone(buzzerPin, 1000);
    delay(300);
    noTone(buzzerPin);
    delay(300);
  } else if (distance <= 50) {
    // Farther away, even slower beeping
    tone(buzzerPin, 1000);
    delay(500);
    noTone(buzzerPin);
    delay(500);
  } else {
    // No obstacle nearby, no beeping
    noTone(buzzerPin);
  }

  delay(100); // Short delay before the next reading
}

Code Explanation

1. Pin Setup:
   • trigPin sends the ultrasonic pulse.
   • echoPin receives the reflected pulse.
   • buzzerPin controls the buzzer sound.
2. Distance Calculation:
   • The ultrasonic sensor sends out a pulse from the trigPin, and the time it takes for the pulse to bounce back is measured via the echoPin. The duration is used to calculate the distance in centimeters.
3. Buzzer Control:
   • If the distance is less than or equal to 10 cm, the buzzer emits fast beeps.
   • If the distance is between 10 and 30 cm, the beeps are slower.
   • At distances between 30 and 50 cm, the beeping is even slower.
   • Beyond 50 cm, the buzzer remains silent.

Modifying the Code

You can adjust the distance thresholds or beep speed to suit your needs. For example, if you want to increase the beeping rate for farther distances, you can modify the if statements and delay() values accordingly.

Assembly Instructions

1. Connect the ultrasonic sensor to the Arduino using jumper wires as described in the circuit diagram.
2. Connect the buzzer to the Arduino.
3. Upload the code to your Arduino using the Arduino IDE.
4. Power the Arduino using a USB cable or external power supply.

Testing the System

After assembling the circuit and uploading the code, place the sensor in front of a wall or another obstacle. As you move the obstacle closer, you should hear the buzzer beeping faster.

If the sensor does not detect the object correctly, check the wiring of the ultrasonic sensor and ensure the pins are connected properly.

Applications

• Car parking assist: A small, low-cost system to help drivers detect nearby objects when parking.
• Garage parking: Mount this system in your garage to detect the position of your car and ensure it’s parked safely.
• Object detection: Useful in robotics or automation projects to detect the presence of nearby objects.

Conclusion

This Arduino Parking Sensor project is a great way to understand how ultrasonic sensors work and how they can be integrated into real-world applications. You now have a functional parking sensor system that mimics the capabilities of modern car parking assistance technologies. With a few tweaks, you can expand this project further by adding visual feedback using LEDs or an LCD screen. Happy tinkering!

The post Arduino Parking Sensor Project appeared first on Teach Me Microcontrollers!.

This project is a simple clone of the popular Flappy Bird game. The original app isn't available in the app store anymore, although there are a lot of clones. Here is the original:

The objective of the game, for those who are unfamiliar, is to control the bird as it avoids “pipes”. The amusing part is that the bird jumps in the air with every push of the button and falls when left unattended, making it harder to avoid the pipes.

This is a good starting project for those who want to dive into game design. You’ll be familiar with two-dimensional coordinates, randomization, and button handling.

ChatGPT suggested the idea for this game. Then I tried googling for any similar project that uses a dot matrix. To my surprise, there was none so that affirmed my decision to make one.

Bill of Materials

1. Arduino board
2. Dot Matrix display
3. Buzzer

Any Arduino board with an ATMega microcontroller can be used in this project. The dot matrix orientation is such that the DIN pin is on top. A buzzer or piezo speaker can be optionally added for simple game sounds.

Wiring diagram

Gameplay

The main screen is a simple marquee of the text “Arduino Flappy Bird”. The game starts when the user presses the button. The “bird” starts in the middle and traverses left to right. Obstacles or pipes appear in its path with the passage location randomly generated. The player scores a point every time the bird passes a pipe. Thus, the player must press the button correctly to avoid a pipe. The game is over if the bird hits a pipe or the ground.

Each frame takes 1 second to execute. As one frame passes, so does one movement of the bird and the pipe. The bird may move up two pixels when the button is pressed or down until the button is pressed. Similarly, the pipe moves 1-pixel position from right to left.

The button press serves as an external interrupt. In the interrupt service routine, a flag is either set or clear depending on the current state of the bird. If the bird is falling, then the flag is set, indicating that the bird is now rising. When the bird is already rising, the flag clears to indicate the bird is falling. This flag is continuously checked inside the loop to create the appropriate bird movement.

Code/Sketch

The full code can be downloaded from this repository.

Video

The post Arduino Flappy Bird Dot Matrix Project appeared first on Teach Me Microcontrollers!.

Materials

• Arduino (Uno/Nano/Micro)
• Single LED Dot Matrix
• MPU6050 Breakout Board
• Breadboard, connecting wires

Theory/Concept

The dots in a single LED matrix follow a coordinate system, with the horizontal the x-axis and the vertical the y-axis. You can set your own origin point by mounting the dot matrix whichever your like; In my case, the origin point is the upper right corner.

The device may only tilt to the left or to the right. This means it’s only tilting on one axis.

I used an MPU6050 accelerometer + gyroscope to detect the movement. Jeff Rowberg’s library provides examples on how to measure the yaw, pitch and roll movements of the device. This is again, depending on how you mount the MPU6050 against the dot matrix. On my setup, I only need to read the roll of the MPU6050.

It’s much easier to analyze first if I just select a single row of dots. Then I divided the movements into two steps. First is from the initial position to the 45 inclined position:

The rightmost dot would have to move four positions to get to its final position on the 2nd image. The second from the right would have to move three positions and so on. The farther the dot from the center, the greater the distance it has to travel to get to its final position.

My algorithm is to set the movements of the dots against their initial position, using Arduino’s map() function:

for(int i=0;i<8;i++){
  int a = u[i][1]+ u[i][0] - 4;
  m[i] = map(angle,90,45,u[i][1],a);
  n[i] = u[i][0];
  for(int j=0;j<8;j++){
    lmd.setPixel(m[i]+j,n[i],true);
  }
}

Here, setPixel() is a function that turns on a dot in a specific coordinate. This function is from LedMatrixDriver library I am using for this project.

The second step is from the 45 degree inclined position to the upright position:

Here, instead of moving up in the y-axis, the dots need to move right in the x-axis to reach their final destination.

The algorithm now is:

for(int i=0;i<8;i++){
  p[i] = map(angle,45,0,u[i][0],4);
  q[i] = u[i][0];
  for(int j=1;j<8;j++){
    lmd.setPixel(q[i],p[i]-j,true); 
  }
}

To fill up the dot matrix, I just increment/decrement the position of the line of dots:

The same concept follows if the device is tilted to the left.

Wiring

Sketch/Code

The code uses the MPU6050 library from Jeff Rowberg and the LedMatrixDriver library. You can read my article on MPU6050 for some basic understanding of the accelerometer and gyroscope. I also wrote a tutorial for using the MAX7219 driver with the LED dot matrix.

The full sketch/code is in my repository.

Output Video

I am still looking to improve this project, particularly adding gravity and momentum effects to make the movements more convincing.

If you have any questions, suggestions or reactions about this project, kindly drop a comment below!

The post Dot Matrix Droplets Project appeared first on Teach Me Microcontrollers!.

This week’s Arduino project is a classic one and ideal for beginners. Here I will be showing how to build a simple clap switch for an RGB LED strip. Basically, a microphone captures the sound of the clap and converts it to a voltage. The Arduino processes that voltage and then changes the color of the RGB LED strip.

What You’ll Need

• Arduino Microcontroller (Nano in this case but UNO is possible too)
• Microphone breakout board
• Connecting wires (jumper)
• RGB LED strip (12V)
• 3 x 2N2222A NPN Transistor
• 12V power source

Wiring Diagram

The condenser microphone converts sound to an analog voltage. My Arduino microphone tutorial covers the basics of how condenser microphones work. The voltage from the microphone is read by the ADC of the Arduino and converted it to a digital value.

You can use the analogReadSerial sketch (File> Examples>Basics) first to know the value of your clap sound. After that, replace the value of the threshold variable in the sketch below.

This clap switch project listens to three claps 1 second apart. When this condition is met, the RGB LED strip changes color. Moreover, the sequence of colors follows R-O-Y-G-B-V.

A particular LED turns on when the voltage drop across it is zero. For example, a high pulse from Arduino's D9 will turn on the transistor resulting in the green LED turning on. The 2N2222A transistor in this project was enough to handle the current requirements of the LED strip.

You can use a 5V or a 12V LED strip as long as you have the power source for it. My diagram uses a 12V LED strip so I needed to have a separate supply for the Arduino board.

Sketch/Code

/*
 * Clap Switch for RGB LEDs using Arduino
 * 
 * by: R. Pelayo
 * Created: February 13, 2020
 * 
 * Full project tutorial on: teachmemicro.com/clap-switch-rgb-led-arduino
 */

#define threshold 200  //change this according to your clap sound
int red = 10;
int green = 9;
int blue = 11;
int mic = A0;
int sound_value;
int clap_counter = 0;
int color_counter = 0;

void setup() {
  pinMode(red,OUTPUT);
  pinMode(green,OUTPUT);
  pinMode(blue,OUTPUT);
}

void loop() {
  int sound_value = analogRead(mic);
  if(sound_value > threshold){
    clap_counter++;
    if(clap_counter > 2){
      clap_counter = 0;
      color_counter++;
      if(color_counter > 5) color_counter = 0;
      changeColor();
    }
  }
  delay(1000);
}

void changeColor(){
  switch(color_counter){
    case 0: //display red
      analogWrite(red,255);
      analogWrite(green,0);
      analogWrite(blue,0);
    case 1: //display orange
      analogWrite(red,210);
      analogWrite(green,100);
      analogWrite(blue,0);
    case 2: //display yellow
      analogWrite(red,255);
      analogWrite(green,255);
      analogWrite(blue,0);
    case 3: //display green
      analogWrite(red,0);
      analogWrite(green,255);
      analogWrite(blue,0);
    case 4: //display blue
      analogWrite(red,0);
      analogWrite(green,0);
      analogWrite(blue,255);
    case 5: //display violet
      analogWrite(red,255);
      analogWrite(green,0);
      analogWrite(blue,255);
  }
}

Here, I set the threshold value to 200. Every time the voltage from the microphone reaches this level, a variable (clap_counter) increments. When this variable reaches a value of three, the function to change color is invoked, and another variable (color_counter) increments. The color_counter variable is used for knowing which color in the sequence to be displayed.

The post Clap Switch for RGB LEDs using Arduino appeared first on Teach Me Microcontrollers!.

What You’ll Need

• Flame sensor module
• Microcontroller (Arduino or NodeMCU ESP8266 or PIC)
• Power source
• Output device (buzzer or smartphone)

Flame Sensor Module

The star of this project is this flame sensor module:

This module contains a phototransistor and signal conditioning electronics. A phototransistor conducts more electrical current when exposed to light. Physics taught us that (visible) light comprises of all colors, from red to violet. By coating the phototransistor with black epoxy, it becomes more sensitive to red or even invisible below red or infrared. Interestingly, flame emits infrared radiation. Thus, when this sensor sees flame, it conducts more current.

Microcontrollers read voltage, not current. Thus, the signal conditioning circuit in the module converts the current into levels of voltage that is considered safe for the microcontroller (typically, the maximum voltage should be the supply voltage to the microcontroller).

The flame sensor module also contains indicator LEDs. One LED lights up (PWR-LED) when the module is powered up while another lights up (D0-LED) when the sensor detects fire.

Moreover, the voltage from the D0 pin falls to zero in the vicinity of fire and rises to the supply voltage when there is none. We use this as a trigger for the microcontroller.

Arduino - Flame Sensor Interface

I aim to use three different kinds of microcontroller for this project. First, I’ll show how to build an Arduino flame sensor with a buzzer as indicator.

Since the module only provides two values, on and off, we don’t need to use any of the analog pins of the Arduino. The wiring diagram below shows that the D0 pin of the module connects to the digital pin 2 of the Arduino UNO:

Moreover, the VCC or + pin connects to 5V and the G pin is connected to GND. Note that the fire detector module can also run on 3.3V. Finally, the buzzer’s red wire is connected to pin 5 while its black pin is wired to GND. In this project, I am using a buzzer that can run from voltages 3 to 24 V.

The sketch is straightforward:

const int sensor_pin = 2;
const int buzzer = 5;

void setup() {
  pinMode(sensor_pin,INPUT_PULLUP);
  pinMode(buzzer,OUTPUT);
}

void loop() {
  if(digitalRead(sensor_pin) == LOW){
    digitalWrite(buzzer,HIGH);
  }else{
    digitalWrite(buzzer,LOW);
  }
}

I gave pins 2 and 5 appropriate aliases:

const int sensor_pin = 2;
const int buzzer = 5;

Inside setup(), we declare sensor_pin as an input pin while buzzer is an output pin:

pinMode(sensor_pin,INPUT_PULLUP);
pinMode(buzzer,OUTPUT);

In loop(), we check if the sensor_pin voltage is zero. If it is, we sound the buzzer. If not, then turn off the buzzer.

void loop() {
  if(digitalRead(sensor_pin) == LOW){
    digitalWrite(buzzer,HIGH);
  }else{
    digitalWrite(buzzer,LOW);
  }
}

The fire sensor can detect flame within its 60 degree capture angle. The distance of the flame varies with ambient light. In my tests, the sensor was able to detect a match’s flame from around 5 cm.

Using the Flame Sensor with PIC16F877A

The difference here is that we are using a different microcontroller and thus, a different compiler. Nevertheless, the concept is the same: the PIC16F877A reads the D0 pin and if its low, fire up the buzzer and so on.

Here’s the wiring diagram:

The D0 pin of the fire detector module connects to RB0 while the buzzer’s red wire is connected to RB1.

The C code (XC8) for the circuit above is shown below:

#define _XTAL_FREQ 4000000
#include <xc.h>

void main(void) {
    
    TRISBbits.TRISB0 = 1;
    TRISBbits.TRISB1 = 0;
    while(1){
        if(PORTBbits.RB0 == 0){
            PORTBbits.RB1 = 1;
        }else{
            PORTBbits.RB1 = 0;
        }
    }
    return;
}

The pin RB0 is an input pin while RB1 is an output pin. Hence their corresponding TRIS bits should be:

TRISBbits.TRISB0 = 1; 
TRISBbits.TRISB1 = 0;

We then use simple if-else statements to check if the sensor detects a fire and then turn on or off the buzzer:

while(1){
 if(PORTBbits.RB0 == 0){
    PORTBbits.RB1 = 1; 
 }else{ PORTBbits.RB1 = 0; 
 } 
}

There's no loop() function in XC8 so we create our own infinite loop using the while(1) statement.

That's it for interfacing the flame detector with a PIC microcontroller.

Flame Sensor and ESP8266

Finally we are down to our last microcontroller, the ESP8266. Of course, we will be using the flame sensor with the ESP8266 according to the latter’s capabilities. In this version, the user will receive a push notification on his or her smartphone everytime the fire detector is triggered.

Here’s the wiring diagram:

This diagram is the simplest since we don’t need the buzzer anymore. Note that I am using a NodeMCU ESP8266 board for this project. If this is your first time using the NodeMCU, please follow the instructions to program it using the Arduino IDE.

Here is the full sketch:

/*
 *  This sketch sends push notifications via Pushbullet App through PushingBox.
 *
 *  You need to create a service and scenario at pushingbox.com to acquire
 *  a device ID. Also change lines 12 and 13 to your own WiFi SSID and password
 *
 */
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>

const char* ssid     = "<your WiFi SSID>";
const char* password = "<your WiFi password>";

const char* host = "api.pushingbox.com";
const char* devid = "vADAB279A6A4DA5A";

const int sensor_pin = 14;

void setup()
{
    pinMode(sensor_pin,INPUT_PULLUP);
    pinMode(buzzer,OUTPUT);
    
    Serial.begin(115200);
    delay(10);

    // We start by connecting to a WiFi network

    Serial.println();
    Serial.println();
    Serial.print("Connecting to ");
    Serial.println(ssid);

    WiFi.begin(ssid, password);

    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }

    Serial.println("");
    Serial.println("WiFi connected");
    Serial.println("IP address: ");
    Serial.println(WiFi.localIP());
}

int value = 0;

void loop()
{
    delay(5000);

    if(digitalRead(sensor_pin) == LOW){  //flame sensor triggered

    Serial.print("connecting to ");
    Serial.println(host);

    // Use WiFiClient class to create TCP connections
    WiFiClient client;
    const int httpPort = 80;
    if (!client.connect(host, httpPort)) {
        Serial.println("connection failed");
        return;
    }

    // We now create a URI for the request
    String url = "/pushingbox";
    url += "?devid=";
    url += devid;
    
    Serial.print("Requesting URL: ");
    Serial.println(url);

    // This will send the request to the server
    client.print(String("GET ") + url + " HTTP/1.1\r\n" +
                 "Host: " + host + "\r\n" +
                 "Connection: close\r\n\r\n");
    unsigned long timeout = millis();
    while (client.available() == 0) {
        if (millis() - timeout > 5000) {
            Serial.println(">>> Client Timeout !");
            client.stop();
            return;
        }
    }

    // Read all the lines of the reply from server and print them to Serial
    while(client.available()) {
        String line = client.readStringUntil('\r');
        Serial.print(line);
    }

    Serial.println();
    Serial.println("closing connection");
    }else{;}
}

Before uploading this sketch, we need to configure Pushingbox and Pushbullet for this project to work. 

First, go to Pushingbox and signup or login to your account. You will then be redirected to the Dashboard page:

Click the My Services tab and click “Add a service”:

Next, look for the Pushbullet service:

However, before your press the “Select this service” button, you need to have a Pushbullet account first.

Go to Pushbullet:

Sign up or login to your account. After that, find Settings on the dashboard. There you’ll find your access token:

Go back to Pushingbox, click add a service again and this time click the “Select this service” button for pushbullet. A window appears:

Give the configuration a name, paste your Pushbullet token then click submit.

Next, click the My Scenarios tab to add a scenario linked to the service just created:

After creating the scenario, add an action:

Make sure you select the appropriate scenario:

A window appears; give the action title, push notification message and then click submit.

Finally, copy the device ID whose location is shown:

Now on the sketch, locate line 16 and change the device ID:

const char* devid = "vADAB279A6A4DA5A";

Also, don’t forget to provide your own WiFi’s SSID and password on lines 12 and 13:

const char* ssid     = "<your WiFi SSID>";
const char* password = "<your WiFi password>";

Upload the sketch and you're good to go! Now, install the Pushbullet app on your smartphone and login to your account. Everytime the fire detector is triggered, you will receive a push notification!

Conclusion

The flame sensor project here is limited in capture angle and range. However, there's a special module that contains five phototransistors:

This 5-way fire detector module has a capture angle of 120°. Check prices here.

Hopefully, this article helps you in any way. For any questions, reactions or suggestions, kindly drop comments below.

The post Flame Sensor Project: Comprehensive Guide appeared first on Teach Me Microcontrollers!.

Hardware Setup

I have setup this project on a mini breadboard using the parts:

• HMC5883L Magnetometer
• Nokia 3310/5110 LCD Breakout Board
• Arduino Pro Mini 5V

The HMC5883L magnetometer is fairly common but for this project, I used the 10 DOF IMU from DFRobot. This module contains not only the HMC5883L but also a BMP280 barometric pressure sensor, ITG-3205 gyroscope and ADXL345 accelerometer into one device. Note that the ordinary HMC5883L magnetometer module will still work with this project. Moreover, the Nokia 3310/5110 LCD is used for display and the Arduino Pro Mini is the brains of the project.

Needed Libraries

For this project's sketch to run, you'll need the following libraries:

• Adafruit's PCD8544 and GFX
• DFRobot's HMC5883L

You can learn more about using the Nokia 3310/5110 LCD and its libraries in a separate article.

Developing the Project

Wiring

The project is not that hard because of the readily available libraries. The wiring is also straightforward:

Nokia LCD to Pro Mini Connection:

HMC5883L to Pro Mini Connection:

Reading Data from HMC5883L

The first step was to make sure the HMC5883L is giving out the correct heading. According to the example provided in the HMC5883L library, the range, measurement mode, data rate and samples must be set before reading out data from the magnetometer. Thus, I created this function:

void initCompass(){ 
 while (!compass.begin()) { 
  Serial.println("Could not find a valid QMC5883 sensor, check wiring!"); 
  delay(500); 
 } 

 Serial.println("Initialize QMC5883"); 
 compass.setRange(QMC5883_RANGE_2GA); 
 compass.setMeasurementMode(QMC5883_CONTINOUS); 
 compass.setDataRate(QMC5883_DATARATE_50HZ); 
 compass.setSamples(QMC5883_SAMPLES_8); 
}

The library has a neat begin() function which checks out if the sensor is connected or not, which I used as seen above.

Correcting for Magnetic Declination

Heading is the term used to measure your position from the north pole. North pole is actually the north geographic pole while compasses detect the north magnetic pole which is a different place although not that far from the other north pole. The distance between each pole is really not the issue; it's the magnetic declination between the two. Thus, there's a need to correct for this declination but first you must find out your area's declination through here.

For example, the magnetic declination in our area is - 0° 53' (negative 0 degrees and 53' minutes). This declination must be converted into radians:

Let's say the reading of the compass is 2.0 radians. The correct heading, accounting declination, is now:

Drawing the Compass

Now that I have the correct heading, the next part is to display that heading on the LCD. Showing the heading as a number is too easy; I wanted an arrow that will always point to the north like a real compass.

The GFX library I pointed out above has a line function:

drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t, y1, uint16_t color);

Here, the x0, y0 are the coordinates of the origin of the line while x1, y1 are those of the end point.

Specifying the origin of the arrow for the compass is just writing the center of the LCD which is (41, 23). The end point of the line is based on the heading. To illustrate:

The end point could be computed as:

In geometry, coordinate (0,0) is at the center. But here, our center is at (41, 23) thus the axes must be translated. Moreover, I wanted to draw the North line, not the heading line. Finally, the direction of the arrow must be corrected according to how the HMC5883L board is connected to my breadboard.

Full Sketch

Here is now the full Arduino Sketch for this project:

#include <SPI.h>
#include <Wire.h>
#include <DFRobot_QMC5883.h>
#include <Adafruit_GFX.h>
#include <Adafruit_PCD8544.h>

// Software SPI (slower updates, more flexible pin options):
// pin 7 - Serial clock out (SCLK)
// pin 6 - Serial data out (DIN)
// pin 5 - Data/Command select (D/C)
// pin 4 - LCD chip select (CS)
// pin 3 - LCD reset (RST)
Adafruit_PCD8544 display = Adafruit_PCD8544(7, 6, 5, 4, 3);

DFRobot_QMC5883 compass;

float arrDirection;
uint16_t centerX = 41;
uint16_t centerY = 23;
float endX;
float endY;
float hyp = 23;
float sum;

#define SAMPLE_SIZE 3

void setup()   {
  Serial.begin(9600);
  initDisplay();  

  display.println("Make figure");
  display.println("8's to calibrate sensor");
  display.display();
  initCompass();
  delay(5000);
  display.clearDisplay();
  
}

void initCompass(){
  while (!compass.begin())
  {
    Serial.println("Could not find a valid QMC5883 sensor, check wiring!");
    delay(500);
  }
  Serial.println("Initialize QMC5883");
  compass.setRange(QMC5883_RANGE_2GA);
  compass.setMeasurementMode(QMC5883_CONTINOUS); 
  compass.setDataRate(QMC5883_DATARATE_50HZ);
  compass.setSamples(QMC5883_SAMPLES_8);
}

void initDisplay(){
  display.begin();

  display.setContrast(50);

  display.display(); // show splashscreen
  delay(2000);
  display.clearDisplay();   // clears the screen and buffer

  display.setTextSize(1);
  display.setTextColor(BLACK);
  display.setCursor(0,0); 
}

float calcPosition(){
  
  for (int i=0;i<SAMPLE_SIZE;i++){
   Vector norm = compass.readNormalize();

   // Calculate heading
   float heading = atan2(norm.YAxis, norm.XAxis);
   //Calculate magnetic declination according to your location
   //See http://magnetic-declination.com
   float declinationAngle = (0.0 + (53.0 / 60.0)) / (180 / PI);
   heading -= declinationAngle;

   // Correct for heading < 0deg and heading > 360deg
   if (heading < 0){
     heading += 2 * PI;
   }

   if (heading > 2 * PI){
     heading -= 2 * PI;
   }
   sum += heading;
  }
  
  float output = sum/SAMPLE_SIZE;
  sum = 0;
  float outDegrees = output*180/PI;
  
  Serial.println(outDegrees);
  
  return output;
  
}

void loop() {
   
   display.drawCircle(centerX, centerY, 23, BLACK);
   endX = 41 - (hyp * sin(calcPosition()-PI/2));
   endY = 23 - (hyp * cos(calcPosition()-PI/2));
   
   display.drawLine(centerX, centerY, endX, endY, BLACK);
   display.drawLine(centerX+1, centerY+1, endX+1, endY+1, BLACK);
   display.drawLine(centerX+2, centerY+2, endX+2, endY+2, BLACK);
   display.setCursor(endX + 4, endY - 4);
   display.println("N");
   display.display();
   delay(500);
   display.clearDisplay();
}

Here you can see how I calculated the heading in degrees accounting magnetic declination and how I drew a line that always point north. I had to make the line thicker so I needed to draw the line three times with each coordinates incremented by a pixel. Also, I drew a circle to make it more compass-like.

Video

Here's the demonstration of the project:

Note that the HMC5833L must be calibrated before acquiring a more stable data. To calibrate, make figure 8's with the device.

That's it! Feel free to comment if you have any questions about this project. Happy building!

The post Arduino Compass with HMC5883L Magnetometer appeared first on Teach Me Microcontrollers!.

Setup

The Bluetooth modules I’ll be using are the old but still popular HC-05 modules. The first step is to make one module as master and another as slave. The module is slave by default so we only need to reconfigure one to be the master.

The HC-05 modules I own is the one without the KEY pin. In case you don’t know, the KEY pin, when driven high, gets the module into AT command mode.

My module contains a button for supposedly getting it to command mode by pressing and holding it before applying power to the module. It works but only during startup. To keep the module in command mode, pin 34 must be kept high. This is shown below:

The brown wire shown must be connected to the 3.3V pin. If successful, the red LED will flash once every two seconds.

I used an FTDI USB to Serial converter to configure the Bluetooth module once it’s in command mode. Then I used Arduino’s serial monitor to send out commands. The default baud rate for command mode is 38400.

To check if the HC-05 is indeed in command mode, I sent:

AT 
> OK

"OK" here is the module's reply.

Next, I reset the configurations to its default values:

AT+ORGL
> OK

Then, I set the module to master:

AT+ROLE=1 
> OK

Next, reset the module:

AT+RESET 
> OK

Then when its back, initialize:

AT+INIT 
> OK

Now, I want the module to link with only one device: the slave HC-05 on my robot car. To forget all the previous connections, I sent:

AT+RMAAD 
> OK

After this, I turned on the slave HC-05 because I needed to know its MAC address. Knowing the MAC address of available devices is simple. Just issue:

AT+INQ 
> +INQ:98D3:31:FC20A9,1F00,7FFF

Here, it shows that my slave device has a MAC address of 98D3:31:FC20A9. The 1F00 is the device class while the 7FFF is the received signal strength indicator (RSSI).

To pair with the slave device:

AT+PAIR=98D3,31,FC20A9,20 
> OK

The parameter for the AT+PAIR command is just the address of the slave address but is now separated by the comma instead of the colon and the timeout period (20 seconds in this example). After pairing, the LED on the master module will start flashing with about two seconds of pause.

Next, we bind the master and slave devices by using:

AT+BIND=98D3,31,FC20A9 
> OK

Finally, we link the two devices through:

AT+LINK=98D3,31,FC20A9 
> OK

If successful, both the master and slave device's LED will now blink twice followed by about two seconds of pause.

The good thing is even if I remove power from either master or slave, they will automatically connect with each other when both are turned on!

Wiring Up the Wireless Controller

Now that I’ve linked two Bluetooth modules together, it’s time to attach the master device to DFRobot’s Input shield. Here’s my setup:

I used an Arduino Mega with the shield but a UNO could work too. The Shield has an eight-pin female header on the top right side. It would’ve been awesome if the HC-05 fits there but it doesn’t. Naturally, I had to improvise. I still used the header but only its 5V and GND pins. The TX and RX pins of the module are connected to D13 and D13 respectively, via the ICSP header. The power to the controller is provided by a small power bank.

Here is the controller with the Shield-Bot:

Arduino Sketch

The shield bot setup is the same as that in my Bluetooth RC car project. You can view the Arduino sketch for the robot there. In that project, the robot moves when the Bluetooth module receives the following commands:

• "f" -> forward
• "b" -> backward
• "l" -> left
• "r" -> right

So all I need to do is make the controller send these characters wirelessly. I decided to use only the controller's joystick for the moment.

After testing, I found out that the joystick Y-axis is connected to A2, and the X-axis is connected to A3. When the joystick is all the way to the right, the A3 value is 0. Similarly, when the joystick is all the way up, A2 is zero. This means all the way left and down could be 1023 for A3 and A2.

Here is my sketch for the controller:

#include <SoftwareSerial.h>

SoftwareSerial Bluetooth(13, 12); // RX, TX

#define up_button  8
#define down_button A1
#define left_button 9
#define right_button  12

#define stick_button  A0
#define level_stick A3
#define vertical_stick  A2

void setup() {
  Bluetooth.begin(9600);
  Serial.begin(9600);
  Serial.println("Waiting for command...");
  Bluetooth.println("Waiting for command");
  
  pinMode (left_button, INPUT);
  pinMode (right_button, INPUT);
  pinMode (up_button, INPUT);
  pinMode (down_button, INPUT);

  pinMode (stick_button  , INPUT);
  pinMode (level_stick   , INPUT);
  pinMode (vertical_stick, INPUT);
}

void loop() {
  int left_state = digitalRead (left_button);
  int right_state = digitalRead (right_button);
  int up_state = digitalRead (up_button);
  int down_state = digitalRead (down_button);
  int stick_state = digitalRead (stick_button);
  int level_value = analogRead (level_stick);
  int vertical_value = analogRead (vertical_stick);
  if(level_value > 800){
    Bluetooth.println("l");
    Serial.println("l");
  }else if(level_value == 0){
    Bluetooth.println("r");
    Serial.println("r");
  }else if(vertical_value > 800){
    Bluetooth.println("b");
    Serial.println("b");
  }else if(vertical_value == 0){
    Bluetooth.println("f");
    Serial.println("f");
  }else{
    Bluetooth.println("s");
    Serial.println("s");
  }
  delay (500);
}

That’s it! Thanks for viewing this project. If you have any concerns, kindly drop a comment!

The post Wireless Controller for Bluetooth RC Car appeared first on Teach Me Microcontrollers!.

An obstacle-avoiding robot is a simple wheeled machine that avoids any obstacle in front of it. The obstacle can be detected using ultrasonic or infrared signals; these signals can be reflected back to their source by solid objects. For this project, I will be using an infrared sensor to detect the obstacle.

Materials

I chose to buy my own robot body primarily to reduce building time and also because it's very cheap. The circular robot body comes with two geared DC motors with wheels and an AA battery holder. There are also holes on the chassis for mounting the Arduino board and other needed modules.

I decided to use three 18650 Li-Po batteries as power source which gives around 11 volts. The L298N module isn't like the one I featured in my tutorial but it's basically the same except for a power button which makes it better (because I don't have to include a switch on this robot).

• Arduino UNO Rev3 or similar
• Circular Robot Kit which contains:
  • 2 x Geared DC Motors
  • Top and Bottom Chassis
  • 2 x Caster Wheels
  • Metal Standoffs
  • Screws and Nuts
• Infrared Avoidance Sensor Module
• L298N Motor Driver Module
• 3 x 18650 Batteries with Holder
• Connecting Wires

Of course, any robot body can be used with this project, as long as we have the same type of obstacle sensor (IR), motor driver (L298N) and microcontroller (Arduino).

Construction

As mentioned, the robot chassis already has holes in it which made the assembly rather easy. However, it seems the chassis was not meant to be used with the materials I listed above so I had to improvise.

Step 1: Assembling the Robot Base

The robot chassis has two main parts: the bottom and the top part. The bottom part is where the main wheels and swivel caster wheels are attached. It is also the part where I attached the four IR sensors for obstacle detection.

As you can see, I've soldered wires to the motor. These are male-male jumper wires with the other end cut off for easy soldering.

The chassis comes with two caster wheels and has holes for both but I found out that the front caster wheel tends to lift up the base, hence, not allowing the bigger wheels to touch the ground properly. So I had to remove it (can be seen in the video below).

Step 2: Assembling the Robot Top

Next is to attach the rest of the components in the top part of the robot chassis. As I've mentioned, the top part was not meant to be used with the modules I've chosen for this project so I had to improvise a bit. I attached the battery holder, L298N module and IR sensor "motherboard" on one side:

I ran out of space! So I had to attach the Arduino UNO to the other side:

Step 3: Connect Some Wires

I used the following Fritzing and schematic diagrams for the wiring:

Step 4: Connect the Bottom and Top Parts

I used the extra holes on the top part for the wires to go through, making the wiring a bit tidier. The finished Arduino robot now looks like this:

Step 5: Upload the Code

The Arduino sketch for the robot is not that complicated. The idea is that the robot should go away from the obstacle detected by the IR sensors. For example, when the left most sensor is triggered, the robot must backpedal, turn right and then go forward.

/* 
Obstacle Avoiding Arduino Robot Sketch
by Roland
www.teachmemicro.com/arduino-robot-obstacle-avoiding
*/

//Motor Driver Pins
int Motor_INA = 3;
int Motor_INB = 5;
int Motor_INC = 6;
int Motor_IND = 9;
//Sensor Pins
int Sensor_IN1 = 10;
int Sensor_IN2 = 11;
int Sensor_IN3 = 12;
int Sensor_IN4 = 13;

void setup() {
 pinMode(Motor_INA,OUTPUT);
 pinMode(Motor_INB,OUTPUT);
 pinMode(Motor_INC,OUTPUT);
 pinMode(Motor_IND,OUTPUT);

 pinMode(Sensor_IN1,INPUT);
 pinMode(Sensor_IN2,INPUT);
 pinMode(Sensor_IN3,INPUT);
 pinMode(Sensor_IN4,INPUT);
}

void goReverse(){
  analogWrite(Motor_INA,0);
  analogWrite(Motor_INB,50);
  analogWrite(Motor_INC,0);
  analogWrite(Motor_IND,50);
  delay(500);
}

void goRight(){
  analogWrite(Motor_INA,0);
  analogWrite(Motor_INB,0);
  analogWrite(Motor_INC,50);
  analogWrite(Motor_IND,0);
}

void goLeft(){
  analogWrite(Motor_INA,50);
  analogWrite(Motor_INB,0);
  analogWrite(Motor_INC,0);
  analogWrite(Motor_IND,0);
}

void stopBot(){
  analogWrite(Motor_INA,0);
  analogWrite(Motor_INB,0);
  analogWrite(Motor_INC,0);
  analogWrite(Motor_IND,0);
}

void goStraight(){
  analogWrite(Motor_INA,50);
  analogWrite(Motor_INB,0);
  analogWrite(Motor_INC,50);
  analogWrite(Motor_IND,0);
}
void loop() {
  delay(500);
  if(digitalRead(Sensor_IN1) == 0 || digitalRead(Sensor_IN2) == 0){
    goReverse();
    delay(100);
    stopBot();
    delay(100);
    goRight();
    delay(100);
    stopBot();
    delay(100);
    goStraight();
  }else if(digitalRead(Sensor_IN3) == 0 || digitalRead(Sensor_IN4) == 0){
    goReverse();
    delay(100);
    stopBot();
    delay(100);
    goLeft();
    delay(100);
    stopBot();
    delay(100);
    goStraight();
  }else if(digitalRead(Sensor_IN1) == 0 && digitalRead(Sensor_IN2) == 0 && digitalRead(Sensor_IN3) == 0 && digitalRead(Sensor_IN4) == 0){
    stopBot();
  }else{
    goStraight();
  }
  
}

The IR sensor is basically an IR LED and receiver pair. When something is in front of it, the radiation from the IR LED bounces back to the receiver. If nothing is in front, the receiver will receive nothing. This concept is a simple "on and off" scheme.

So to detect an obstacle, I only had to read the pin where an IR sensor is connected. If it's high, there's something there. Otherwise, there's nothing in front of the sensor.

To move forward, I need to rotate the wheels in the same direction. I wanted the robot to not move too fast. In order to control its speed, I used PWM to drive the motors through the L298N driver module. Producing PWM is just using analogWrite() but of course, I had to make sure that the Arduino pins for motor control are PWM pins.

Video

The video below shows the whole construction and assembly process as well as a demonstration on how the Arduino robot runs:

Got any questions, tips or reactions? Kindly comment below or create a thread on our community page!

The post Obstacle-Avoiding Arduino Robot appeared first on Teach Me Microcontrollers!.