DEV Community: Akshay Jain

Building a UWB Distance Monitoring and Alert System with Arduino

Akshay Jain — Mon, 19 Oct 2026 07:28:27 +0000

Measuring the distance between two points wirelessly can be useful in proximity detection, object monitoring, and embedded automation projects. While ultrasonic sensors and infrared sensors are common choices for short-range distance measurement, Ultra-Wideband (UWB) technology offers another approach for applications that require wireless ranging.

In this project, I built a UWB-based distance monitoring and alert system using an Arduino UNO and two REYAX RYUW122_Lite UWB modules. The system measures the distance between an Anchor and a Tag, displays the reading on a 16×2 I2C LCD, and activates a buzzer when the distance exceeds a predefined threshold.

Overview

The project consists of two UWB modules, an Arduino UNO, an LCD, and a buzzer.

One RYUW122_Lite module operates as the Anchor and connects to the Arduino through UART communication. The second module operates as the Tag. The Anchor requests a distance measurement and receives the ranging result from the Tag.

The Arduino processes the returned distance, displays it in centimeters, and checks whether it exceeds the configured threshold of 200 cm. If the distance crosses that limit, the buzzer activates.

Components Required

Arduino UNO
2 × REYAX RYUW122_Lite UWB modules
16×2 I2C LCD
Active-low buzzer module
Logic-level shifter for UART communication
Regulated 3.3 V power supply for the UWB modules
Jumper wires and breadboard

Understanding REYAX RYUW122_Lite UWB Module

The REYAX RYUW122_Lite is a UWB antenna transceiver module. The module can be configured using UART AT commands, making it suitable for microcontroller-based projects. It supports distance measurement between an Anchor and a Tag and can achieve approximately 10 cm accuracy under suitable conditions. Actual performance depends on the environment, antenna placement, and obstacles.

Hardware Connections

Connecting the Anchor to Arduino UNO

The Anchor communicates with the Arduino using UART. Since the RYUW122_Lite operates at 3.3 V and the Arduino UNO uses 5 V logic, a suitable logic-level shifter should be used for the UART signal connections.

Connect the Anchor's TXD pin through the level shifter to Arduino D9, configured as the software serial RX pin. Connect Arduino D10, configured as the software serial TX pin, through the level shifter to the Anchor's RXD pin.

Power the Anchor using a regulated 3.3 V supply and connect its ground to Arduino GND.

Connecting the LCD

The 16×2 I2C LCD uses four connections. Connect VCC to 5 V, GND to GND, SDA to Arduino A4, and SCL to Arduino A5. If the LCD's A0, A1, and A2 address jumpers are open, its I2C address is 0x27.

Connecting the Buzzer

For the active-low buzzer module used in this setup, connect its positive terminal to the 5 V supply and its control/negative terminal to Arduino D2. The buzzer activates when D2 is driven LOW. Use a suitable transistor driver if the buzzer's current requirements exceed what an Arduino pin can safely handle.

Connecting the Tag

The second UWB module is configured as the Tag and powered from a regulated 3.3 V supply. Connect its GND to ground. The Tag does not require a direct UART connection to the Arduino in this configuration.

Never apply 5 V or 12 V directly to the module's 3.3 V power input.

Configuring the UWB Modules

Before running the Arduino sketch, configure the modules using a UART terminal that supports AT commands.

Set the Anchor to Anchor mode using:

AT+MODE=1

Set the Tag to Tag mode using:

AT+MODE=0

Configure both modules with the same network ID. For example:

AT+NETWORKID=1

If the Arduino sketch uses a software serial baud rate of 9600, configure the Anchor's UART baud rate accordingly:

AT+IPR=9600

Make sure the module addresses, network configuration, baud rate, and ranging command match the actual firmware and Arduino sketch.

Arduino Software

The Arduino sketch handles UART communication with the Anchor, receives the ranging response, extracts the distance, updates the LCD, and controls the buzzer.

The project uses the SoftwareSerial library and the LiquidCrystal_I2C library by Frank de Brabander. The sketch should send a valid ranging request to the Anchor and parse the response returned by the module.

For example, a ranging command may look like this:

AT+ANCHOR_SEND=TAG,2,Hi

A response can look like this:

+ANCHOR_RCV=TAG,2,Hi,50 cm

The exact command and response format must match the module configuration and firmware. The Arduino code should also handle missing or invalid responses instead of interpreting them as valid distance measurements.

Once the distance has been extracted, the program compares it with the 200 cm threshold. If the distance exceeds the limit, it activates the buzzer; otherwise, the alert remains inactive.

Testing the Project

After completing the wiring and configuring both modules, upload the Arduino sketch and power on the system. The LCD should display the measured distance between the Anchor and Tag.

Move the modules closer together and farther apart to check whether the displayed readings change accordingly. When the distance exceeds 200 cm, the buzzer should activate.

Repeat the test in different positions and environments. Walls, obstacles, antenna orientation, and the surrounding environment can affect ranging performance, so it is worth observing how the readings behave under different conditions.

What Could Be Improved?

This project is a useful starting point, but there are several ways to extend it.

Push buttons could be added to adjust the alert threshold without modifying the code. LEDs could indicate safe, warning, and alert states. Measurement filtering and separate trigger/reset thresholds could reduce repeated buzzer switching when readings fluctuate near the limit.

Another extension would be to connect an ESP32 to a monitoring dashboard and record distance measurements over time. For a more advanced project, multiple Anchors could be explored for indoor positioning, provided the hardware configuration and ranging protocol support the intended positioning method.

Final Thoughts

Building this project provided a practical way to explore UWB ranging, UART communication, and Arduino-based alert systems. It demonstrates how two wireless modules can be used to measure distance and trigger an action when a predefined limit is crossed.

For the complete project tutorial, including the hardware setup and implementation details, see Distance Monitoring and Alert System Using RYUW122_Lite UWB Modules and Arduino.

Have you worked with UWB modules in an Arduino or ESP32 project? What applications or improvements would you explore next?

Ultrasonic Sensor HC-SR04 Ultrasonic Sensor HC-SR04 with Arduino: A Beginner's Guide to Distance Measurement

Akshay Jain — Tue, 21 Jul 2026 09:16:14 +0000

HC-SR04 ultrasonic sensor is one of the most popular sensors in the Arduino ecosystem because it makes measuring distance incredibly simple.

The HC-SR04 uses ultrasonic sound waves (40 kHz) to determine how far an object is from the sensor. It works by transmitting sound waves, waiting for them to bounce back from an object, and calculating the distance based on the time taken for the echo to return.

In this tutorial, we'll learn what the HC-SR04 sensor is, how it works, its key specifications, real-world applications, and how to interface it with an Arduino UNO.

This article is adapted from a project published on Play with Circuit, where we regularly share Arduino, ESP32, IoT, and embedded systems tutorials.

What is the HC-SR04 Ultrasonic Sensor?

The HC-SR04 is a non-contact distance measurement sensor widely used in electronics and robotics projects. Since it uses ultrasonic waves instead of light, it performs reliably in different lighting conditions.

The module contains an ultrasonic transmitter, an ultrasonic receiver, and onboard control circuitry. Whenever the Trigger pin receives a pulse, the sensor emits ultrasonic waves. These waves travel through the air, hit an object, and return to the receiver. The sensor then calculates the distance by measuring the travel time of the sound.

One of the biggest advantages of the HC-SR04 is its simplicity. It requires only four pins and can be connected to an Arduino in just a few minutes.

Key Features of HC-SR04

Operating voltage: 5V DC
Operating current: Approximately 15 mA
Operating frequency: 40 kHz
Measurement range: 3 cm to 300 cm
Accuracy: Approximately ±3 mm
Measuring angle: Less than 15 degrees
Dimensions: 45 mm × 20 mm × 15 mm
Supports non-contact distance measurement
Low power consumption
Easy interfacing with Arduino and other microcontrollers

These specifications make the HC-SR04 suitable for both beginner and advanced electronics projects.

HC-SR04 Pinout

The HC-SR04 has four pins:

VCC: Provides power to the sensor and should be connected to 5V.
Trig: Receives a 10-microsecond pulse to initiate distance measurement.
Echo: Outputs a pulse whose width represents the distance to the object.
GND: Connected to the ground of the Arduino.

Because there are only four connections, the sensor is ideal for beginners learning about sensor interfacing.

How Does the HC-SR04 Work?

The HC-SR04 operates using the principle of echolocation, which is similar to how bats and dolphins navigate.

The process works as follows:

Arduino sends a 10-microsecond pulse to the Trigger pin.
The sensor emits ultrasonic waves at a frequency of 40 kHz.
These sound waves travel through the air until they encounter an object.
The waves reflect back toward the sensor.
The Echo pin remains HIGH until the reflected signal is received.
Arduino measures the pulse duration and calculates the distance.

The formula used to calculate distance is:

Distance = (Time × Speed of Sound) ÷ 2

For Arduino projects, a simplified equation is commonly used:

Distance (cm) = Echo Time (µs) ÷ 58.3

For example, if the Echo pulse duration is 1000 microseconds, the calculated distance is approximately 17 centimeters.

Applications of HC-SR04

The HC-SR04 is used in countless electronics projects. Some popular applications include:

Obstacle avoiding robots
Smart parking systems
Water and liquid level monitoring
Automatic door systems
Home automation projects
Security and alarm systems
Drone navigation
Object detection systems
Smart dustbins
Industrial automation solutions

Its versatility makes it one of the first sensors many makers add to their toolkit.

Hardware Required

To build this project, you'll need the following components:

Arduino UNO (1)
HC-SR04 Ultrasonic Sensor (1)
16×2 LCD Display (1)
10k Potentiometer (1)
1k Resistor (1)
Breadboard (1)
Jumper Wires
USB Cable for programming the Arduino

Circuit Connections

Connect the HC-SR04 sensor as follows:

VCC → Arduino 5V
Trig → Arduino Pin 6
Echo → Arduino Pin 7
GND → Arduino GND

For the LCD connections:

RS → Pin 12
Enable → Pin 11
D4 → Pin 5
D5 → Pin 4
D6 → Pin 3
D7 → Pin 2

The Arduino continuously reads the distance from the HC-SR04 and displays it on the LCD in centimeters.

Tips for Stable Readings

Ultrasonic sensors can occasionally produce unstable values. To improve accuracy:

Use the NewPing library.
Average multiple readings.
Ensure the sensor is firmly mounted.
Avoid measuring soft or absorbent materials.
Keep objects within the recommended measurement angle.
Minimize electrical interference.

For most projects, averaging five to ten readings produces excellent results.

Final Thoughts

The HC-SR04 remains one of the best sensors for learning Arduino and embedded systems. It introduces important concepts such as timing, sensor interfacing, signal processing, and real-time measurements while being inexpensive and easy to use.

Whether you're building a robot, a parking assistant, or a liquid level monitoring system, the HC-SR04 is an excellent addition to your electronics toolbox.

For the complete tutorial, including LCD integration, additional examples, and more Arduino projects, visit Play with Circuit:

https://playwithcircuit.com/ultrasonic-sensor-hc-sr04-interfacing-with-arduino/

Long-Range Appliance Control System Using Arduino and LoRa

Akshay Jain — Sun, 21 Jun 2026 15:28:51 +0000

Most IoT projects depend on Wi-Fi and cloud services. But what if the device you want to control is located far away from your router, or internet connectivity isn't available at all?

That's the question that led me to experiment with a long-range appliance control system using Arduino Nano and the Reyax RYLR999 LoRa module.

The idea was simple:

Can a smartphone control electrical appliances located hundreds of meters—or even kilometers—away without using Wi-Fi?

The answer turned out to be yes.

In this project, I combined Bluetooth Low Energy (BLE) and LoRa communication to create a wireless system capable of controlling a lamp and a fan remotely.

Why LoRa?

LoRa (Long Range Radio) is a wireless communication technology designed specifically for transmitting data over very large distances while consuming very little power.

Unlike Bluetooth or Wi-Fi, LoRa is not intended for high-speed data transfer. Instead, it focuses on:

Long communication range
Low power consumption
Reliable transmission
Simple infrastructure

The system consists of two separate nodes.

Controller Node

The controller node acts as the bridge between the smartphone and the LoRa network.

A smartphone connects to the Reyax RYLR999 module using Bluetooth Low Energy through the LightBlue mobile application. Commands received from the phone are processed by an Arduino Nano and then transmitted over LoRa.

Target Node

A second RYLR999 module receives the LoRa message and passes it to another Arduino Nano.

The Arduino interprets the command and controls relay outputs connected to appliances.

Relay channel 1 controls a 240V AC bulb.
Relay channel 2 controls a 12V DC fan.

After executing the command, the receiver sends a response back to the controller node, providing confirmation that the operation was successful.

Hardware Used

Arduino Nano ×2
Reyax RYLR999 LoRa + BLE Module ×2
Bidirectional voltage level shifter ×2
16×2 I2C LCD display ×2
Two-channel relay module
Jumper wires
12V power supply
12V DC fan
240V AC bulb
Why Use the RYLR999 Module?

One thing I really liked about the Reyax RYLR999 module is that it combines two communication technologies inside a single module:

Bluetooth Low Energy
LoRa

This allows the smartphone to communicate locally through BLE, while LoRa handles long-distance communication.

Essentially, the module transforms short-range Bluetooth commands into long-range LoRa transmissions.

Understanding the Communication Flow

The sequence is fairly straightforward:

The smartphone sends a command through Bluetooth.
The controller node receives the command.
Arduino processes the message.
The LoRa module transmits the command.
The target node receives the message.
Arduino activates the appropriate relay.
The appliance switches ON or OFF.
A confirmation response is sent back.

This creates a simple but reliable two-way communication system.

Controller Connections

The controller setup consists of:

Arduino Nano
RYLR999 Module
Voltage Level Shifter
I2C LCD

Because the RYLR999 module operates with 3.3V logic while the Arduino uses 5V logic, a bidirectional level shifter is placed between them.

The module's LoRa TX pin connects to the Arduino RX pin through the level shifter, and the Arduino TX pin connects back to the module's LoRa RX pin.

SoftwareSerial communication is used for Bluetooth communication:

D2 → BLE Transmit
D3 → BLE Receive

The I2C LCD uses:

SDA → A4
SCL → A5

The display shows command and communication status information.

Target Connections

The target node also uses an Arduino Nano and an RYLR999 module.

This node continuously listens for LoRa packets.

A two-channel relay module is connected to:

D11 → Bulb control
D12 → Fan control

The relay module allows the Arduino to safely switch both AC and DC loads.

A second I2C LCD provides feedback about received commands and appliance status.

⚠️ Be careful when working with mains voltage. Disconnect power before wiring the AC bulb circuit.

Why Is a Voltage Level Shifter Needed?

The Arduino Nano uses 5V logic levels, while the RYLR999 module operates with 3.3V logic. Directly connecting them can damage the module.

To safely interface both devices, a bidirectional voltage level shifter is used between the Arduino and the RYLR999.

This ensures reliable serial communication without risking the hardware.

Relays: Connecting the Digital World to Real Appliances

Microcontrollers cannot directly control high-voltage devices.

That's where relays come in.

A relay acts as an electrically controlled switch. It allows a low-voltage signal from the Arduino to safely control:

AC loads such as bulbs
DC loads such as fans and motors

This isolation makes the system much safer and more practical.

Real-Time Feedback Using LCD Displays

Both nodes include 16×2 I2C LCD displays.

These displays show:

System initialization
Received commands
LoRa transmission status
Response messages

Having visual feedback makes debugging and troubleshooting much easier.

Commands Used

The smartphone sends commands using the LightBlue BLE application.

Examples include:

*L1# → Turn bulb ON
*L0# → Turn bulb OFF
*F1# → Turn fan ON
*F0# → Turn fan OFF

After successful execution, the target node sends back:

DONE

Potential Applications

This architecture can easily be expanded for:

Irrigation systems
Warehouse automation
Remote lighting
Industrial control

Final Thoughts

I documented the complete project, including wiring diagrams, source code, and configuration steps, on Play with Circuit, where I share tutorials on Arduino, embedded systems, and practical electronics projects.

Building a Smart Weather Monitoring System with ESP32-S3 and LVGL

Akshay Jain — Fri, 19 Jun 2026 06:13:31 +0000

In this project, I built a weather monitoring system using an ESP32-S3 Smart Display, a BME280 sensor, a rain sensor, and an LDR module. The system continuously measures environmental conditions and presents the information through a graphical interface created with LVGL.

Besides providing live weather information, this project serves as a great example of combining sensor interfacing with embedded GUI development.

System Overview

The weather station performs three major tasks:

Acquiring environmental measurements.
Processing sensor data.
Displaying information on a graphical dashboard.

The ESP32-S3 acts as the processing unit while LVGL provides the user interface.

How the System Works

The sensors continuously collect information from the environment. The ESP32-S3 processes the measurements and updates the dashboard in real time.

The complete workflow consists of:

Environmental data acquisition.
Sensor processing.
Graphical visualization.

Acquiring Environmental Data

Three sensors are used to monitor weather conditions.

BME280 Sensor

The BME280 provides:

Temperature
Relative humidity
Atmospheric pressure

Pressure measurements are also used to estimate altitude.

Communication with the controller takes place through the I2C interface.

Rain Sensor

Rain detection is performed using a conductive rain sensor.

Water droplets modify the conductivity of the sensor plate, producing changes in the output voltage. By monitoring these changes, the system determines whether rainfall is present.

Light Sensor

An LDR module is used to detect ambient light conditions.

Since the resistance of the photoresistor changes with illumination intensity, the controller can distinguish between daytime and nighttime conditions.

Sensor Processing

The ESP32-S3 performs several tasks:

Reading BME280 measurements.
Acquiring analog values from the rain sensor.
Measuring ambient light intensity.
Calculating altitude from pressure values.
Determining rain status.
Detecting day and night conditions.
Updating the graphical interface.

Continuous processing ensures that the dashboard always reflects current environmental conditions.

Visualizing Data with LVGL

Instead of showing plain numerical values, the project uses LVGL to create a more user-friendly interface.

The dashboard displays:

Temperature
Humidity
Pressure
Altitude
Rain status
Day/night indication

Icons and labels make the information easier to interpret and provide a more polished user experience.

Hardware Requirements

The project uses:

ESP32-S3 Smart Display
BME280 Sensor
Rain Sensor
LDR Module
Breadboard
Jumper Wires
USB Cable

Since the display module contains both the controller and the screen, the overall hardware remains compact.

Software Requirements

Development is performed using:

Visual Studio Code
ESP-IDF Extension
ESP-IDF v5.3.5
Python 3.11
Bosch BME280 Library
LVGL v8

These components provide support for sensor communication and graphical rendering.

Circuit Connections

The BME280 communicates with the ESP32-S3 over the I2C bus.

Connections:

VCC → 3.3 V
GND → GND
SDA → GPIO9
SCL → GPIO10

The rain sensor uses an analog output connected to GPIO7.

Connections:

VCC → 3.3 V
GND → GND
AO → GPIO7

The LDR module is connected to GPIO6.

Connections:

VCC → 3.3 V
GND → GND
AO → GPIO6

All sensors share the same 3.3 V supply and common ground.

Software Architecture

Although ESP-IDF contains many framework files, only a few modules are directly related to the application.

main.cpp

This file acts as the application entry point.

Responsibilities include:

Display initialization.
LVGL configuration.
Sensor initialization.
Dashboard creation.
Real-time screen updates.

sensors.c

This module serves as the sensor abstraction layer.

Functions include:

Reading BME280 measurements.
Pressure-based altitude estimation.
Rain sensor acquisition.
Light intensity measurements.
Environmental condition classification.

Separating sensor management from UI logic improves maintainability and simplifies future expansion.

Applications

The same architecture can be extended for:

Smart home systems
Greenhouse monitoring
IoT dashboards
Data logging
Industrial monitoring
Environmental sensing projects

Video

Final Thoughts

Combining an ESP32-S3 Smart Display with environmental sensors and LVGL makes it possible to build a compact and interactive weather station.

Beyond simply displaying sensor values, the project demonstrates how embedded hardware and graphical interfaces can work together to create practical IoT applications.

Complete Project Resources

Full project is available at Play with Circuit

How to Build a Weather Monitoring System Using ESP32-S3 Smart Display and LVGL

https://playwithcircuit.com/how-to-build-a-weather-monitoring-system-using-esp32-s3-smart-display-and-lvgl/

Controlling DC, Servo, and Stepper Motors Using L293D Motor Driver Shield with Arduino

Akshay Jain — Fri, 13 Feb 2026 15:47:33 +0000

Motor control is one of the most common requirements in robotics and automation projects. The L293D Motor Driver Shield makes this process simple by allowing an Arduino board to control multiple DC motors, stepper motors, and servo motors simultaneously — without complex wiring.

In this overview, we’ll understand how the shield works and how it can be used to control speed and direction efficiently.

What is L293D Motor Driver Shield?

The L293D Motor Driver Shield is an expansion board designed to simplify motor interfacing with an Arduino Uno. It uses two L293D H-bridge driver ICs and a 74HC595 shift register to efficiently control multiple motors using limited Arduino pins.

Each L293D IC can control:

Two DC motors
Or one stepper motor

Since the shield includes two L293D ICs, it can control:

Up to 4 DC motors
Or 2 stepper motors
Plus 2 servo motors

Each motor channel supports:

Motor voltage: 4.5V to 24V
Continuous current: 600mA per channel (1.2A peak)

Key Features

Drives up to 4 bidirectional DC motors
Supports 2 unipolar or bipolar stepper motors
Two dedicated servo headers
5V logic compatible
Pull-down resistor network for safe startup
Power selection jumper for flexible supply options
External motor power terminal (EXT_PWR)

L293D Motor Driver Shield Hardware Overview

Pin Usage on Arduino UNO

The shield occupies the following digital pins:

D3, D4, D5, D6, D7, D8, D9, D10, D11, D12

That leaves limited digital I/O, so analog pins (A0–A5) can be used as digital inputs when required.

Power Configuration Options

The shield allows two powering methods:
1️⃣ Single Supply Mode
If motors operate within 12V range, you can power both Arduino and shield from a single adapter via Arduino’s DC jack.
(Keep the PWR jumper connected.)

2️⃣ Separate Supply Mode
Remove the power jumper.
Power Arduino via USB and motors via external supply connected to EXT_PWR terminal.

⚠ Important: Never keep the jumper installed when using external motor supply — it may cause a short circuit.

Wiring of DC motor with L293D shield and Arduino UNO

Pin Connections
5V - Vcc pin of LCD and pin 1 of POT
Gnd - Gnd pin of LCD and pin 3 of POT
A0 - pin 2 of POT
A1 - Clockwise rotation Button
A2 - Anti-Clockwise rotation Button
A3 - Stop Button
SCL - SCL pin of LCD
SDA - SDA pin of LCD

/* 
Interfacing DC Motor with Arduino UNO using L293D motor Driver shield
by www.playwithcircuit.com 
*/
#include <AFMotor.h>
  // Library to run DC Motor Using Motor Driver Shield  
#include <LiquidCrystal_I2C.h> 
  // Library to Run I2C LCD
LiquidCrystal_I2C lcd(0x27, 16, 2);  // Format -> (Address,Columns,Rows )
// Create the motor object connected to M3
AF_DCMotor motor(3);
// Define button pins
const int forwardButtonPin = A1;
const int reverseButtonPin = A2;
const int stopButtonPin    = A3;
// Define potentiometer pin
const int potPin = A0;
// Variables to store motor state and direction
bool motorRunning  = false;
int motorDirection = BACKWARD;  // FORWARD or BACKWARD
// Read the potentiometer value
int potValue;
int motorSpeed;
// Variable to store button states
bool forwardButtonState;
bool stopButtonState;
bool reverseButtonState;
// Inline function to check if button is pressed packed with debouncing logic
inline bool chkButtonState(int pinNum, int checkState, int debounceDelay) {
  if (((digitalRead(pinNum) == checkState) ? true : false) == true) {
    delay(debounceDelay);
    return (((digitalRead(pinNum) == checkState) ? (true) : (false)) == true);
  } else {
    return false;
  }
}
void setup() {
  // initialize the lcd
  lcd.init();
  // Turn on the Backlight
  lcd.backlight();
  // Clear the display buffer
  lcd.clear();
  // Set cursor (Column, Row)
  lcd.setCursor(0, 0);
  lcd.print("DC Motor using");
  lcd.setCursor(0, 1);
  lcd.print("L293D Shield");
  // Set button pins as inputs
  pinMode(forwardButtonPin, INPUT_PULLUP);
  pinMode(stopButtonPin   , INPUT_PULLUP);
  pinMode(reverseButtonPin, INPUT_PULLUP);
  // Start with motor off
  motor.setSpeed(0);
  motor.run(RELEASE);
  delay(2000);
  // Clear the display buffer
  lcd.clear();
  // Set cursor (Column, Row)
  lcd.setCursor(0, 0);
  lcd.print("Motor Direction:");
  lcd.setCursor(0, 1);
  lcd.print("Stopped   ");
}
void loop() {
  // Read the potentiometer value for changing speed as per Analog input
  potValue   = analogRead(potPin);
  motorSpeed = map(potValue, 0, 1023, 0, 255);
  // Read the button states
  forwardButtonState = chkButtonState(forwardButtonPin, LOW, 20);
  reverseButtonState = chkButtonState(reverseButtonPin, LOW, 20);
  stopButtonState    = chkButtonState(stopButtonPin,    LOW, 20);
  // check for Forward run
  if (forwardButtonState && (!motorRunning || motorDirection == BACKWARD)) {
    // Set cursor (Column, Row)
    lcd.setCursor(0, 1);
    lcd.print("Clock   ");
    if (motorDirection == BACKWARD) {
      motor.setSpeed(0);
      motor.run(RELEASE);
      delay(1000);
    }
    motorRunning = true;
    motorDirection = FORWARD;
    motor.setSpeed(motorSpeed);
    motor.run(FORWARD);
  }

  // check for Reverse run
  else if (reverseButtonState && (!motorRunning || motorDirection == FORWARD)) {
    // Set cursor (Column, Row)
    lcd.setCursor(0, 1);
    lcd.print("Anti-Clk");
    if (motorDirection == FORWARD) {
      motor.setSpeed(0);
      motor.run(RELEASE);
      delay(1000);
    }
    motorRunning = true;
    motorDirection = BACKWARD;
    motor.setSpeed(motorSpeed);
    motor.run(BACKWARD);
  }

  // Stop motor
  else if (stopButtonState && motorRunning) {
    // Set cursor (Column, Row)
    lcd.setCursor(0, 1);
    lcd.print("Stopped         ");
    motorRunning = false;
    motor.setSpeed(0);
    motor.run(RELEASE);
  }

  // Adjust motor speed if running and display speed on LCD
  if (motorRunning) {
    motor.setSpeed(motorSpeed);
    // Set cursor (Column, Row)
    lcd.setCursor(9, 1);
    lcd.print("SPD:");
    lcd.print(((motorSpeed*100)/255));
    lcd.print("%  ");
  }
}

For complete details on how to control servo and stepper motor including wiring diagrams, code examples, and detailed explanations, you can read the full step-by-step tutorial at Play with Circuit:

👉 https://playwithcircuit.com/l293d-motor-driver-shield-arduino-tutorial/

Micro SD Card Module with Arduino

Akshay Jain — Tue, 16 Sep 2025 05:12:53 +0000

Ever wanted to log real-time sensor data with your Arduino?
Think of a weather station recording temperature and humidity every 10 seconds, or a smart irrigation system storing soil moisture levels throughout the day. Pretty soon, you’ll realize Arduino’s built-in memory just isn’t enough.

So what’s the solution?
👉 A Micro SD card module—the same tiny storage cards you use in cameras and phones. With this simple module, your Arduino projects get access to megabytes (even gigabytes!) of external storage. Perfect for projects that need data logging, tracking, or saving files.

In this guide, we’ll walk you through how to interface a Micro SD card module with Arduino step by step.

Micro SD Card Module Hardware Overview

A Micro SD card module is more than just a card slot. It includes:

Micro SD Card Socket – Where you insert the card. Most modules have clear markings to avoid wrong insertion.

3.3V LDO Voltage Regulator – Since SD cards work at 3.3V, the regulator safely steps down Arduino’s 5V to 3.3V. This prevents damage while keeping voltage stable.

Logic Level Shifter (74LVC125A) – Acts as a translator that converts Arduino’s 5V logic signals to 3.3V for the SD card, ensuring safe and reliable communication.

Micro SD Card Module Pinout

Here’s the pin configuration you’ll use while wiring it with Arduino:

GND → Connect to Arduino GND

VCC → Connect to 5V pin on Arduino

MISO (Master In Slave Out) → Sends data from SD card to Arduino

MOSI (Master Out Slave In) → Sends data from Arduino to SD card

SCK (Serial Clock) → Provides clock pulses from Arduino

CS (Chip Select / Slave Select) → Activates or deactivates the module on the SPI bus

Interfacing Micro SD Card Module with Arduino

Now that you understand the module and its pins, let’s put it into action. We’ll interface the Micro SD card module with Arduino UNO and use an I2C LCD to display information.

Hardware Requirements

Arduino UNO R3
LCD 16x2 (with I2C)
Micro SD Card Module
Micro SD Card
Jumper Wires
USB Cable Type A to B
12V Adapter

Wiring Connections

The Micro SD card module communicates with Arduino using the SPI protocol. This means it relies on dedicated SPI pins—MOSI, MISO, SCK, and CS—to exchange data. While SD cards can also work over SDIO (Secure Digital Input Output), this tutorial focuses only on the SPI-based interface.

Along with these communication pins, the module also needs power connections:

VCC (5V) – to power the module

GND – to complete the circuit

Wiring Between Arduino UNO and SD Card Reader

Connecting the I2C LCD with Arduino

Wiring the I2C LCD to Arduino is straightforward.

Connect VCC and GND of the LCD to the respective VCC and GND pins on the Arduino.

The two communication lines are:

SCL (Clock) → Connects to Arduino’s SCL pin (Analog pin A5)

SDA (Data) → Connects to Arduino’s SDA pin (Analog pin A4)

On the LCD’s back panel, these SCL and SDA pins are also marked and internally connected to A5 and A4 of the Arduino. In the provided wiring diagram, the pink wire is used for SCL and the blue wire for SDA.

⚠️ Important Note: Ensure that the A0, A1, and A2 address jumpers on the I2C LCD are not shorted. This is necessary because in the code we’ll be using the I2C address 0x27, which only works when these jumpers remain open.

Arduino Code for checking Micro SD card Information

/*
Code to get info about SD card and for testing if its working or not
by platwithcircuit.com
*/
#include <SPI.h>                
  // include SPI library header
#include <SD.h>                 
  // include the SD library header
#include <LiquidCrystal_I2C.h>  
  // include I2C LCD library header
// set up variables using the SD utility library functions
Sd2Card card;
SdVolume volume;
SdFile root;
// Set the LCD address to 0x27 for a 16 chars and 2 line display
LiquidCrystal_I2C lcd(0x27, 16, 2);
const int chipSelect = 10;
void setup() {
  // initialize the LCD
  lcd.init();
  // Turn ON the Backlight
  lcd.backlight();
  // Clear the display buffer
  lcd.clear();
  // Print a message to the LCD
  lcd.setCursor(0, 0);
  lcd.print("Initializing");
  lcd.setCursor(0, 1);
  lcd.print("SD Card...");
  // Open serial communications and wait for port to open
  Serial.begin(9600);
  while (!Serial) {
    ;  // wait for serial port to connect
  }
  Serial.print("\nInitializing SD card...");
  delay(1000);
  // we'll use the initialization code from the utility libraries
  // since we're just testing if the card is working!
  if (!card.init(SPI_HALF_SPEED, chipSelect)) {
    Serial.println("initialization failed. Things to check:");
    Serial.println("* is a card inserted?");
    Serial.println("* is your wiring correct?");
    Serial.println("* did you change the chipSelect pin to match your shield or module?");
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Initialization");
    lcd.setCursor(0, 1);
    lcd.print("Failed");
    while (1)
      ;
  } else {
    Serial.println("Wiring is correct and a card is present.");
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Initialization");
    lcd.setCursor(0, 1);
    lcd.print("Successfull");
    delay(2000);
  }
  // print the type of card
  Serial.println();
  Serial.print("Card type:         ");
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Card Type:");
  lcd.setCursor(0, 1);
  switch (card.type()) {
    case SD_CARD_TYPE_SD1:
      Serial.println("SD1");
      lcd.print("SD1");
      break;
    case SD_CARD_TYPE_SD2:
      Serial.println("SD2");
      lcd.print("SD2");
      break;
    case SD_CARD_TYPE_SDHC:
      Serial.println("SDHC");
      lcd.print("SDHC");
      break;
    default:
      Serial.println("Unknown");
      lcd.print("Unknown");
  }
  delay(2000);
  // Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32
  if (!volume.init(card)) {
    Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");
    while (1)
      ;
  }
  Serial.print("Clusters:          ");
  Serial.println(volume.clusterCount());

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Clusters:");
  lcd.setCursor(0, 1);
  lcd.print(volume.clusterCount()); 
  delay(2000);
  Serial.print("Blocks per Cluster:  ");
  Serial.println(volume.blocksPerCluster());
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Block per Clster");
  lcd.setCursor(0, 1);
  lcd.print(volume.blocksPerCluster()); 
  delay(2000);
  Serial.print("Total Blocks:      ");
  Serial.println(volume.blocksPerCluster() * volume.clusterCount());
  Serial.println();
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Total Blocks:");
  lcd.setCursor(0, 1);
  lcd.print(volume.blocksPerCluster() * volume.clusterCount()); 
  delay(2000);
  // print the type and size of the first FAT-type volume
  uint32_t volumesize;
  Serial.print("Volume type is:    FAT");
  Serial.println(volume.fatType(), DEC);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Volume type is:");
  lcd.setCursor(0, 1);
  lcd.print("FAT");
  lcd.print(volume.fatType(), DEC); 
  delay(2000);

  volumesize = volume.blocksPerCluster();  // clusters are collections of blocks
  volumesize *= volume.clusterCount();     // we'll have a lot of clusters
  volumesize /= 2;                         // SD card blocks are always 512 bytes (2 blocks are 1KB)
  Serial.print("Volume size (KB):  ");
  Serial.println(volumesize);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Volume size (KB):");
  lcd.setCursor(0, 1);
  lcd.print(volumesize); 
  delay(2000);
  Serial.print("Volume size (MB):  ");
  volumesize /= 1024;
  Serial.println(volumesize);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Volume size (MB):");
  lcd.setCursor(0, 1);
  lcd.print(volumesize); 
  delay(2000);
  Serial.print("Volume size (GB):  ");
  Serial.println((float)volumesize / 1024.0);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Volume size (GB):");
  lcd.setCursor(0, 1);
  lcd.print((float)volumesize / 1024.0); 
  delay(2000);
  Serial.println("\nFiles found on the card (name, date and size in bytes): ");
  root.openRoot(volume);
  // list all files in the card with date and size
  root.ls(LS_R | LS_DATE | LS_SIZE);
}
void loop(void) {
}

Checkout this article to learn how to: Read-Write Data on Micro SD Card

How to use Flame Sensor Module with Arduino

Akshay Jain — Fri, 13 Jun 2025 05:24:59 +0000

In this tutorial, you’ll learn how to interface a flame sensor module with an Arduino to build a simple fire detection system. This system will monitor the presence of flames and trigger an alert using an alarm—ideal for DIY home safety or educational projects.

How Does a Flame Sensor Module Work?

The flame sensor module operates by detecting infrared (IR) light—a type of thermal radiation emitted by flames and hot objects. At its core is a photodiode, which is sensitive to IR wavelengths. When a flame is present, the photodiode picks up the IR radiation.

An onboard LM393 comparator IC processes this signal and compares it to a threshold value, which you can adjust using the module’s potentiometer. If the incoming IR signal exceeds the threshold, the digital output (DO) pin changes its state, indicating the presence of a flame.

You can also use the analog output (AO) pin to measure how intense the IR radiation is. An onboard Signal LED lights up to visually indicate flame detection, and you can fine-tune the sensor’s response using the adjustable potentiometer.

Flame Sensor Module Specifications

Here’s a quick look at the key specifications of the module:

Operating Voltage: 3.3V to 5V (compatible with Arduino and other MCUs)
Detection Angle: ~60°, suitable for focused flame detection
Detection Range: 1–2 meters depending on the flame size
Sensitivity: Adjustable via onboard potentiometer
Form Factor: Small and compact for easy integration

Hardware Overview of Flame Sensor Module

Here’s what makes up the module:

Photodiode: Detects infrared light from flames.
LM393 Comparator IC: Converts the IR signal to a digital output based on a threshold.
Potentiometer: Adjusts the sensor’s sensitivity to suit your environment.
Power LED: Lights up when the module is powered.
Signal LED: Indicates flame detection (typically turns off when a flame is detected).

Flame Sensor Module Pinout

VCC: Power supply input (3.3V to 5V)
GND: Ground connection
DO(Digital Output): Outputs HIGH or LOW based on flame presence
AO(Analog Output): Outputs analog signal proportional to IR intensity

Wiring diagram when using Analog Output pin of Flame Sensor

/* 
Interfacing Flame Sensor with Arduino UNO using Analog input pin of Arduino and displaying fire detected on I2C LCD.
code by www.playwithcircuit.com
*/
#include <LiquidCrystal_I2C.h>  // Library to Run I2C LCD
// Buzzer pin
#define BUZZER_PIN 11
// Maximum counts to detect the flame
#define FLAME_DETECT_COUNTS 300
// define the size of filter array
#define FILTER_SIZE 30
// Set the LCD address to 0x27 for a 16 chars and 2 line display
LiquidCrystal_I2C lcd(0x27, 16, 2);
// Define the analog input pin, for the flame sensor's analog output
const int FlameSensorAnalogPin = A0;
// Variable to store the Analog count from flame sensor
int FlameCounts;
// Variable to store the Filtered Analog count from flame sensor
int filteredFlameCounts;
// Analog value filter
int Filter(int sensorValue);
void setup() {
  // initialize the LCD
  lcd.init();
  // Turn ON the Backlight
  lcd.backlight();
  // Clear the display buffer
  lcd.clear();
  // Make buzzer pin as output
  pinMode(BUZZER_PIN, OUTPUT);
  // Turn OFF buzzer pin
  digitalWrite(BUZZER_PIN, LOW);
  // Print a message to the LCD
  lcd.setCursor(0, 0);
  lcd.print("Initializing");
  // Print a message to the LCD
  lcd.setCursor(0, 1);
  lcd.print("Please Wait...");
  // flush out the first 100 values AND give time to flame sensor counts to be stable
  for (int i = 0; i < 100; i++) {
    // Read the value from the flame sensor
    FlameCounts = analogRead(FlameSensorAnalogPin);
    // Filter the input counts
    filteredFlameCounts = Filter(FlameCounts);
    delay(10);
  }
  // Clear the display buffer
  lcd.clear();
  // Print a message to the LCD
  lcd.setCursor(0, 0);
  lcd.print("Fire Detected:  ");
  // Print a message to the LCD
  lcd.setCursor(0, 1);
  lcd.print("                ");
}
void loop() {
  // Read the value from the flame sensor
  FlameCounts = analogRead(FlameSensorAnalogPin);
  // Filter the input counts
  filteredFlameCounts = Filter(FlameCounts);
  // if the counts are less than flame_detect_counts, the buzzer is activated
  // for this sensor when the flame is detected, the Analog counts decreases
  if (filteredFlameCounts < FLAME_DETECT_COUNTS) {
    lcd.setCursor(0, 1);
    lcd.print("YES");
    digitalWrite(BUZZER_PIN, !digitalRead(BUZZER_PIN));
    delay(100);
  } else {
    lcd.setCursor(0, 1);
    lcd.print("NO ");
    // Turn OFF buzzer pin
    digitalWrite(BUZZER_PIN, LOW);
    // Wait for 10ms before the next loop
    delay(10);
  }
}
// Averaging filter to filter Analog values
int Filter(int sensorValue) {
  static int analogArray[FILTER_SIZE] = { 0 };
  unsigned long int filteredValue = 0;
  int i;
  // Shift the element removing the oldest value stored at index 0
  for (i = 0; i < (FILTER_SIZE - 1); i++) {
    analogArray[i] = analogArray[i + 1];
  }
  // Put the current value in the last element of Array i.e. at index FILTER_SIZE-1
  analogArray[FILTER_SIZE - 1] = sensorValue;
  for (i = 0; i < FILTER_SIZE; i++) {
    filteredValue += analogArray[i];
  }
  // Return Filtered Analog value
  return (filteredValue / FILTER_SIZE);
}

To learn more checkout: Flame Sensor Module with Arduino

Output

playwithcircuit.com

LM35 Temperature Sensor with Arduino

Akshay Jain — Thu, 05 Jun 2025 16:07:43 +0000

The LM35 is a popular temperature sensor known for its accuracy, and low cost. It provides a linear voltage output directly proportional to temperature and doesn't require any external calibration or signal conditioning, making it ideal for Arduino projects.

In this tutorial, you'll learn how to interface the LM35 sensor with an Arduino UNO. We'll build a simple temperature monitoring system that measures the temperature and displays it in both Celsius and Fahrenheit. The temperature readings will be shown in real-time and shown on a 16×2 LCD display.

LM35 Temperature Sensor Overview

The LM35 is a precision analog temperature sensor that provides a voltage output linearly proportional to temperature in degrees Celsius (°C). One of the biggest advantages of the LM35 is its 10 mV/°C linear output, making it easy to interface with ADCs or microcontrollers like the Arduino.

LM35 Sensor Specifications

Operating Voltage: 4V to 30V
Temperature Range: -55°C to +150°C
Current Consumption: 60 μA (typical)
Output Type: Analog
Accuracy: ±0.5°C (typical)
Output Impedance: 0.1Ω for 1 mA load
Linearity: ±0.25°C
Sensitivity: 10 mV/°C

LM35 Temperature Sensor Pinout

VCC: Power supply pin of the LM35.
GND: Ground pin.
Out: Analog output pin of the sensor.

Interfacing LM35 Temperature Sensor with an Arduino

Component Required

Arduino UNO R3
LM35 Temperature Sensor
RGB LED (Common Cathode)
Resistor (220Ω)
Breadboard
Jumper Wires
USB Type A to B Cable
12V Adapter
PCF8574 I2C LCD Module

Wiring Connections

Arduino Code

/* 
Interfacing temperature Sensor with Arduino UNO using Analog input pin of Arduino and 
display temperature in Fahrenheit and in degree Celsius on I2C LCD. Here RGB LED turns Blue at LOW temperature, Red at HIGH temperature and Green when the temperature is between LOW and HIGH limit.
by www.playwithcircuit.com
*/
#include <LiquidCrystal_I2C.h>  // Library to Run I2C LCD
#define RED_PIN 10
#define BLUE_PIN 9
#define GREEN_PIN 8
#define LOW_TEMP    10
#define HIGH_TEMP   50
// Set the LCD address to 0x27 for a 16 chars and 2 line display
LiquidCrystal_I2C lcd(0x27, 16, 2);
// Define the analog pin for the temperature sensor
const int TemperatureSensorPin = A0;
// Variable to store the Analog count from temperature sensor
int temperatureCounts;
// Variable to store Voltage values
float voltageValue;
// Variable to store Temperature in Degree Celsius
float temperatureDegreeCelsius;
// Variable to store Temperature in Fahrenheit
float temperatureFahrenheit;
void setup() {
  // initialize the lcd
  lcd.init();
  // Turn on the Backlight
  lcd.backlight();
  // Clear the display buffer
  lcd.clear();
  // Make LED pins and Buzzer pin as output
  pinMode(RED_PIN, OUTPUT);
  pinMode(BLUE_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  // Turn off all the pins
  digitalWrite(RED_PIN, LOW);
  digitalWrite(BLUE_PIN, LOW);
  digitalWrite(GREEN_PIN, LOW);
  // Print a message to the LCD
  lcd.setCursor(0, 0);
  lcd.print("Initializing");
  // Print a message to the LCD
  lcd.setCursor(0, 1);
  lcd.print("Please Wait...");
  // flush out the first hundred values give time to temperature sensor to be stable
  for (int i = 0; i < 100; i++) {
    // Read the value from the temperature sensor
    temperatureCounts = analogRead(TemperatureSensorPin);
    delay(10);
  }
  // Clear the display buffer
  lcd.clear();
  // Print a message to the LCD
  lcd.setCursor(0, 0);
  lcd.print("Temp in C:");
  // Print a message to the LCD
  lcd.setCursor(0, 1);
  lcd.print("Temp in F:");
}
void loop() {
  // Static variables to save the last temperature
  static float lastTemp = 0xFF;
  // Read the value from the temperature sensor
  temperatureCounts = analogRead(TemperatureSensorPin);
  // convert the counts 0 to 1023 into voltage values 0 to 5V
  voltageValue = (5.0/1023) * temperatureCounts;
  // Convert voltage to temperature in Celsius
  temperatureDegreeCelsius = voltageValue * 100;
  // Convert Celsius to Fahrenheit
  temperatureFahrenheit = (temperatureDegreeCelsius * 9.0 / 5.0) + 32.0;
  // If current temperature is not equal to last temperature value in degree celsius
  if (lastTemp !
= temperatureDegreeCelsius) {
    // Print a temp to the LCD
    lcd.setCursor(10, 0);
    lcd.print("      ");
    lcd.setCursor(10, 0);
    lcd.print((int)temperatureDegreeCelsius);
    // Print a message to the LCD
    lcd.setCursor(10, 1);
    lcd.print("      ");
    lcd.setCursor(10, 1);
    lcd.print((int)temperatureFahrenheit);
  }
  // Save the current temperature value in the static variable to use it later
  lastTemp = temperatureDegreeCelsius;
  // Change the color of LED as per temperature level
  if (temperatureDegreeCelsius > HIGH_TEMP) {
    digitalWrite(RED_PIN, HIGH);
    digitalWrite(BLUE_PIN, LOW);
    digitalWrite(GREEN_PIN, LOW);
  } else if (temperatureDegreeCelsius >= LOW_TEMP && temperatureDegreeCelsius <= HIGH_TEMP) {
    digitalWrite(RED_PIN, LOW);
    digitalWrite(BLUE_PIN, LOW);
    digitalWrite(GREEN_PIN, HIGH);
  } else if (temperatureDegreeCelsius < LOW_TEMP) {
    digitalWrite(RED_PIN, LOW);
    digitalWrite(BLUE_PIN, HIGH);
    digitalWrite(GREEN_PIN, LOW);
  }
  // Wait for 1000 ms before the next loop
  delay(1000);
}

To learn more checkout: Interfacing LM35 Temperature Sensor with Arduino

74HC595 Shift Register with Arduino UNO

Akshay Jain — Mon, 12 May 2025 11:31:21 +0000

When working with Arduino, you may often need to control multiple devices like LEDs, sensors, or modules. However, as the number of connected peripherals grows, you can quickly run out of available GPIO pins. So, how can you expand your Arduino’s I/O capabilities? The solution is to use a shift register, which can effectively increase the number of input or output pins.

Shift registers come in two main types:

SIPO (Serial-In Parallel-Out) – used to expand outputs.

PISO (Parallel-In Serial-Out) – used to expand inputs.

One of the most commonly used SIPO shift register ICs is the 74HC595. It enables you to control 8 output devices using just 3 digital pins from the Arduino. Even better, you can daisy-chain multiple 74HC595 ICs to control a large number of devices using the same 3 pins.

Whether you're designing an LED matrix, a multiplexed display, or any project requiring efficient serial-to-parallel output control, the 74HC595 is an excellent choice. In this tutorial, we’ll take a closer look at how the 74HC595 works and how to interface it with an Arduino.

Let’s dive in!

What is a Shift Register and Why Use It?

The 74HC595 is an 8-bit Serial-In Parallel-Out (SIPO) shift register with a built-in D-type latch. It offers three output states: HIGH, LOW, and High-Impedance (Hi-Z). The high-impedance state allows multiple devices to share the same output lines without interference.

Let’s look at a practical example. Suppose you want to create light patterns on an 8×8 LED matrix. This matrix has 64 LEDs, and ideally, each LED requires a separate control line. Controlling all 64 LEDs directly would need 64 I/O pins, which isn’t feasible with most microcontrollers like the Arduino Uno (which only has 14 digital I/O pins).

By using two 74HC595 shift registers—one for controlling rows and one for columns—you can control all 64 LEDs using just 6 pins from your Arduino. This makes shift registers extremely valuable when working with projects that need many digital outputs.

It’s important to note that shift registers like the 74HC595 provide digital outputs only, meaning they can turn connected devices ON or OFF (logic HIGH or LOW). While they don't support analog output natively (like PWM for dimming LEDs), workarounds such as software-based PWM can be used to simulate brightness control.

Key Features of the 74HC595

8-bit parallel output
Serial-to-parallel data conversion
Cascade capability to expand outputs
Low power consumption
Operates with 2.0V to 6.0V supply voltage
Compatible with 5V logic systems

How Does the 74HC595 Shift Register Work?

The 74HC595 IC contains two main components:

Shift Register
Storage Register (Latch)

Here’s how it works:

Data is sent one bit at a time to the Data (DS) pin. On every rising edge of the Shift Register Clock (SRCLK), the bits shift from LSB to MSB inside the shift register. After all 8 bits are loaded, a pulse is sent to the Latch Clock (RCLK) pin. This transfers the data from the shift register to the storage register, which then drives the output pins (QA to QH). This process ensures that the outputs only update after all data bits have been shifted in, avoiding flicker or glitches.

74HC595 Pinout

The 74HC595 is a widely used 8-bit shift register IC. Below is a description of its pin configuration and functionality.

Output Pins (QA to QH)
These are the eight output pins of the storage register, labeled QA to QH (also referred to as Q0 to Q7). Each pin corresponds to one bit of the stored data. The pin numbers on the IC are as follows:
QA – Pin 15
QB – Pin 1
QC– Pin 2
QD – Pin 3
QE – Pin 4
QF – Pin 5
QG – Pin 6
QH – Pin 7

Serial Data Input (SER)
This pin is used to input data serially (bit by bit) into the shift register.

Shift Register Clock (SRCLK)
Each rising edge (LOW to HIGH transition) of the clock signal shifts the bits in the shift register one position to the left, making room for a new bit at the LSB. Timing on this pin is critical for accurate data loading.

Storage Register Clock / Latch (RCLK)
This pin latches the data from the shift register into the storage register. When it transitions from LOW to HIGH, the output pins (QA to QH) are updated to reflect the new data.

Cascade Output (QH′)
Also called the serial out, this pin outputs the last bit (bit 7 or QH) of the shift register. It is used to cascade multiple 74HC595 ICs. By connecting this pin to the SER pin of another shift register and sharing the same clock signals, you can expand the number of outputs to 16, 24, or more.

Output Enable (OE)
This is an active LOW pin. Pulling it LOW enables all output pins (QA to QH); pulling it HIGH puts the outputs in a high-impedance (Hi-Z) state, effectively disconnecting them. This is useful when multiple devices share output lines. Additionally, you can use a PWM signal on this pin to control LED brightness.

Shift Register Clear (SRCLR)
This is an active LOW pin used to clear the shift register (reset all bits to 0). Note that this action does not affect the storage register. Typically, this pin is connected to VCC for normal operation.

VCC
This is the power supply pin and should be connected to +5V.

GND
This is the ground pin and should be connected to the Arduino’s GND.

Wiring a 74HC595 Shift Register to an Arduino

In this project, we’ll control 8 red LEDs using a 74HC595 shift register. The LEDs will be connected to the output pins QA to QH of the IC.

Step-by-Step Instructions:

1. Place the 74HC595 on the Breadboard
Start by inserting the 74HC595 IC onto the breadboard so that the pins on each side are placed in separate rows (opposite halves of the breadboard).
To identify Pin 1, look for the small notch or dot on the IC — Pin 1 is to the left of the notch.

2. Power the Shift Register

Connect Pin 16 (VCC) to the 5V pin of the Arduino.
Connect Pin 8 (GND) to the GND of the Arduino.
Connect Pin 10 (SRCLR) to 5V to keep the shift register enabled.
Connect Pin 13 (OE) to Arduino pin 9 — this allows you to control output enable (active LOW). If you don’t plan to toggle outputs dynamically, you can also tie it to GND directly.

3. Connect the Control Pins
The 74HC595 uses three Arduino pins for control:

Pin 11 (SRCLK) → Connect to Arduino pin 12 (Shift register clock).
Pin 12 (RCLK) → Connect to Arduino pin 10 (Latch pin to transfer data to outputs).
Pin 14 (SER) → Connect to Arduino pin 11 (Serial data input).

4. Connect the LEDs

Connect the anodes (positive legs) of the 8 LEDs to the output pins QA to QH (Pins 15, 1, 2, 3, 4, 5, 6, 7 respectively).
Connect a 220Ω resistor in series with each LED to limit current and prevent damage.
Connect the cathodes (negative legs) of the LEDs to GND on the Arduino.

Arduino Code

/* 
Code to interface 74HC595 SIPO shift register using Arduino UNO
by www.playwithcircuit.com
*/
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
//Pin connected to DS of 74HC595
int dataPin = 11;
//Pin connected to ST_CP of 74HC595
int latchPin = 10;
//Pin connected to OE of 74HC595     
int brightnessPin = 9;
//Brightness control variable
int PWM_Value = 0;
void setup() {
  //set pins to output so you can control the shift register  and initially they should be HIGH
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(brightnessPin, OUTPUT);
  digitalWrite(latchPin, HIGH);
  digitalWrite(clockPin, HIGH);
  digitalWrite(dataPin, HIGH);
  analogWrite(brightnessPin, 255);
}
void loop() {
  int led_byte = 0x00;
  //  turn ON all LEDs one by one 
  for (int i = 0; i < 8; i++) {
    // adjust the brightness of LEDs
    PWM_Value = (255 - (115 + (20*i)));
    analogWrite(brightnessPin, PWM_Value);
    led_byte |= (0x01 << i);
    // take the latchPin low
    digitalWrite(latchPin, LOW);
    // shift out the bits:
    shiftOut(dataPin, clockPin, MSBFIRST, led_byte);
    //take the latch pin high so the LEDs will light up:
    digitalWrite(latchPin, HIGH);
    // pause before next value:
    delay(100);
  }
  //  turn OFF all LEDs one by one 
  for (int i = 0; i < 8; i++) {
    led_byte &= ~(0x01 << i);
    // make the latchPin low
    digitalWrite(latchPin, LOW);
    // shift out the bits:
    shiftOut(dataPin, clockPin, MSBFIRST, led_byte);
    //make the latch pin high so the LEDs will light up:
    digitalWrite(latchPin, HIGH);
    // pause before next value
    delay(100);
  }
}

To learn more checkout: 74HC595 Shift Register Interfacing with Arduino UNO

How to Build a Line Follower Robot with Arduino

Akshay Jain — Wed, 27 Nov 2024 05:01:52 +0000

Robotics is one of the most exciting fields in electronics, and building a Line Follower Robot is an excellent way to dive into this world. In this tutorial, we will guide you step by step to create a line follower robot using Arduino.

A line follower robot is an autonomous robot designed to detect and follow a line, typically a black line on a white surface.

How Does It Work?

To enable the line-following functionality in a robot, we need a mechanism to detect the line it will follow. This mechanism leverages a fundamental principle: black surfaces absorb most light, while white surfaces reflect nearly all the light.
Many sensors, such as Light-Dependent Resistors (LDRs), IR sensors, or specialized line sensors, use this property to distinguish between black and white surfaces. In this project, we utilize line sensors for their high precision and reliable line detection capabilities.

A typical line sensor comprises two key components: an IR emitter (LED) and an IR receiver (photodiode). The emitter continuously emits infrared light, while the receiver detects the light reflected from the surface.

Here’s how it works:
When the emitted IR light strikes a white surface, it reflects back and is captured by the photodiode.
Conversely, when the light encounters a black line, it is absorbed rather than reflected, leaving the receiver with little or no signal.

Components Required

To build this project, you will need:

Arduino UNO (or any compatible microcontroller board)
IR Sensor Module (two sensors for detecting the line)
L298N Motor Driver Module
DC Motors (2 units for the robot wheels)
Robot Chassis
Wheels and Castor Wheel
Battery (9V or 12V)
Connecting Wires

Assembling the robot

Watch the following video to learn how to assemble the robot.

Arduino Code

/* 
Library used: Adafruit Motor Shield library V1 version: 1.0.1
For this code to run as expected: 
1.The centre to centre distance between the Line sensors should be 11 to 11.5 cm
2. The width of black tape should be 4.8 to 5 cm
3. The distance of the sensor LED from the flat ground surface should be 2 cm.
*/
#include <AFMotor.h>
// MACROS for Debug print, while calibrating set its value to 1 else keep it 0
#define DEBUG_PRINT 0
// MACROS for Analog Input
#define LEFT_IR A0
#define RIGHT_IR A1
// MACROS to control the Robot
#define DETECT_LIMIT 300
#define FORWARD_SPEED 60
#define TURN_SHARP_SPEED 150
#define TURN_SLIGHT_SPEED 120
#define DELAY_AFTER_TURN 140
#define BEFORE_TURN_DELAY 10
// BO Motor control related data here
// Here motors are running using M3 and M4 of the shield and Left Motor is connected to M3 and Right Motor is connected to M4 using IC2 of the shield
AF_DCMotor motorL(3);  // Uses PWM0B pin of Arduino Pin 5 for Enable
AF_DCMotor motorR(4);  // Uses PWM0A pin of Arduino Pin 6 for Enable
// variables to store the analog values
int left_value;
int right_value;
// Set the last direction to Stop
char lastDirection = 'S';  
void setup() {
#if DEBUG_PRINT  
  Serial.begin(9600);
#endif  
  // Set the current speed of Left Motor to 0
  motorL.setSpeed(0);
  // turn on motor
  motorL.run(RELEASE);
  // Set the current speed of Right Motor to 0
  motorR.setSpeed(0);
  // turn off motor
  motorR.run(RELEASE);
  // To provide starting push to Robot these values are set
  motorR.run(FORWARD);
  motorL.run(FORWARD);
  motorL.setSpeed(255);
  motorR.setSpeed(255);
  delay(40);  // delay of 40 ms
}
void loop() {
  left_value = analogRead(LEFT_IR);
  right_value = analogRead(RIGHT_IR);
#if DEBUG_PRINT
  // This is for debugging. To check the analog inputs the DETECT_LIMIT MACRO value 300 is set by analysing the debug prints
  Serial.print(left_value);
  Serial.print(",");
  Serial.print(right_value);
  Serial.print(",");
  Serial.print(lastDirection);
  Serial.write(10);
#endif
  // Right Sensor detects black line and left does not detect
  if (right_value >= DETECT_LIMIT && !(left_value >= DETECT_LIMIT)) {
    turnRight();
  }
  // Left Sensor detects black line and right does not detect
  else if ((left_value >= DETECT_LIMIT) && !(right_value >= DETECT_LIMIT)) {
    turnLeft();
  }
  // both sensors doesn't detect black line
  else if (!(left_value >= DETECT_LIMIT) && !(right_value >= DETECT_LIMIT)) {
    moveForward();
  }
  // both sensors detect black line
  else if ((left_value >= DETECT_LIMIT) && (right_value >= DETECT_LIMIT)) {
    stop();
  }
}
void moveForward() {
  if (lastDirection != 'F') {
    // To provide starting push to Robot when last direction was not forward
    motorR.run(FORWARD);
    motorL.run(FORWARD);
    motorL.setSpeed(255);
    motorR.setSpeed(255);
    lastDirection = 'F';
    delay(20);
  } else {
    // If the last direction was forward
    motorR.run(FORWARD);
    motorL.run(FORWARD);
    motorL.setSpeed(FORWARD_SPEED);
    motorR.setSpeed(FORWARD_SPEED);
  }
}
void stop() {
  if (lastDirection != 'S') {
    // When stop is detected move further one time to check if its actual stop or not, needed when the robot turns
    motorR.run(FORWARD);
    motorL.run(FORWARD);
    motorL.setSpeed(255);
    motorR.setSpeed(255);
    lastDirection = 'S';
    delay(40);
  } else {
    // When stop is detected next time then stop the Robot
    motorL.setSpeed(0);
    motorR.setSpeed(0);
    motorL.run(RELEASE);
    motorR.run(RELEASE);
    lastDirection = 'S';
  }
}
void turnRight(void) {
  // If first time Right Turn is taken
  if (lastDirection != 'R') {
    lastDirection = 'R';
    // Stop the motor for some time
    motorL.setSpeed(0);
    motorR.setSpeed(0);
    delay(BEFORE_TURN_DELAY);
    // take Slight Right turn
    motorL.run(FORWARD);
    motorR.run(BACKWARD);
    motorL.setSpeed(TURN_SLIGHT_SPEED);
    motorR.setSpeed(TURN_SLIGHT_SPEED);
  } else {
    // take sharp Right turn
    motorL.run(FORWARD);
    motorR.run(BACKWARD);
    motorL.setSpeed(TURN_SHARP_SPEED);
    motorR.setSpeed(TURN_SHARP_SPEED);
  }
  delay(DELAY_AFTER_TURN);
}
void turnLeft() {
  // If first time Left Turn is taken
  if (lastDirection != 'L') {
    lastDirection = 'L';
    // Stop the motor for some time
    motorL.setSpeed(0);
    motorR.setSpeed(0);
    delay(BEFORE_TURN_DELAY);
    // take slight Left turn
    motorR.run(FORWARD);
    motorL.run(BACKWARD);
    motorL.setSpeed(TURN_SLIGHT_SPEED);
    motorR.setSpeed(TURN_SLIGHT_SPEED);
  } else {
    // take sharp Left turn
    motorR.run(FORWARD);
    motorL.run(BACKWARD);
    motorL.setSpeed(TURN_SHARP_SPEED);
    motorR.setSpeed(TURN_SHARP_SPEED);
  }
  delay(DELAY_AFTER_TURN);
}

To learn how to calibrate and troubleshoot line follower Robot checkout this detailed article: Line Follower Robot using Arduino

Master-Slave Communication Between Two Arduino Boards

Akshay Jain — Wed, 31 Jul 2024 09:15:21 +0000

In this project, we'll explore how to set up master-slave communication between two Arduino boards using UART communication.

Understanding Master-Slave Communication

In a master-slave communication setup between two Arduino boards, one board acts as the master, while the other functions as the slave.
The master board sends commands to the slave board to perform specific tasks, and the slave board carries out these operations and sends a response back to the master.

These tasks can include actions like turning on an LED, reading sensor values, or controlling the speed of a motor. While the master sends the commands, the slave processes them and executes the required tasks.
The communication between the master and slave is established using Serial UART Communication, which utilises three pins: Rx (Receive), Tx (Transmit), and GND (Ground).

In this project, the Master Arduino sends commands to the Slave Arduino through the Serial Tx Pin and receives responses from the Slave Arduino via the Serial Rx Pin.

The master will send the following commands:

Request the temperature reading from the Slave board.
Request the humidity reading from the Slave board.
Request the analog value read from the A0 input on the Slave board.
Turn the LED ON/OFF based on the analog input value.

Once the master receives all the responses, it will display the data on an LCD.

On the other side, the slave board listens for commands from the master and provides the appropriate response based on the command received.

Components Required

2 Arduino UNO R3
16 x 2 LCD
2, 10 kΩ Potentiometer
220 Ω Resistance
2 Breadboards
Red LED
100 Ω Resistance
Temperature Sensor
L293D
104 pf Ceramic Capacitor
multiple Connecting Wires
5V DC Motor
DC Fan
USB A/B cable

Circuit Diagram

Master Code

#include "master.h"
#define MOTOR_PIN 3
void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  // set the cursor to (column = 0,row = 0)
  lcd.setCursor(0, 0);
  lcd.print("Master Slave");
  lcd.setCursor(0, 1);
  // set the cursor to (column = 0,row = 1)
  lcd.print("Demo");
  // provide delay of 2 second
  delay(300);
  //Initialize serial and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ;  // wait for serial port to connect. Needed for native USB
  }
  pinMode(MOTOR_PIN, OUTPUT);  // declare Motor pin to be an output
}
void loop() {
  getTempearture();
  getHumidity();
  getSpeed();
  setMotorSpeed();
  lcdUpdate();
}
void setMotorSpeed() {
  if (paramerters.Status[SPD_STA_INDX] == STATUS_OK) {
    analogWrite(MOTOR_PIN, map(paramerters.Speed,0,100,0,255));  // set the Speed of Motor
  }
}
// For temperture
// CMD : START_CHAR TEMP_CMD END_CHAR
// RESP: START_CHAR TEMP_RSP STATUS BYTE1 BYTE2 BYTE3 BYTE4 END_CHAR
void getTempearture() {
  float temp;
  float *ptemp = &temp;
  unsigned char cmdBuffer[3] = { START_CHAR, TEMP_CMD, END_CHAR };
  unsigned char rspBuffer[10] = { 0 };
  unsigned char rspIndex = 0;
  Serial.write(cmdBuffer, 3);
  while (Serial.available() == 0)
    ;
  do {
    rspBuffer[rspIndex++] = Serial.read();
    // this delay is provided because it takes approx 10 ms to receiev a new character at 9600 baurdrate
    delay(10);
  } while (Serial.available() != 0);
  if ((rspBuffer[0] == START_CHAR) && (rspBuffer[1] == TEMP_RSP) && (rspBuffer[7] == END_CHAR)) {
    if (rspBuffer[2] == STATUS_OK) {
      ptemp = (float *)(rspBuffer + 3);
      paramerters.Temperature = *ptemp;
    }
    paramerters.Status[TEM_STA_INDX] = rspBuffer[2];
  }
}
// For humidity
// CMD : START_CHAR HUMIDITY_CMD END_CHAR
// RESP: START_CHAR HUMIDITY_RSP STATUS BYTE1 BYTE2 BYTE3 BYTE4 END_CHAR
void getHumidity() {
  float hum;
  float *phum = &hum;
  unsigned char cmdBuffer[3] = { START_CHAR, HUMIDITY_CMD, END_CHAR };
  unsigned char rspBuffer[10] = { 0 };
  unsigned char rspIndex = 0;
  Serial.write(cmdBuffer, 3);
  while (Serial.available() == 0)
    ;
  do {
    rspBuffer[rspIndex++] = Serial.read();
    // this delay is provided because it takes approx 10 ms to receiev a new character at 9600 baurdrate
    delay(10);
  } while (Serial.available() != 0);
  if ((rspBuffer[0] == START_CHAR) && (rspBuffer[1] == HUMIDITY_RSP) && (rspBuffer[7] == END_CHAR)) {
    if (rspBuffer[2] == STATUS_OK) {
      phum = (float *)(rspBuffer + 3);
      paramerters.Humidity = *phum;
    }
    paramerters.Status[HUM_STA_INDX] = rspBuffer[2];
  }
}
// For speed
// CMD : START_CHAR SPEED_CMD END_CHAR
// RESP: START_CHAR SPEED_RSP STATUS BYTE1 END_CHAR
void getSpeed() {
  int spd;
  int *pspd = &spd;
  unsigned char cmdBuffer[3] = { START_CHAR, SPEED_CMD, END_CHAR };
  unsigned char rspBuffer[10] = { 0 };
  unsigned char rspIndex = 0;
  Serial.write(cmdBuffer, 3);
  while (Serial.available() == 0)
    ;
  do {
    rspBuffer[rspIndex++] = Serial.read();
    // this delay is provided because it takes approx 10 ms to receiev a new character at 9600 baurdrate
    delay(10);
  } while (Serial.available() != 0);
  if ((rspBuffer[0] == START_CHAR) && (rspBuffer[1] == SPEED_RSP) && (rspBuffer[5] == END_CHAR)) {
    if (rspBuffer[2] == STATUS_OK) {
      pspd = (int *)(rspBuffer + 3);
      paramerters.Speed = *pspd;
    }
    paramerters.Status[SPD_STA_INDX] = rspBuffer[2];
  }
  if (paramerters.Status[SPD_STA_INDX] == STATUS_OK) {
    if (paramerters.Speed >= 50) {
      //it indicates high speed
      setLEDON();
    } else {
      //it indicates low speed
      setLEDOff();
    }
  }
}
// For led ON
// CMD : START_CHAR LED_ON_CMD END_CHAR
// RESP: START_CHAR LED_ON_RSP STATUS END_CHAR
void setLEDON() {
  unsigned char cmdBuffer[3] = { START_CHAR, LED_ON_CMD, END_CHAR };
  unsigned char rspBuffer[10] = { 0 };
  unsigned char rspIndex = 0;
  Serial.write(cmdBuffer, 3);
  while (Serial.available() == 0);
  do {
    rspBuffer[rspIndex++] = Serial.read();
    // this delay is provided because it takes approx 10 ms to receiev a new character at 9600 baurdrate
    delay(10);
  } while (Serial.available() != 0);
  if ((rspBuffer[0] == START_CHAR) && (rspBuffer[1] == LED_ON_RSP) && (rspBuffer[3] == END_CHAR)) {
    if (rspBuffer[2] == STATUS_OK) {
      paramerters.Led_state = 1;
    }
    paramerters.Status[LED_STA_INDX] = rspBuffer[2];
  }
}
// For led OFF
// CMD : START_CHAR LED_OFF_CMD END_CHAR
// RESP: START_CHAR LED_OFF_RSP STATUS END_CHAR
void setLEDOff() {
  unsigned char cmdBuffer[3] = { START_CHAR, LED_OFF_CMD, END_CHAR };
  unsigned char rspBuffer[10] = { 0 };
  unsigned char rspIndex = 0;
  Serial.write(cmdBuffer, 3);
  while (Serial.available() == 0)
    ;
  do {
    rspBuffer[rspIndex++] = Serial.read();
    // this delay is provided because it takes approx 10 ms to receiev a new character at 9600 baurdrate
    delay(10);
  } while (Serial.available() != 0);
  if ((rspBuffer[0] == START_CHAR) && (rspBuffer[1] == LED_OFF_RSP) && (rspBuffer[3] == END_CHAR)) {
    if (rspBuffer[2] == STATUS_OK) {
      paramerters.Led_state = 0;
    }
    paramerters.Status[LED_STA_INDX] = rspBuffer[2];
  }
}
void lcdUpdate() {
  lcd.clear();
  // DisplaY Temperature
  // set the cursor to (column = 0,row = 0)
  lcd.setCursor(0, 0);
  lcd.print("Tem=");
  if (paramerters.Status[TEM_STA_INDX] == STATUS_OK) {
    lcd.print(paramerters.Temperature);
  } else {
    lcd.print("NOK");
  }
  // DisplaY LED Status
  lcd.print(" LED=");
  if (paramerters.Status[LED_STA_INDX] == STATUS_OK) {
    lcd.write(paramerters.Led_state | 0x30);
  } else {
    lcd.print("NOK");
  }
  // Display Humidity
  // set the cursor to (column = 0,row = 1)
  lcd.setCursor(0, 1);
  lcd.print("Hum=");
  if (paramerters.Status[HUM_STA_INDX] == STATUS_OK) {
    lcd.print(paramerters.Humidity);
  } else {
    lcd.print("NOK");
  }
  // Display Speed
  lcd.print(" SP=");
  if (paramerters.Status[HUM_STA_INDX] == STATUS_OK) {
    lcd.print(paramerters.Speed);
    lcd.print('%');
  } else {
    lcd.print("NOK");
  }
}

Slave Code

#include "slave.h"
#define ALARM_LED 8
#define LED_ON 0
#define LED_OFF 1
char serialInput;
int dataIndex = 0;
char databuffer[10] = { 0 };
bool dataRcvd = false;  // whether the string receiving is completed.
unsigned char rspBuffer[10];
void setup() {
  Serial.begin(9600);          // initialize serial port
  dht.begin();                 // Initialize the DHT sensor
  pinMode(ALARM_LED, OUTPUT);  // Initialize alarm LED
  digitalWrite(ALARM_LED, LED_OFF);
}
void loop() {
  getTemphumidity();
  getSpeed();
  if (dataRcvd == true) {
    // Check for start and end character
    if ((databuffer[0] = START_CHAR) && (databuffer[2] = END_CHAR)) {
      // Check if its the temperature command
      // For temperture
      // CMD : START_CHAR TEMP_CMD END_CHAR
      // RESP: START_CHAR TEMP_RSP STATUS BYTE1 BYTE2 BYTE3 BYTE4 END_CHAR
      if (databuffer[1] == TEMP_CMD) {
        rspBuffer[0] = START_CHAR;
        rspBuffer[1] = TEMP_RSP;
        if (paramerters.Status[TEM_STA_INDX] == STATUS_OK) {
          rspBuffer[2] = STATUS_OK;
          memcpy((rspBuffer + 3), &(paramerters.Temperature), 4);
        } else {
          rspBuffer[2] = STATUS_NOT_OK;
          memset((rspBuffer + 3), 0x00, 4);
        }
        rspBuffer[7] = END_CHAR;
        Serial.write(rspBuffer, 8);
      }
      // Check if it is Humidity command
      // For humidity
      // CMD : START_CHAR HUMIDITY_CMD END_CHAR
      // RESP: START_CHAR HUMIDITY_RSP STATUS BYTE1 BYTE2 BYTE3 BYTE4 END_CHAR
      else if (databuffer[1] == HUMIDITY_CMD) {
        rspBuffer[0] = START_CHAR;
        rspBuffer[1] = HUMIDITY_RSP;
        if (paramerters.Status[HUM_STA_INDX] == STATUS_OK) {
          rspBuffer[2] = STATUS_OK;
          memcpy((rspBuffer + 3), &(paramerters.Humidity), 4);
        } else {
          rspBuffer[2] = STATUS_NOT_OK;
          memset((rspBuffer + 3), 0x00, 4);
        }
        rspBuffer[7] = END_CHAR;
        Serial.write(rspBuffer, 8);
      }
      // Check if it is Speed command
      // For speed
      // CMD : START_CHAR SPEED_CMD END_CHAR
      // RESP: START_CHAR SPEED_RSP STATUS BYTE1 END_CHAR
      else if (databuffer[1] == SPEED_CMD) {
        rspBuffer[0] = START_CHAR;
        rspBuffer[1] = SPEED_RSP;
        if (paramerters.Status[SPD_STA_INDX] == STATUS_OK) {
          rspBuffer[2] = STATUS_OK;
          memcpy((rspBuffer + 3), &(paramerters.Speed), 2);
        } else {
          rspBuffer[2] = STATUS_NOT_OK;
          memset((rspBuffer + 3), 0x00, 2);
        }
        rspBuffer[5] = END_CHAR;
        Serial.write(rspBuffer, 6);
      }
      // For led ON
      // CMD : START_CHAR LED_ON_CMD END_CHAR
      // RESP: START_CHAR LED_ON_RSP STATUS END_CHAR
      else if (databuffer[1] == LED_ON_CMD) {
        rspBuffer[0] = START_CHAR;
        rspBuffer[1] = LED_ON_RSP;
        digitalWrite(ALARM_LED, LED_ON);
        rspBuffer[2] = STATUS_OK;
        rspBuffer[3] = END_CHAR;
        Serial.write(rspBuffer, 4);
      }
      // For led OFF
      // CMD : START_CHAR LED_OFF_CMD END_CHAR
      // RESP: START_CHAR LED_OFF_RSP STATUS END_CHAR
      else if (databuffer[1] == LED_OFF_CMD) {
        rspBuffer[0] = START_CHAR;
        rspBuffer[1] = LED_OFF_RSP;
        digitalWrite(ALARM_LED, LED_OFF);
        rspBuffer[2] = STATUS_OK;
        rspBuffer[3] = END_CHAR;
        Serial.write(rspBuffer, 4);
      }
    }
    dataRcvd = false;
    memset(databuffer, 0x00, sizeof(databuffer));
  }
}
void getTemphumidity() {
  static unsigned long int previousTick = 0;
  static unsigned long int currentTick;
  float temperature;
  float humidity;
  currentTick = millis();
  if ((currentTick - previousTick) >= 100) {
    previousTick = currentTick;
    // Read temperature and humidity from the DHT sensor
    temperature = dht.readTemperature(false);
    humidity = dht.readHumidity();
    // Check if the sensor reading is valid (non-NaN)
    if (!isnan(temperature)) {
      paramerters.Temperature = temperature;
      paramerters.Status[TEM_STA_INDX] = STATUS_OK;
      // Serial.print("Temperature: ");
      // Serial.print(temperature);
    } else {
      paramerters.Status[TEM_STA_INDX] = STATUS_NOT_OK;
    }
    if (!isnan(humidity)) {
      paramerters.Humidity = humidity;
      paramerters.Status[HUM_STA_INDX] = STATUS_OK;
      // Serial.print(" °F, Humidity: ");
      // Serial.print(humidity);
      // Serial.println("%");
    } else {
      paramerters.Status[HUM_STA_INDX] = STATUS_NOT_OK;
    }
  }
}
void getSpeed() {
  int analogPin = A0;  // potentiometer wiper (middle terminal) is connected to analog pin 0
  int analogVal = 0;   // variable to store the value read
  analogVal = analogRead(analogPin);  // read the Analog input pin
  paramerters.Speed = map(analogVal, 0, 1023, 0, 100);
  paramerters.Status[SPD_STA_INDX] = STATUS_OK;
}
/*
  SerialEvent occurs whenever a new data comes in the hardware serial RX. This
  routine is run between each time loop() runs, so using delay inside loop can
  delay response. Multiple bytes of data may be available.
*/
void serialEvent() {
  while (Serial.available()) {
    // get the new byte:
    serialInput = Serial.read();
    databuffer[dataIndex++] = serialInput;
    // if the incoming character is a line feed character '\n', set a flag so the main loop can do something about it
    if (serialInput == END_CHAR) {
      dataRcvd = true;
      dataIndex = 0;
    }
  }
}

This project demonstrates how to implement master-slave communication between two Arduino boards using Serial UART Communication. By utilizing simple commands, the master board can control the slave board to perform various tasks and display the results on an LCD. For a detailed step-by-step guide, visit our blog post on Master-Slave Communication Between Two Arduino Boards.

Video

Controlling a 28BYJ-48 Stepper Motor with Arduino: A Step-by-Step Guide

Akshay Jain — Wed, 10 Jul 2024 11:08:54 +0000

In this guide, we will walk you through controlling a 28BYJ-48 stepper motor using an Arduino and a ULN2003 driver. This tutorial aims to provide a hands-on experience for enthusiasts and beginners in the field of electronics and robotics. For a detailed explanation and additional resources, visit my blog post at Stepper Motor Control with Arduino.

Materials Needed

Arduino UNO
28BYJ-48 Stepper Motor
ULN2003 Driver Module
Jumper Wires
Breadboard (optional)
Power Supply (optional)

Understanding the Components

28BYJ-48 Stepper Motor: This stepper motor is known for its low cost and reliability. It has a 5-wire interface that connects to the ULN2003 driver.
ULN2003 Driver Module: The ULN2003 is a Darlington transistor array used to drive the stepper motor. It provides the necessary current and voltage to the motor from the Arduino signals.

Circuit Connections

Connecting the Motor to the Driver

Connect the 5-wire connector of the 28BYJ-48 stepper motor to the ULN2003 driver module.

Connecting the Driver to the Arduino

Connect the IN1 pin on the ULN2003 to the digital pin 7 on the Arduino.
Connect the IN2 pin on the ULN2003 to the digital pin 6 on the Arduino.
Connect the IN3 pin on the ULN2003 to the digital pin 5 on the Arduino.
Connect the IN4 pin on the ULN2003 to the digital pin 4 on the Arduino.
Connect the GND pin on the ULN2003 to a GND pin on the Arduino.
Connect the VCC pin on the ULN2003 to the 5V pin on the Arduino.

Arduino Code

Upload the following code to your Arduino

#include <Stepper.h>
//define Input pins of the Motor
#define OUTPUT1   7                // Connected to the Blue coloured wire
#define OUTPUT2   6                // Connected to the Pink coloured wire
#define OUTPUT3   5                // Connected to the Yellow coloured wire
#define OUTPUT4   4                // Connected to the Orange coloured wire
// Define the number of steps per rotation
const int stepsPerRotation = 2048;  // 28BYJ-48 has 2048 steps per rotation in full step mode as given in data sheet
// Initialize the stepper motor with the sequence of control pins OUTPUT1, OUTPUT3, OUTPUT2, IN4
// OUTPUT1 and OUTPUT3 are connected to one coil and OUTPUT2 and OUTPUT4 are connected to one Coil
Stepper myStepper(stepsPerRotation, OUTPUT1, OUTPUT3, OUTPUT2, OUTPUT4);  
void setup() {
  // Set the speed of the motor in RPM (adjust as needed)
  myStepper.setSpeed(15);  // 15 RPM
}
void loop() {
  // Rotate in One Direction and complete one complete rotation i.e 2048 steps
  myStepper.step(stepsPerRotation);  
  delay(1000);  // Delay between rotations
  // For Rotation in opposite direction provide the variable to the parameter with negative Sign
  myStepper.step(-stepsPerRotation);  
  delay(1000);  // Delay between rotations
}