DEV Community: Play with Circuit

How to Interface the Reyax RYLR999 LoRa Module with Arduino

Play with Circuit — Tue, 25 Aug 2026 08:34:01 +0000

Long-range wireless communication is an important part of modern IoT systems, particularly when connected devices need to exchange small amounts of data over large distances while operating with limited power. Technologies such as Wi-Fi and Bluetooth are convenient for short-range communication, while cellular networks provide wide coverage but generally involve higher power consumption and operating costs.

LoRa is designed to address this gap. It provides long-distance wireless communication with relatively low power requirements, making it well suited for applications such as environmental monitoring, agriculture, industrial sensing, remote control, and other IoT projects.

In this project, we explore the Reyax RYLR999 LoRa module and its interface with an Arduino UNO. The setup demonstrates a simple two-way LoRa communication link in which one Arduino acts as the initiator and another works as the responder.

Project Overview

The basic idea is to establish point-to-point communication between two RYLR999 modules connected to separate Arduino UNO boards.

The first Arduino works as the initiator. It periodically sends the message “Are you there?” through its RYLR999 module. The second Arduino acts as the responder, listening for the incoming LoRa message and returning “Yes” when the request is received.

This simple exchange provides a practical way to understand how the RYLR999 communicates with a microcontroller through UART and how AT commands can be used to control LoRa transmission and reception.

The project also demonstrates the difference between the two sides of a wireless communication link: one device generates and transmits the request, while the other receives the request and sends a response.

What Is LoRa?

LoRa stands for Long Range and is a wireless communication technology developed by Semtech. It is intended primarily for applications where devices need to transmit relatively small amounts of information over considerably longer distances than conventional short-range wireless technologies.

LoRa is particularly useful for IoT devices because many IoT nodes send only small packets of information.

Depending on environmental and radio conditions, LoRa communication can typically reach approximately 15 to 20 km in open environments.

LoRa commonly operates in license-free ISM frequency bands such as 433 MHz, 868 MHz, and 915 MHz. It can also operate in the 2.4 GHz band for applications requiring higher data rates, although communication range is generally reduced at this frequency.

An important characteristic of LoRa is the balance it provides between communication range, data rate, and power consumption. It is therefore better suited to small, infrequent data packets than to applications that continuously transfer large amounts of information.

How Does LoRa Technology Work?

LoRa operates at the physical layer of wireless communication and defines how information is converted into a radio signal for transmission.

When a microcontroller needs to send information, the digital data is passed to the LoRa transceiver. The radio then uses Chirp Spread Spectrum (CSS) modulation to encode the information into frequency-swept chirp signals.

These chirps spread the transmitted information across a wider bandwidth. This improves receiver sensitivity and helps the system operate in the presence of noise and interference.

One of the major advantages of this approach is that a LoRa receiver can detect relatively weak signals. This contributes to the technology's long communication range while allowing the radio to operate at comparatively low power.

At the receiving end, the LoRa transceiver demodulates the incoming chirp signal and converts it back into digital information. The resulting data is then made available to the connected microcontroller through the module's UART interface.

LoRa generally works with low data rates and is intended for small packets rather than continuous high-bandwidth communication. This makes it practical for battery-operated devices that can remain in a low-power state between transmissions.

It is important to distinguish LoRa from LoRaWAN. LoRa describes the radio communication technology at the physical layer, while LoRaWAN is a higher-level networking protocol designed for connecting LoRa devices to wider networks and infrastructure.

Where LoRa Is Used

LoRa is a good choice when the application needs:

Long-distance communication
Low power consumption
Small amounts of transmitted data
Battery-operated sensor nodes
Wireless communication in areas without conventional network infrastructure

It is not intended for applications such as video streaming, audio transmission, or transferring large files because its data rate is comparatively low.

Introduction to the RYLR999 Module

The RYLR999 Lite is a long-range wireless communication module developed by REYAX Technology. The module combines 868/915 MHz LoRa communication with 2.4 GHz Bluetooth Low Energy (BLE) capabilities in a compact transceiver.

A notable feature of the RYLR999 is that it provides separate UART interfaces for its BLE and LoRa functions. This allows the two wireless communication paths to be handled independently.

The BLE UART interface is used for exchanging information with devices such as smartphones, BLE-enabled systems, or compatible microcontrollers. The LoRa UART interface, meanwhile, handles LoRa-related data transmission and reception.

The module can be configured through AT commands. Parameters such as LoRa addresses, network IDs, operating frequency, and modulation settings can be configured according to the requirements of the application.

When a transmission command is issued, the module processes the supplied data and sends it wirelessly using LoRa's CSS-based modulation. Another compatible RYLR999 module can receive the transmitted packet and make the received information available through its UART interface.

Another useful capability of the RYLR999 is its potential to operate as a BLE-to-LoRa bridge. In this type of application, a nearby BLE device can communicate with the module, while the RYLR999 forwards the information through a long-range LoRa connection. This effectively extends the communication reach of a device that would normally be restricted to short-range BLE communication.

RYLR999 Pinout

Understanding the module's pin functions is important because the RYLR999 uses separate UART connections for its BLE and LoRa interfaces.

VDD (Pin 1): This is the module's power supply pin.
RST (Pin 2): This is the reset input.
TXD_BLE (Pin 3): This pin functions as the BLE UART transmit output. It is particularly relevant when the module is being used for BLE-to-LoRa bridging.
RXD_LoRa (Pin 4): This is the receiving input of the LoRa UART interface. AT commands and LoRa-related instructions from a microcontroller, PC terminal, or BLE subsystem are supplied through this pin.
TXD_LoRa (Pin 5): This is the transmit output of the LoRa UART interface. Received LoRa data and status information are provided through this pin.
RXD_BLE (Pin 6): This pin receives data intended for the BLE subsystem. Commands or information that need to be sent to the BLE section from a microcontroller or PC are supplied through this pin.
GND (Pin 7): This is the ground connection.

Interfacing RYLR999 with Arduino UNO

The RYLR999 can be connected to an Arduino UNO to create a simple point-to-point LoRa communication system. In the proposed arrangement, two Arduino UNO boards are used, with each board connected to one RYLR999 module.

The initiator Arduino is responsible for generating the communication request and sending it through its LoRa module. The responder Arduino remains ready to receive the message and sends a response when the expected request arrives.

The RYLR999 communicates with the Arduino through its LoRa UART interface. Since the RYLR999's digital I/O operates at 3.3 V logic levels, the UART connection requires appropriate voltage-level conversion when interfacing it with the Arduino UNO's 5 V logic.

Initiator Wiring Concept

On the initiator side, the Arduino UNO sends LoRa commands to the RYLR999 and can display the communication status on a 16×2 I2C LCD.

The VDD pin of the RYLR999 is connected to the 5V output of the Arduino UNO, while the GND pin is connected to the Arduino GND.

For UART communication, the TXD_LoRa pin of the RYLR999 is connected to the LV1 pin of the voltage shifter, and the corresponding HV1 output is connected to the Arduino Rx pin.

In the opposite direction, the TX pin of the Arduino is connected to the HV2 pin of the voltage shifter, while the corresponding LV2 output is connected to the RXD_LoRa pin of the RYLR999.

The voltage shifter also requires its power-side connections. The 5V pin of the Arduino is connected to the HV pin of the voltage shifter, while the 3.3V pin of the Arduino is connected to the LV pin. These connections allow the voltage-level converter to operate correctly.

The Arduino UNO and RYLR999 LoRa UART connections can therefore be summarized as:

Arduino UNO 5V → RYLR999 VDD
Arduino UNO GND → RYLR999 GND
Arduino UNO Rx → RYLR999 TXD_LoRa through the voltage shifter
Arduino UNO Tx → RYLR999 RXD_LoRa through the voltage shifter

I2C LCD Connection

The initiator setup can also use a 16×2 I2C LCD to display communication information.

The LCD VCC and GND connections are connected to the corresponding Arduino power and ground pins. The LCD's SCL and SDA lines are connected to the Arduino's I2C pins.

On the Arduino UNO, the I2C lines correspond to:

SCL → A5
SDA → A4

The LCD address configuration is also relevant. When using the address 0x27, the A0, A1, and A2 address jumpers should not be shorted. These jumpers influence the I2C address of the display, so their configuration should match the address used by the software.

Responder Wiring Concept

The responder side follows the same basic RYLR999-to-Arduino UART arrangement but does not require the LCD.

The responder Arduino continuously monitors the LoRa UART interface for incoming communication from the initiator. When the expected request is received, the Arduino processes it and sends the appropriate response through its RYLR999 module.

The main wiring between the Arduino UNO and RYLR999 therefore remains the same:

Arduino UNO 5V → RYLR999 VDD
Arduino UNO GND → RYLR999 GND
Arduino UNO Rx → RYLR999 TXD_LoRa through the voltage shifter
Arduino UNO Tx → RYLR999 RXD_LoRa through the voltage shifter

The primary difference between the two configurations is that the initiator includes the I2C LCD for displaying communication information, whereas the responder operates without the display.

Understanding the Communication Flow

The complete communication sequence can be understood as a simple request-and-response cycle.

First, the initiator Arduino sends an AT command to its RYLR999 module instructing it to transmit the required message. The module converts the data into a LoRa radio signal and broadcasts it to the receiving RYLR999.

The responder module receives the LoRa packet and forwards the resulting data to its Arduino through the LoRa UART interface.

After identifying the incoming request, the responder Arduino instructs its RYLR999 to transmit a reply. The second module then sends the response wirelessly back to the initiator.

The initiator's RYLR999 receives the response and makes the received information available to the Arduino through TXD_LoRa. This completes the two-way communication cycle.

Important Considerations

When working with the RYLR999, the power supply and logic-level requirements should be considered carefully. Although the module requires a 5 V supply within the specified range, its digital I/O uses 3.3 V logic levels. Appropriate voltage-level conversion should therefore be used for UART communication with the Arduino UNO.

The RYLR999 can operate at relatively high LoRa transmit power, with the specified maximum output reaching +30 dBm (1 Watt). The antenna and RF implementation should therefore follow the module manufacturer's recommendations.

LoRa's long range should also not be interpreted as unlimited bandwidth. The technology is optimized for small data packets and long-distance communication rather than high-speed data transfer.

Conclusion

The RYLR999 provides a practical way to add long-range wireless communication to Arduino-based projects. Its LoRa interface allows small packets of information to travel significantly farther than conventional short-range wireless technologies, while its BLE functionality adds another communication option within the same module.

By connecting two RYLR999 modules to separate Arduino UNO boards, it is possible to create a straightforward point-to-point communication system. The initiator can send a request such as “Are you there?”, while the responder can return “Yes”, demonstrating the basic principles of LoRa data transmission and reception.

The module's UART interface, AT-command configuration, long-range capability, and BLE-to-LoRa functionality make the RYLR999 useful for a variety of IoT, sensor, automation, and remote-monitoring applications where reliable long-distance communication is required without depending on conventional Wi-Fi or cellular connectivity.

For source code Visit: Play with Circuit(playwithcircuit.com)

How to Use the SH-C30L USB-to-CAN Adapter with Arduino UNO and MCP2515

Play with Circuit — Tue, 18 Aug 2026 06:39:35 +0000

Controller Area Network (CAN) is one of those technologies that quietly powers a huge number of embedded systems. It is commonly found in cars, EVs, industrial controllers, robotics, and other distributed systems where multiple devices need to exchange data reliably over a shared bus.

For development and debugging, it is useful to connect that CAN network to a computer. The problem is that a standard computer communicates through USB, while CAN uses a dedicated differential bus. A USB-to-CAN interface solves this problem by translating between the two.

In this project, we will explore the DSD TECH SH-C30L USB-to-CAN adapter, learn how its different firmware modes work, connect it to a PC, and then use an Arduino UNO with an MCP2515 CAN module to create a simple bidirectional CAN communication setup.

The goal is not just to make the hardware work, but also to understand what happens between the Arduino, CAN bus, USB adapter, and computer.

SH-C30L USB-to-CAN Adapter Overview

The SH-C30L is a compact USB-to-CAN interface designed to connect a computer directly to a CAN network. It is based on an STM32F072C8T6 microcontroller, which contains an integrated CAN controller. This allows the adapter to handle CAN protocol processing without requiring a separate external CAN controller.

The microcontroller communicates with the computer through USB, while a dedicated CAN transceiver handles the physical CAN interface. The transceiver converts the controller's logic-level signals into the differential CAN_H and CAN_L signals used on a CAN network.

One of the interesting aspects of the SH-C30L is its firmware flexibility. The adapter can work with Candlelight firmware, which allows it to operate with Linux SocketCAN and compatible CAN applications, or with SLCAN firmware, where it behaves more like a serial CAN interface. This makes the same hardware useful with different operating systems and software environments.

The adapter supports both CAN 2.0A and CAN 2.0B frames, with CAN speeds of up to 1 Mbps. It also includes a switchable 120Ω termination resistor and a boot switch for entering firmware-update mode.

For a small development setup, these features make the SH-C30L a useful alternative to more expensive professional CAN interfaces.

Why Do We Need a Driver?

When you plug a USB-to-CAN adapter into a computer, the operating system needs to know how to communicate with the device.

On modern Windows systems, the SH-C30L can generally be detected using the operating system's built-in USB support, depending on the firmware installed. Linux provides even stronger native CAN support through SocketCAN.

If the adapter appears as an unknown USB device, a driver may need to be installed manually. Therefore, the first troubleshooting step should always be checking Device Manager on Windows or the relevant USB/CAN interfaces on Linux.

Software You Can Use

The software required depends on the firmware and operating system.

On Linux, SocketCAN is particularly useful. The can-utils package provides utilities such as:

candump for monitoring CAN traffic
cansend for transmitting CAN frames
cansniffer for observing changing CAN data
canbusload for checking bus utilization

On Windows, Cangaroo provides a graphical interface for monitoring and transmitting CAN messages. It can also work with DBC files for decoding signals.

For custom applications, Python is another useful option. The python-can library provides an interface for sending and receiving CAN messages from Python programs.

Using the SH-C30L with Linux and SocketCAN

Linux is particularly convenient for CAN development because CAN support is integrated into the operating system through SocketCAN.

When the SH-C30L is running Candlelight firmware, it can appear as a native CAN interface such as can0.

With SLCAN firmware, the setup is slightly different because the adapter is exposed through a serial interface and tools such as slcand can be used to create a CAN network interface.

Using the SH-C30L with Python

Python is useful when CAN communication needs to become part of a larger application.

Instead of manually watching frames in a CAN analyzer, you can write a program that records messages, checks specific CAN IDs, generates test traffic, or communicates with another application.

The connection method depends on the firmware. A Candlelight-based setup can use a SocketCAN interface such as can0, while an SLCAN configuration may use a serial port.

Windows Testing with Cangaroo

Windows users can use Cangaroo to verify that the SH-C30L is communicating correctly.

Start by connecting the adapter to the PC and opening Device Manager. With the factory Candlelight firmware, the adapter may appear as a CANable/gs_usb-type device.

Next, launch Cangaroo and open its measurement setup. If the adapter is detected correctly, the available CAN interface should appear in the interface list.

Select the detected interface and configure the CAN bitrate to match the network. For example, if the CAN network operates at 500 kbps, the software must also be configured for 500 kbps.

Once the interface is active and another CAN node is transmitting, frames should begin appearing in the monitoring window.

This is a simple way to verify the adapter before connecting it to a more complicated embedded system.

MCP2515 CAN Module Overview

The Arduino UNO is a popular development board, but it does not include a native CAN controller. To add CAN functionality, an external CAN controller and transceiver are required.

The commonly available MCP2515 CAN module solves this problem by combining an MCP2515 CAN controller with a CAN transceiver, often a TJA1050 on typical modules.

MCP2515 CAN Controller

The MCP2515 handles the CAN protocol itself. It communicates with the Arduino through the SPI bus and takes care of CAN frame transmission and reception.

It supports standard 11-bit identifiers as well as extended 29-bit identifiers and provides hardware filtering and masking features. These functions are useful when a CAN network contains many different message IDs but the Arduino only needs to process a small subset.

The MCP2515 also has an interrupt output. When a relevant CAN event occurs, the INT pin can notify the Arduino so that the microcontroller does not have to continuously poll the controller.

TJA1050 CAN Transceiver

The MCP2515 cannot directly drive the CAN_H and CAN_L lines. The TJA1050 transceiver handles this physical-layer conversion.

It converts the digital CAN signals from the MCP2515 into the differential signals used on the CAN bus and converts incoming CAN bus signals back into logic-level signals for the controller.

In simple terms:

MCP2515 = CAN protocol controller

TJA1050 = CAN physical-layer transceiver

Together, they provide the Arduino with a practical CAN interface.

120Ω Termination

CAN networks normally require termination resistors at both physical ends of the bus.

Many MCP2515 modules include a 120Ω resistor that can be enabled or disabled with a jumper. Whether you should enable it depends on where the module is located in the CAN network.

If the MCP2515 is one end of the bus, its termination can be enabled. If it is a middle node, the termination should normally be disabled.

The SH-C30L also has a switchable 120Ω termination resistor, which makes it convenient to create a correctly terminated two-node test network.

Crystal Oscillator

The MCP2515 requires a clock reference for CAN timing. Common breakout boards use either an 8 MHz or 16 MHz oscillator.

This is important when configuring the Arduino library. The oscillator frequency defined in the software must match the actual MCP2515 module.

Using the wrong oscillator setting can result in CAN initialization or communication problems even when the wiring is correct.

Interfacing Arduino UNO with MCP2515

The MCP2515 communicates with the Arduino UNO using SPI.

For a typical UNO setup, connect:

MCP2515	Arduino UNO
VCC	5V
GND	GND
CS	D10
MOSI	D11
MISO	D12
SCK	D13
INT	Optional interrupt pin

The CS pin can be changed in software, but the SPI data pins are normally connected to the UNO's hardware SPI pins.

After connecting the SPI interface, the Arduino can configure the MCP2515 and exchange CAN frames through it.

Connecting the MCP2515 to the SH-C30L

The second part of the setup is the CAN bus connection.

Connect:

MCP2515	SH-C30L
CAN_H	CAN_H
CAN_L	CAN_L
GND	GND

The CAN_H and CAN_L lines must not be swapped.

A common ground is also recommended for this non-isolated setup.

If the MCP2515 and SH-C30L are the two endpoints of the test bus, enable the 120Ω termination on both devices. With two 120Ω resistors in parallel, the measured resistance between CAN_H and CAN_L should be approximately 60Ω when the system is powered off.

How the Complete System Works

Once everything is connected, the communication path looks like this:

Arduino UNO
     │
     │ SPI
     ▼
  MCP2515
     │
     │ CAN_H / CAN_L
     ▼
  SH-C30L
     │
     │ USB
     ▼
     PC / Laptop

When the Arduino sends data, it first transfers the information to the MCP2515 through SPI.

The MCP2515 packages the information into a CAN frame and passes it to the CAN transceiver. The transceiver places the differential signal onto CAN_H and CAN_L.

The SH-C30L receives that CAN frame, converts it into a USB-compatible representation, and forwards it to the computer.

The process also works in the opposite direction.

A CAN frame generated by the PC is sent through USB to the SH-C30L. The adapter places it on the CAN bus, where the MCP2515 receives it. The Arduino can then read the frame through SPI and process the information in its program.

This gives us a simple bidirectional CAN communication link between Arduino and a computer.

CAN Termination: Don't Skip This

Termination is one of the first things to check when a CAN network does not behave as expected.

For this two-node test setup, the MCP2515 and SH-C30L represent the two ends of the bus. Therefore, both ends should have 120Ω termination enabled.

With power removed, measuring between CAN_H and CAN_L should give approximately 60Ω because:

120Ω || 120Ω ≈ 60Ω

If you measure approximately 120Ω, only one termination resistor is active. If the measurement is significantly different, check the wiring and termination configuration.

Troubleshooting Tips

If no CAN messages are appearing, check the basics before changing the software configuration.

Confirm that CAN_H is connected to CAN_H and CAN_L to CAN_L.
Make sure all devices use the same CAN bitrate.
Check whether the MCP2515 module uses an 8 MHz or 16 MHz oscillator.
Verify that the correct MCP2515 CS pin is defined in your Arduino code.
Check the termination resistors.
Confirm that the SH-C30L is detected by the operating system.
Make sure the selected firmware matches the software interface you are using.
Use a common ground between the Arduino-side CAN hardware and the SH-C30L.

CAN troubleshooting becomes much easier when you verify one layer at a time: first USB detection, then CAN adapter configuration, then CAN bus signaling, and finally Arduino communication.

Where This Setup Can Be Used

This setup is useful for experimenting with:

Automotive CAN communication
ECU development and diagnostics
EV and battery-system communication
Industrial controllers
Robotics
CAN-based sensor networks
Embedded-system testing
CAN protocol learning

It is particularly useful for students and hobbyists because it provides a practical way to observe how CAN communication moves between an embedded controller and a computer.

Conclusion

The SH-C30L provides a convenient bridge between a computer and a CAN network, while the MCP2515 gives the Arduino UNO the CAN capability that it lacks internally.

Putting the three pieces together creates a useful development platform: the Arduino generates or processes CAN messages, the MCP2515 handles CAN protocol communication, and the SH-C30L provides the connection to PC-based monitoring and debugging software.

The setup also demonstrates an important concept in embedded systems: communication often involves multiple layers. SPI connects the Arduino to the CAN controller, the CAN transceiver handles the physical bus, and USB connects the CAN network to the computer.

For complete step-by-step instructions, wiring details, code, and additional testing information, you can also refer to the original guide on Play with Circuit:

https://playwithcircuit.com/how-to-interface-servo-motor-with-arduino/

If you're just getting started with CAN, this project is a good way to move from simply reading about the protocol to actually sending, receiving, and analyzing CAN frames.

Arduino 5V 4-Channel Relay Module: Pinout, Wiring and How It Works

Play with Circuit — Tue, 11 Aug 2026 05:18:24 +0000

An Arduino can easily control LEDs, sensors, displays, and other low-voltage components. But what happens when you need to switch a motor, lamp, fan, or another higher-power load?

A relay module provides a simple interface between the Arduino and the load.

In this tutorial, we'll look at a commonly available 5V 4-channel relay module (HL-52S type), understand its working, and connect it to an Arduino Uno.

The example uses the relay outputs to control a DC motor and the three channels of a multicolor LED.

Safety: Relay contacts can be used with mains voltage. Do not work with 120/230V AC unless you understand mains safety practices. For this example, we'll use DC loads.

5V 4-Channel Relay Module Pinout

Each relay channel has three output terminals:

COM — Common
NO — Normally Open
NC — Normally Closed

The module also has the following control connections:

Pin	Function
VCC	Relay module supply
GND	Ground
IN1	Relay 1 control
IN2	Relay 2 control
IN3	Relay 3 control
IN4	Relay 4 control

How the HL-52S Relay Module Works

The relay board contains four 5V relay coils and driver circuitry.

On this particular type of module, the control inputs are active LOW.

That means:

HIGH → relay de-energized
LOW → relay energized

The input signal controls a transistor in the driver circuit. When the input is pulled LOW, the transistor switches the relay coil and the corresponding relay changes state.

A flyback diode is connected across each relay coil. Its purpose is to suppress the voltage spike produced when the magnetic field of the coil collapses after the relay is switched off.

The board also provides LEDs to show the power and individual relay states.

Relay Module Specifications

Typical specifications for this 5V 4-channel relay board are:

Parameter	Specification
Supply voltage	3.75V–6V
Input trigger current	Approximately 5mA
Relay coil current	Approximately 70mA per relay
All four relay coils	Approximately 300mA
Maximum switching current	10A
Maximum contact voltage	250VAC / 30VDC

The exact specifications can vary slightly between manufacturers and board revisions, so check the markings or datasheet for your particular module.

Testing the Relay Module with Push Buttons

Before connecting an Arduino, you can also test the relay board using push buttons.

Connect the relay module's IN1–IN4 inputs to four push buttons. The buttons can pull the corresponding inputs to ground.

Because the module uses active-LOW triggering, pressing a button pulls the input LOW and activates that relay.

The relay's indicator LED will also turn on.

When the button is released, the input returns HIGH and the relay returns to its inactive state.

This is a useful way to understand the relay module without writing any code.

Connecting the Relay Module to Arduino Uno

Components

For a basic setup, you'll need:

Arduino Uno R3
5V 4-channel relay module
9V DC motor
Common-cathode multicolor LED
External DC supply/battery for the loads
Breadboard
Jumper wires
USB cable for the Arduino

For the Arduino example, we'll use the following connections:

Relay Module	Arduino Uno
VCC	5V
GND	GND
IN1 — Motor	Pin 2
IN2 — RED	Pin 3
IN3 — BLUE	Pin 4
IN4 — GREEN	Pin 5

The four relay channels are assigned as follows:

Relay 1: DC motor
Relay 2: Red LED channel
Relay 3: Blue LED channel
Relay 4: Green LED channel

The relay contacts are then used to switch the external DC supply to the respective loads.

The Arduino can control each relay independently.

Because the relay contacts are electrically separate from the Arduino control logic, the load receives power from its own supply rather than directly from an Arduino GPIO pin.

Conclusion

A 5V 4-channel relay module is a convenient way to let an Arduino control loads that cannot be driven directly from its GPIO pins.

For the original circuit diagrams and a more detailed hardware walkthrough, see the full 5V 4-channel relay module with Arduino tutorial on 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/