DEV Community: Play with Circuit

Interface a MicroSD Card Module with Arduino UNO

Play with Circuit — Sat, 19 Sep 2026 05:30:17 +0000

When an Arduino project needs to store data over a long period, the board's internal memory quickly becomes a limitation. A weather station, for example, may need to record temperature and humidity every few seconds. A soil-monitoring system might need to keep readings for several days.

A MicroSD card is a simple way to add external storage to such projects. With a small MicroSD card module, an Arduino UNO can read and write files on a memory card using the SPI interface.

In this tutorial, we'll connect a MicroSD card module to an Arduino UNO and use it to access files on the card. An I2C LCD is also used to display information from the card.

What You Need

For this project, you'll need:

Arduino UNO R3
MicroSD card module
MicroSD card
16x2 LCD with I2C interface
Jumper wires
USB cable for Arduino UNO
Arduino IDE
5V power supply, if required

Understanding the MicroSD Card Module

A typical Arduino MicroSD card module contains more than just the card socket.

It generally includes a 3.3V voltage regulator and a logic-level conversion circuit so that it can be used with 5V Arduino boards.

The MicroSD card itself operates at approximately 3.3V. The regulator on compatible modules converts the incoming supply to the required voltage for the card.

The logic-level circuitry is used to translate the SPI signals between the Arduino's 5V logic and the SD card's lower-voltage logic.

Because different MicroSD modules are available, it's worth checking the schematic or markings of your particular module before applying power.

MicroSD Module Pins

Most of the common SPI-based MicroSD modules provide these pins:

Module Pin	Function
VCC	Power supply
GND	Ground
MISO	Data from SD card to Arduino
MOSI	Data from Arduino to SD card
SCK	SPI clock
CS	Chip Select

The SD card communicates with the Arduino through the SPI bus. On an Arduino UNO, the hardware SPI pins are:

MOSI — D11
MISO — D12
SCK — D13

The CS pin can be assigned to a suitable digital pin. In this example, we'll use D10.

Connecting the MicroSD Module to Arduino UNO

Connect the module as follows:

MicroSD Module	Arduino UNO
CS	D10
SCK	D13
MOSI	D11
MISO	D12
VCC	5V*
GND	GND

*The 5V connection assumes you are using a MicroSD module specifically designed with the appropriate regulator/level shifting for 5V Arduino boards. Do not connect 5V directly to a bare MicroSD card.

The SPI connections are straightforward because the Arduino UNO has dedicated hardware SPI pins.

Adding the I2C LCD

The LCD is connected through the Arduino UNO's I2C interface.
For an UNO:

I2C LCD	Arduino UNO
VCC	5V
GND	GND
SDA	A4
SCL	A5

Many 16x2 I2C LCD modules use 0x27 as their default address, but this isn't universal. If the LCD doesn't respond, scanning the I2C bus is a good way to find its actual address.

Also check the address-selection jumpers on your LCD backpack if your particular module provides them.

Arduino Libraries

You can use the built-in SD and SPI libraries for the MicroSD card.

For the LCD, install the LiquidCrystal_I2C library.

In Arduino IDE:

Open Library Manager.
Search for LiquidCrystal I2C.
Install the library you intend to use.
The SD and SPI libraries are normally included with the Arduino AVR core.

Using a MicroSD Card for Data Logging

This is where the MicroSD module becomes particularly useful.

Suppose you're building an environmental monitoring system with a temperature and humidity sensor. Instead of keeping only the latest measurement in RAM, the Arduino can periodically append each measurement to a file.

A typical workflow would be:

Sensor
   ↓
Arduino UNO
   ↓
SPI
   ↓
MicroSD Module
   ↓
Data File

The file could contain one measurement per line, making it relatively easy to process later on a computer.

The same approach can be used for:

Weather stations
Soil-moisture monitoring
Energy monitoring
GPS data logging
Industrial sensor logging
Temperature monitoring
Motion/event recording
IoT prototypes with offline data storage

A Few Things to Check When the SD Card Doesn't Work

MicroSD modules can sometimes be surprisingly sensitive during initial setup. If the Arduino reports that the card initialization failed, check these points before changing the code.

Check the CS pin first. The pin defined in the program must match the physical connection. In this example, it is D10.

Check the SPI wiring. On an Arduino UNO, MOSI is D11, MISO is D12 and SCK is D13.

Check the card format. An incorrectly formatted or incompatible card can prevent initialization.

Try another MicroSD card. Some cards work more reliably than others with older Arduino libraries and hardware.

Check the module's voltage arrangement. Not every MicroSD breakout is designed to accept 5V directly. Verify that your particular board includes the required regulator and level shifting.

Keep the SPI wires short. Long jumper wires can introduce communication problems, especially on breadboards.

Final Thoughts

Adding a MicroSD card gives an Arduino project a practical way to store much more data than the microcontroller's internal memory can hold.

The SPI interface keeps the wiring simple, and the Arduino SD library provides the basic functions needed to initialize the card, create files, read data, and write new records.

Once the basic interface is working, you can extend the project into a complete data logger by connecting sensors and periodically saving their readings to the SD card.

If you want to follow the complete project and source-code implementation, you can find the detailed tutorial on Play with Circuit.

How nRF24L01+ Works and How to Interface It with Arduino

Play with Circuit — Mon, 07 Sep 2026 09:13:20 +0000

Wireless communication between microcontrollers is useful in many projects where running physical wires between devices is inconvenient. For example, the same approach can be used for remote sensing, wireless control, home automation, and distributed sensor systems.

For Arduino-based projects, the nRF24L01+ transceiver module is a practical option for adding wireless communication. It operates in the 2.4 GHz ISM band and supports both transmitting and receiving data, which makes it possible to build simple two-way communication systems as well as networks with multiple transmitters.

In this project, I am using two Arduino boards with nRF24L01+ modules to demonstrate a basic communication between an initiator and a responder. The initiator sends a message, the responder receives it and sends a reply, and the communication status is displayed on an I2C LCD connected to the initiator.

I will also cover how the nRF24L01+ Multiceiver feature can be used to communicate with multiple transmitters through a single receiver.

What is the nRF24L01+?

The nRF24L01+ is a low-cost, single-chip wireless transceiver module capable of both transmitting and receiving data. The module operates between 1.9 V and 3.6 V and works best with a 3.3 V supply.

It is a relatively low-power device. During transmission it consumes around 11.3 mA, while receive current is around 13.5 mA. It can also enter standby and power-down modes, where its current consumption drops considerably. This makes it useful for battery-powered wireless applications.

The standard nRF24L01+ module uses a PCB trace antenna and can provide a communication range of around 50–100 meters in open space. If a longer range is required, versions with a PA (Power Amplifier), LNA (Low-Noise Amplifier), and external antenna are available. Depending on the environment and configuration, these versions can provide communication distances of up to 1000 meters in open space.

The nRF24L01+ supports data rates of 250 Kbps, 1 Mbps, and 2 Mbps. Using a lower data rate such as 250 Kbps can improve the effective communication range because the lower rate is less sensitive to noise.

Technical Specifications

Parameter	Specification
Frequency range	2.4 – 2.5 GHz ISM band
Data rates	250 Kbps / 1 Mbps / 2 Mbps
Maximum output power	0 dBm
Operating voltage	1.9 – 3.6 V
Maximum operating current	13.5 mA
Standby current	26 µA
Logic inputs	5 V tolerant
Communication range	100 m (open space)
SPI interface speed	0–8 Mbps

For the complete electrical specifications, refer to the nRF24L01+ product datasheet.

How Does the nRF24L01+ Communicate?

The nRF24L01+ operates in the 2.4 GHz ISM band, from 2.400 GHz to 2.525 GHz. This frequency range is divided into channels. At a data rate of 1 Mbps, the channel spacing is 1 MHz, giving 126 available channels from channel 0 to channel 125.

For two nRF24L01+ modules to communicate, both modules need to be configured to use the same RF channel. For example, if the transmitter is configured for 2500 MHz, corresponding to channel 100, the receiver must use the same frequency.

This channel-based arrangement also makes it possible to operate multiple groups of nRF24L01+ devices in the same area while reducing interference by assigning different groups to different channels.

Multiceiver

One of the useful features of the nRF24L01+ is its Multiceiver capability. A single receiver can communicate with up to six different transmitters on the same RF channel.

The receiver uses six individual data pipes, each with its own address. Although six pipes can be configured, only one data pipe can receive a packet at any particular moment.

This feature is particularly useful when several Arduino-based nodes need to send information to one central Arduino.

Enhanced ShockBurst

The nRF24L01+ also has hardware support for the Enhanced ShockBurst communication protocol. A number of tasks that would otherwise have to be handled by the microcontroller are managed internally by the RF module.

When transmitting, the module handles packet formation, including the preamble, address, and CRC. When a packet reaches the receiver, the module checks whether the packet is valid before placing the received data into its Rx FIFO.

The module can also automatically send an acknowledgment to the transmitter after successfully receiving a valid packet. If the transmitter does not receive the expected acknowledgment, it can automatically retransmit the packet.

These features make communication more reliable and reduce the amount of communication-handling code required on the Arduino.

nRF24L01+ Module Variants

The nRF24L01+ is available in several physical configurations. The core nRF24L01+ chip is essentially the same, but the antenna arrangement and additional RF circuitry can differ.

nRF24L01+ with PCB Antenna

This is the commonly available compact version of the module. It uses a PCB trace antenna and is suitable for short- to medium-range wireless communication.

Its typical range can reach around 100 meters in open space, although the actual range indoors can be considerably lower because walls, furniture, and other objects affect the RF signal.

nRF24L01+ with SMA Connector

Another version provides an SMA connector for connecting an external antenna. The external antenna can provide better signal performance and can improve communication range and stability, particularly when there are obstacles between the two devices.

nRF24L01+ PA + LNA Version

For applications requiring greater range, the PA + LNA version combines an external antenna with additional RF amplification.

This version includes an RFX2401C range extender that provides Power Amplifier and Low-Noise Amplifier functionality along with transmit/receive switching. With the additional amplification and external antenna, communication distances of up to 1000 meters in open space are possible under suitable conditions.

The PA + LNA module remains compatible with other nRF24L01+ variants, so it can generally be substituted for the standard module in the same type of Arduino project.

What Do PA and LNA Do?

The Power Amplifier (PA) increases the strength of the signal being transmitted. This allows the RF signal to travel a greater distance.

The Low-Noise Amplifier (LNA) works on the receiving side. Signals arriving from a distant transmitter can be very weak, so the LNA amplifies these incoming signals while keeping additional noise low.

Using both PA and LNA therefore helps the module transmit over longer distances and receive weaker signals more effectively.

nRF24L01+ Pinout

The nRF24L01+ has eight pins: GND, VCC, CE, CSN, SCK, MOSI, MISO, and IRQ.

GND is the ground connection. On the module, this pin is marked with a square pad, which can help identify the pin orientation.

VCC is the power supply pin. The module operates from 1.9 V to 3.6 V and works best at 3.3 V.

CE (Chip Enable) is an active-high control pin used to switch the module between active and standby states. When CE is HIGH, the module can operate in transmit or receive mode according to its configuration. When CE is LOW, the module remains in standby mode.

CSN (Chip Select Not) is the active-low SPI chip-select pin. It is normally HIGH and is pulled LOW when the Arduino needs to communicate with the nRF24L01+ over SPI.

SCK (Serial Clock) receives the SPI clock signal generated by the Arduino.

MOSI (Master Out Slave In) carries data from the Arduino to the nRF24L01+.

MISO (Master In Slave Out) carries data from the nRF24L01+ back to the Arduino.

IRQ (Interrupt Request) is an optional active-low interrupt pin. It can be used by the module to notify the microcontroller about events such as received data.

Two-Way Communication Between Two nRF24L01+ Modules

To test the wireless link, I used two Arduino boards, each connected to an nRF24L01+ module. One Arduino acts as the initiator, while the other works as the responder.

The initiator sends a message through its nRF24L01+ module. When the responder receives the message, it sends a response back to the initiator. An I2C LCD connected to the initiator displays the communication status.

This provides a simple way to verify that the two RF modules are correctly configured and that data is being exchanged in both directions.

Hardware Requirements

Component	Quantity	Remarks
Arduino UNO R3	1	Revision R3
LCD 16x2	1	I2C support
Jumper Wires	1	For Arduino and LCD connections
USB Cable Type A to B	1	For programming Arduino UNO
12V Supply Adapter	1	For providing power to Arduino
nRF24L01+ Modules	1	For interfacing with Arduino

Software Requirements

The project uses the Arduino IDE for programming. The required software setup is:

Arduino IDE version 2.3.4 or above
LiquidCrystal_I2C library by Frank de Brabander, version 1.1.2
RF24 library by TMRh20, version 1.5.0

Wiring Connections

There are two wiring setups in this project: one for the initiator and another for the responder.

The nRF24L01+ connections are the same on both Arduino boards. The main difference is that the initiator also has an I2C LCD connected to it, while the responder sends its received data through the serial port.

Initiator Wiring

The nRF24L01+ communicates with the Arduino through the SPI bus using the MISO, MOSI, SCK, and CSN pins. In addition to these connections, CE, VCC, and GND are also connected. The IRQ pin is left unused.

The connections between Arduino Uno and nRF Module are as follows:

nRF Module	Arduino Side Pin
GND (Pin 1)	GND pin of Arduino
VCC (pin 2)	3.3V pin of Arduino
CE (Pin 3)	9
CSN (Pin 4)	10
SCK (Pin 5)	13
MOSI (Pin 6)	11
MISO (Pin 7)	12
IRQ (Pin 8)	Not connected

When using a base for the nRF module that internally converts 5 V to 3.3 V, the power connection of the base can be connected to the 5 V pin of the Arduino.

If the nRF24L01+ module is being used without such a base, its VCC should instead be connected directly to the Arduino's 3.3 V pin, as shown in the wiring setup.

The Arduino uses 5 V logic while the nRF24L01+ operates at 3.3 V. Although the 5 V SPI signals do not necessarily cause immediate failure of the module, exposing the module to these voltage levels can affect its long-term reliability. A voltage level shifter is therefore recommended for industrial or long-term applications. For simplicity, a level shifter is not included in this project.

I2C LCD Connections

The I2C LCD requires only four connections to the Arduino: VCC, GND, SCL, and SDA.

Connect the VCC and GND pins of the I2C LCD to the corresponding VCC and GND pins of the Arduino. The SCL and SDA pins connect to the Arduino's SCL and SDA pins.

On the Arduino Uno, these correspond to the A5 and A4 analog pins respectively. The SCL and SDA header pins are also connected internally to A5 and A4.

One important detail is the I2C address of the LCD. Make sure the A0, A1, and A2 address jumpers are not shorted. In this project, the code uses the I2C address 0x27, which is obtained when these address jumpers are left open.

Responder Wiring

The responder uses the same nRF24L01+ to Arduino connections as the initiator. Since there is no I2C LCD on this Arduino, the responder has fewer connections.

The nRF24L01+ is connected through the same SPI pins, with CE connected to Arduino pin 9, CSN to pin 10, SCK to pin 13, MOSI to pin 11, and MISO to pin 12. VCC is connected to 3.3 V and GND to Arduino GND, while IRQ remains unconnected.

The responder can then receive the wireless message from the initiator and send its response through the serial interface.

Moving from Two Devices to Multiple Transmitters

Once the basic two-way communication is working, the same nRF24L01+ platform can be extended to a setup where several transmitter nodes communicate with a single receiver.

This is where the Multiceiver feature becomes useful. Instead of having one dedicated transmitter and one receiver, multiple nRF24L01+ transmitters can send information to a central receiver using separate data-pipe addresses on the same RF channel.

If you want to build this configuration, the complete wiring, transmitter and receiver code, and the implementation details are covered in the Play with Circuit project:

Communication between Multiple nRF24L01+ Transmitters to a Single Receiver

The multiple-transmitter setup is a useful next step when moving from a simple point-to-point wireless link toward a small distributed Arduino network.

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/