DEV Community: Play with Circuit

Arduino Servo Motor Control

Play with Circuit — Wed, 15 Apr 2026 09:38:35 +0000

When working on robotics or automation projects, one of the most commonly used components is the servo motor. Unlike regular DC motors, servo motors are designed for precise position control, making them ideal for applications like robotic arms, camera positioning systems, and mechanical linkages.

In this project, we will first understand how to interface a servo motor with the Arduino Uno and control its movement. Along with that, we will also build a simple servo tester, which is extremely useful for checking whether a servo is functioning correctly before using it in a larger system.

Components Required

Arduino Uno
SG90 Micro Servo Motor
Breadboard
Jumper wires
10kΩ Potentiometer
16x2 LCD (optional but useful)
220Ω resistor
USB cable or 5V supply

Understanding the Servo Motor

A servo motor is a compact device that combines a DC motor, a gear mechanism, and a feedback system. This feedback system continuously monitors the position of the output shaft and adjusts it to match the desired angle. Because of this closed-loop control, servo motors can move to a specific position and hold it steadily.

Most hobby servo motors, such as the popular SG90, can rotate approximately from 0° to 180°. They are controlled using a PWM (Pulse Width Modulation) signal. Instead of changing voltage, the control is achieved by varying the width of the pulse sent to the signal pin. The internal electronics interpret this pulse width and rotate the shaft accordingly.

Working Principle of Servo Control

The core concept behind controlling a servo motor is PWM. The Arduino generates a series of pulses, and the duration of each pulse determines the position of the servo shaft. For example, a shorter pulse corresponds to one extreme position (around 0 degrees), a medium pulse places the servo at the center (around 90 degrees), and a longer pulse moves it to the other extreme (around 180 degrees).

The servo’s internal control circuit continuously compares the received signal with its current position using feedback from the internal potentiometer. If there is a difference, it drives the motor until the desired position is reached. This is why servo motors are highly accurate and stable.

Circuit Diagram

The circuit for interfacing a servo motor with Arduino is quite simple. The power wire of the servo is connected to the 5V pin of the Arduino, while the ground wire is connected to the GND pin. The control wire is connected to one of the PWM-enabled digital pins, commonly pin 10.

Once the connections are made, the Arduino sends PWM signals through the control pin, and the servo rotates according to the signal timing. This setup is sufficient for basic control and experimentation.

However, if you are using multiple servos or require more stable performance, it is often recommended to use an external power supply instead of relying solely on the Arduino’s 5V output.

Building a Servo Tester Using Arduino

A servo tester is a simple yet powerful tool that allows you to manually control and verify the performance of a servo motor. Instead of writing different code snippets repeatedly, a tester provides an intuitive way to check whether the servo responds correctly.

In this setup, a 10k potentiometer is used as an input device. The middle pin of the potentiometer is connected to the analog pin A0 of the Arduino. As you rotate the knob, the analog value changes, and the Arduino maps this value to a corresponding servo angle.

The servo motor is connected in the same way as before, with its signal pin connected to pin 10. When the potentiometer is turned, the servo rotates smoothly, following the input. This gives you direct control over the servo position.

If you add a 16x2 LCD display, the system becomes even more informative. The Arduino can display the current angle of the servo in real time. This allows you to verify whether the physical movement of the servo matches the expected angle. If the movement is inconsistent or unresponsive, it may indicate a faulty servo.

This type of tester is particularly useful when working on larger projects where multiple servos are involved, as it helps ensure reliability before integration.

Conclusion

This project introduces you to both controlling and testing servo motors, which are essential skills in embedded systems and robotics. Understanding how PWM signals translate into physical motion gives you a strong foundation for more advanced designs.

By building a simple servo tester, you also learn how to validate components efficiently—something that becomes increasingly important as your projects grow in complexity.

As you move forward, you can expand this concept into multi-servo systems, robotic mechanisms, or even custom-designed hardware using professional PCB services like PCBWay.

For complete step-by-step instructions, Arduino code, and a detailed servo motor testing setup, check the full guide here:
https://playwithcircuit.com/how-to-interface-servo-motor-with-arduino/

Water Level Sensor with Arduino

Play with Circuit — Fri, 04 Apr 2025 11:21:56 +0000

Water wastage due to tank overflow is a common issue faced in many homes and buildings. Fortunately, this problem can be effectively addressed with a simple and affordable solution: a Water Level Sensor. By integrating this sensor with an Arduino, we can monitor the water level inside a tank in real-time and trigger alerts—such as turning on an LED or buzzer—when the tank is about to overflow.
In this tutorial, you'll learn how water level sensors work, how to connect them to an Arduino.

How Does a Water Level Sensor Work?

A water level sensor detects the presence or height of water in a container by measuring the electrical resistance between exposed conductive traces. When water comes into contact with the sensor, it changes the resistance between these traces, which in turn alters the output voltage.

Here's how it works:
More water → more conductivity → lower resistance → higher output voltage
Less water → less conductivity → higher resistance → lower output voltage
This analog voltage output is then read by an Arduino analog pin and mapped to represent the water level. The deeper the water covers the sensor, the higher the voltage output.

Water Level Sensor Specifications

Operating voltage: 3 to 5V, < 20mA
Humidity: 10%-90% non-condensing
Operating Temperature: 10℃-30℃
Sensor Type: Analog
Output Voltage Range: 0 to 3.85V
Detection Area: 40mm (height) x 16mm (width)

Water Level Sensor Hardware Overview

The water level sensor consists of 10 parallel conductive traces:
5 Power Traces (connected to VCC)
5 Sense Traces (connected to signal output)

These traces are arranged alternately so that each sensing trace is placed between two power traces. When water bridges the traces, it allows current to flow, which is interpreted by the internal circuit as an increase in water level.
The module also contains:

A power LED to indicate the sensor is powered.
An NPN transistor for switching behavior.
Multiple resistors to limit current and protect the components.

Pinout of Water Level Sensor

VCC: Power supply pin (connect to 5V on Arduino)
GND: Ground connection
OUT: Analog output (connect to Arduino analog pin)

Schematic Diagram

The internal working of the sensor module can be broken down into these parts:
NPN Transistor (Q1): Acts as a switch, turning on when the sensor detects water.
Resistors (R1, R2, R3): Limit the current and protect the components.
Copper Traces: The power traces are connected to VCC through resistors, and sense traces go to the transistor's base.

**Working Principle: **When water bridges the traces, it creates a voltage at the transistor’s base. This allows current to flow from collector to emitter, effectively turning the transistor ON. As a result, the signal pin provides an analog voltage output that increases with water level.

Wiring a Water Level Sensor to Arduino

The circuit diagram is shown as follows:

Wiring:
Sensor VCC → Arduino 5V
Sensor GND → Arduino GND
Sensor OUT → Arduino A0 (analog pin)
SCK and SDA pins of LCD → I2C pin of the Arduino

Arduino Code

/* 
Interfacing Water Level Sensor with Arduino UNO using Analog Output pin of Module
by www.playwithcircuit.com
Using this code we will know the Analog Value when water level is very low and when it is very high.
*/
#include <LiquidCrystal_I2C.h>  // Library to Run I2C LCD
// define the size of filter array
#define FILTER_SIZE 20
// 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 soil moisture sensor
const int WaterSensorPin = A0;
// 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();
  // Print a message to the LCD
  lcd.setCursor(0, 0);
  lcd.print("Analog Value:");
}
void loop() {
  // Variable to store sensor values
  int sensorValue;
  // Variable to store filtered values
  int filteredValue;
  // Read the value from the soil moisture sensor
  sensorValue = analogRead(WaterSensorPin);
  filteredValue = Filter(sensorValue);
  // Display the filtered Analog Value on the LCD
  lcd.setCursor(0, 1);
  lcd.print(filteredValue);
  // Clear Previous Data
  lcd.print("   ");
  // Wait for 50ms before the next loop
  delay(50);
}
// Averaging filter to filter Analog Values
int Filter(int sensorValue) {
  static int analogArray[FILTER_SIZE] = { 0 };
  int filteredValue = 0;
  int i;
  // Shift the Elemnent 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 how to create a water level indicator checkout: https://playwithcircuit.com/water-level-sensor-arduino-tutorial/