Makerguides.

com

Waterproof JSN-SR04T Ultrasonic Distance

Sensor with Arduino Tutorial
Written by Benne de Bakker (https://www.makerguides.com/author/benne-de-bakker/)

The JSN-SR04T is an easy to use waterproof ultrasonic distance sensor with a range
of 25 to 450 cm. If you are planning to build a water level measuring system or if you
need to take other distance measurements outside, then this is the sensor you need!

In this article I have included a wiring diagram and example codes so you can start
experimenting with your sensor. After each example, I break down and explain how
the code works, so you should have no problems modifying it to suit your needs.
First we will look at an example that doesn’t use an Arduino library. Next I will cover
the easy to use NewPing library that has some nice built in features.

Arduino Distance Sensor -

Precision distance measurement
Ad Auxiliary safety landing of drones, set
height and obstacle avoidance,
en.benewake.com

Learn more

About the sensor

The sensor comes with a 2.5 m long cable that connects to a breakout board which
controls the sensor and does all the processing of the signal. Note that only the
sensor and the cable itself are waterproof, if you get water onto the breakout board,
the sensor might stop working.

An ultrasonic distance sensor works by sending out ultrasound waves. These

ultrasound waves get reflected back by an object and the ultrasonic sensor detects
them. By timing how much time passed between sending and receiving the sound
waves, you can calculate the distance between the sensor and an object.

Distance (cm) = Speed of sound (cm/µs) × Time (µs) / 2

Where Time is the time between sending and receiving the sound waves in
microseconds.

So what are the differences between this sensor and the HC-SR04? The main
difference, besides it being waterproof, is that this sensor uses only one ultrasonic
transducer. This transducer serves as both the transmitter and the receiver of the
ultrasound waves.
For more info on how ultrasonic sensors work, you can check out my article on the
HC-SR04 (https://www.makerguides.com/hc-sr04-arduino-tutorial/). In this article
the working principles of an ultrasonic distance sensor are explained in much greater
detail.

JSN-SR04T Specifications

Operating voltage 5V

Operating current 30 mA

Quiescent current 5 mA

Frequency 40 kHz

Measuring range 25-450 cm

Resolution 2 mm

Measuring angle 45-75 degrees

Sensor dimensions 23.5 x 20 mm, 2.5 m long cable

PCB dimensions 41 x 28.5 mm

Mounting hole 18 mm

For more information you can check out the datasheet here.

JSN-SR04T Datasheet
(https://www.makerguides.com/wp-content/uploads/2019/02/JSN-SR04T-
Datasheet.pdf)
Tools and Materials
Parts are available on Amazon via the links below.

Hardware components

JSN-SR04T sensor x Amazon

(https://amzn.to/2XdsHeH) 1 (https://amzn.to/2XdsHeH)

Arduino UNO R3 x Amazon

(https://amzn.to/2L9w4SS) 1 (https://amzn.to/2L9w4SS)

Breadboard (https://amzn.to/2MQHicc) x Amazon

I highly recommend to buy at least 1 good quality 1 (https://amzn.to/2MQHicc)
breadboard like the BusBoard Prototype Systems
BB400 (https://amzn.to/2MQHicc) or BB830
(https://amzn.to/2GM261Q).

Jumper wires (https://amzn.to/2DCt2R8) ~ Amazon

6 (https://amzn.to/2DCt2R8)

Software

Arduino IDE (https://www.arduino.cc/en/Main/Software)

Note: the above links are affiliated which means – at no additional cost to you – if you purchase anything
using them you’re helping to support my work on this site. My humble thanks (I really appreciate it)!

When shopping for the sensor, you might find the updated version, the JSN-
SR04T-2.0 (https://amzn.to/2FmiZ2G). This newer version works exactly the same,
but some users have found issues while using the sensors at a lower voltage. This
newer version is rated for 3–5 V.

Using a longer trigger puls of at least 20 µs instead of 10µs seems to help if you are
having faulty readings.

-46% -46% -46% -50% -50% -46%

Wiring – Connecting JSN-SR04T to Arduino UNO

The wiring diagram/schematic below shows you how to connect the JSN-SR04T
sensor to the Arduino. The breakout board of the JSN-SR04T has the exact same
pinout as the HC-SR04, so it can be used as a drop-in replacement. The cable of the
sensor itself can be plugged into the connector on the back of the breakout board.

Wiring diagram/schamatic for the JSN-SR04T ultrasonic distance sensor with Arduino.

The code examples below use digital pin 2 and 3 for the trigger and echo pin, but of
course you can change this to any digital pin you want.
JSN-SR04T Connections

JSN-SR04T Arduino

5V 5V

Trig Pin 2

Echo Pin 3

GND GND

Example code for JSN-SR04T sensor with Arduino

Now that you have wired up the sensor it is time to connect the Arduino to the
computer and upload some code. The sensor can be used without an Arduino
library. Later I will show you an example with the NewPing library, which makes the
code a lot shorter.

You can upload the following example code to your Arduino using the Arduino IDE
(https://www.arduino.cc/en/main/software). Next, I will explain you how the code
works. (This code works for the JSN-SR04T-2.0 too).

1. /* Arduino example sketch to control a JSN-SR04T ultrasonic

distance sensor with Arduino. No library needed. More info:
https://www.makerguides.com */
2.
3. // Define Trig and Echo pin:
4. #define trigPin 2
5. #define echoPin 3
6.
7. // Define variables:
8. long duration;
9. int distance;
10.
11. void setup() {
12. // Define inputs and outputs
13. pinMode(trigPin, OUTPUT);
14. pinMode(echoPin, INPUT);
 15.
16. // Begin Serial communication at a baudrate of 9600:
17. Serial.begin(9600);
18. }
19.
20. void loop() {
21. // Clear the trigPin by setting it LOW:
22. digitalWrite(trigPin, LOW);
23.
24. delayMicroseconds(5);
25.
26. // Trigger the sensor by setting the trigPin high for 10
microseconds:
27. digitalWrite(trigPin, HIGH);
28. delayMicroseconds(10);
29. digitalWrite(trigPin, LOW);
30.
31. // Read the echoPin. pulseIn() returns the duration (length of
the pulse) in microseconds:
32. duration = pulseIn(echoPin, HIGH);
33.
34. // Calculate the distance:
35. distance = duration*0.034/2;
36.
37. // Print the distance on the Serial Monitor (Ctrl+Shift+M):
38. Serial.print("Distance = ");
39. Serial.print(distance);
40. Serial.println(" cm");
41.
42. delay(100);
43. }

You should see the following output in the serial monitor:

How the code works

First, the trigger pin and the echo pin are defined. I call them trigPin and
EchoPin . The trigger pin is connected to digital pin 2 and the echo pin to digital pin
3 on the Arduino.

The statement #define is used to give a name to a constant value. The compiler
will replace any references to this constant with the defined value when the the
program is compiled. So everywhere you mention trigPin , the compiler will
replace it with the value 2 when the program is compiled.

3. // Define Trig and Echo pin:

4. #define trigPin 2
5. #define echoPin 3

Next I defined two variables: duration and distance . Duration stores the time
between sending and receiving the sound waves. The distance variable is used to
store the calculated distance.

7. //Define variables
8. long duration;
9. int distance;

In the setup() , you start by setting the trigPin as an output and the echoPin as an
input. Next you initialize serial communication at a baud rate of 9600. Later you will
display the measured distance in the serial monitor, which can be accessed with
Ctrl+Shift+M or Tools > Serial Monitor. Make sure the baud rate is also set to 9600 in
the serial monitor.

11. void setup() {

12. // Define inputs and outputs
13. pinMode(trigPin, OUTPUT);
14. pinMode(echoPin, INPUT);
15.
16. // Begin Serial communication at a baudrate of 9600:
17. Serial.begin(9600);
18. }
In the loop() , you trigger the sensor by setting the trigPin HIGH for 20 µs. Note
that to get a clean signal you start by clearing the trigPin by setting it LOW for 5
microseconds.

20. void loop() {

21. // Clear the trigPin by setting it LOW:
22. digitalWrite(trigPin, LOW);
23.
24. delayMicroseconds(5);
25.
26. // Trigger the sensor by setting the trigPin high for 10
microseconds:
27. digitalWrite(trigPin, HIGH);
28. delayMicroseconds(10);
29. digitalWrite(trigPin, LOW);

Next, you need to read the length of the pulse sent by the echoPin. I use the function
pulseIn() for this. This function waits for the pin to go from LOW to HIGH, starts
timing, then waits for the pin to go LOW and stops timing.

After that you can calculate the distance by using the formula mentioned in the
introduction of this tutorial.

31. // Read the echoPin. pulseIn() returns the duration (length of

the pulse) in microseconds:
32. duration = pulseIn(echoPin, HIGH);
33.
34. // Calculate the distance:
35. distance = duration*0.034/2;

Finally, print the calculated distance in the serial monitor.

37. // Print the distance on the Serial Monitor (Ctrl+Shift+M):

38. Serial.print("Distance = ");
39. Serial.print(distance);
40. Serial.println(" cm");
41.
42. delay(100);
43. }
 
Hmmm...can’t reach this page
Try this

• Make sure you’ve got the right web

Example code JSN-SR04T with Arduino and NewPing

library
The NewPing library written by Tim Eckel can be used with many ultrasonic
distance sensors. The latest version of this library can be downloaded here on
bitbucket.org. (https://bitbucket.org/teckel12/arduino-new-ping/downloads/) You
might notice that the code below, which uses the NewPing library, is a lot shorter
than the code we used before.

NewPing_v1.9.1.zip
(https://www.makerguides.com/wp-
content/uploads/2019/02/NewPing_v1.9.1.zip)

You can install the library by going to Sketch > Include Library > Add .ZIP Library in
the Arduino IDE.

The library does include some examples that you can use, but you will have to
modify them to match your hardware setup. I have included a modified example
code below that can be used with the same wiring setup as before.

1. /*Arduino example sketch to control a JSN-SR04T ultrasonic distance

sensor with NewPing libary and Arduino. More info:
https://www.makerguides.com */
2.
3. // Include the library:
4. #include <NewPing.h>
5.
 6. // Define Trig and Echo pin:
7. #define trigPin 2
8. #define echoPin 3
9.
10. // Define maximum distance we want to ping for (in centimeters).
Maximum sensor distance is rated at 400-500 cm:
11. #define MAX_DISTANCE 400
12.
13. // NewPing setup of pins and maximum distance.
14. NewPing sonar = NewPing(trigPin, echoPin, MAX_DISTANCE);
15.
16. void setup() {
17. // Open the Serial Monitor at 9600 baudrate to see ping results:
18. Serial.begin(9600);
19. }
20.
21. void loop() {
22. // Wait 50ms between pings (about 20 pings/sec). 29ms should be
the shortest delay between pings:
23. delay(50);
24.
25. // Measure distance and print to the Serial Monitor:
26. Serial.print("Distance = ");
27. // Send ping, get distance in cm and print result (0 = outside
set distance range):
28. Serial.print(sonar.ping_cm());
29. Serial.println(" cm");
30. }

Conclusion
In this article I have shown you how the JSN-SR04T ultrasonic distance sensor
works and how you can use it with Arduino. I hope you found it useful and
informative. If you did, please share it with a friend that also likes electronics!
Personal project: About a year ago I was working on a waterlevel measuring station
for developing countries as part of a university project. We used one of these
sensors and modified it so it could be used in a narrow tube. You can read more
about it here on Hackaday (https://hackaday.io/project/21579-affordable-water-
level-measuring-station).

I would love to know what projects you plan on building (or have already built) with
this sensor. If you have any questions, suggestions or if you think that things are
missing in this tutorial, please leave a comment down below.

Note that comments are held for moderation in order to prevent spam.

This work is licensed under a Creative Commons Attribution-NonCommercial-

ShareAlike 4.0 International License (https://creativecommons.org/licenses/by-nc-
sa/4.0/).

 (https://twitter.com/intent/tweet?url=https://www.makerguides.com/jsn-

sr04t-arduino-tutorial/&text=&via=makerguides_com) 
(https://www.facebook.com/sharer/sharer.php?

u=https://www.makerguides.com/jsn-sr04t-arduino-tutorial/) 
(https://www.linkedin.com/shareArticle?
mini=true&url=https://www.makerguides.com/jsn-sr04t-arduino-tutorial/&title=)

 (http://pinterest.com/pin/create/button/?

url=https://www.makerguides.com/jsn-sr04t-arduino-tutorial/)

Beginner
Comments

Paul says
April 24, 2019 at 10:09 am (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-26)

Exelent arrival thanks for publishing.

I had not come across the ping library.

Reply

Gustavo says
May 13, 2019 at 3:54 am (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-44)

Is it possible to connect a 3 pin oem parking sensor on this board? Or are there an
other board to make that?

Reply

Benne de Bakker says

May 13, 2019 at 10:06 am (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-45)

Hi,

The sensor/ultrasonic transducer that connects to the control board only has two
wires/pins. If your oem parking sensor comes with it’s own pcb that creates the
signal, then you might be able to control it with an Arduino or other
microcontroller. I have written a small section about controlling 3 pin sensors
with the NewPing library in my tutorial about the HC-SR04 ultrasonic sensor:
https://www.makerguides.com/hc-sr04-arduino-tutorial/
(https://www.makerguides.com/hc-sr04-arduino-tutorial/).
 Benne

Reply

Alexey says
May 21, 2019 at 11:41 am (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-67)

Hello!
Tell me how to connect 2 sensors JSN-SR04T and how to write a sketch?

Reply

Benne de Bakker says

May 21, 2019 at 12:03 pm (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-68)

This can easily be done with the NewPing library. Just create two instances of
the NewPing class and add an additional trigger and echo pin:

#define trigPin 2
#define echoPin 3
#define trigPin2 4
#define echoPin2 5

NewPing sonar(trigPin, echoPin, MAX_DISTANCE);

NewPing sonar2(trigPin2, echoPin2, MAX_DISTANCE);

Now if you want to read the first sensor you can use sonar.ping_cm() and for the
second sensor sonar2.ping_cm().

Hope this helps.

Benne

Reply
Tommy says
June 4, 2019 at 9:04 am (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-83)

I’m a newb, so forgive me if this is a stupid question.

Why do you need a breadboard? Can’t you connect the 5V and GND from the JSN-
SR04T directly to the Arduino?

Reply

Benne de Bakker says

June 4, 2019 at 9:13 am (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-84)

Hi Tommy,

Good question. A breadboard is definitely not needed, so you can just wire
everything directly from the sensor to the Arduino. I just find a breadboard easy
to use when prototyping. If you only have male-male jumper wires, a breadboard
makes it easier to wire up the sensor without soldering. If you plan to build
something more permanent, I wouldn’t use a breadboard.

Greetings,

Benne

Reply

Andre du Toit says

June 6, 2019 at 6:08 am (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-89)
Hi Benne
Thanks for this tutorial, its very well explained for beginners like me!
I have a project where I want to keep the USsensor at a certain distance from the
ground, achieved through activating a 12v solinoid valve. Basicly 2 output pins on
the Arduino whould need to go high, one for sensor to low and the other for sensor
to high( which will activate relay switches for the higher current to solinoid). I have
not come across a tutorial or example coding for something of the kind. Any idea
where I can look?

And would it be possible to write code so the desired distance for the sensor is say,
within 10cm, to try and eliminate oscillation?
Regards
Andre

Reply

Benne de Bakker says

June 6, 2019 at 9:01 am (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-90)

Hi Andre,

You can probably just use an if else statement.

if (10 < sonar.ping_cm() < 20){ digitalWrite(solenoidPin1, HIGH): }else if (100 <
sonar.ping_cm() < 110){ digitalWrite(solenoidPin2, HIGH); }else { digitalWrite
(solenoidPin1, LOW); digitalWrite(solenoidPin2, LOW); }Something like this
maybe (note that I used a function from the NewPing library). I unfortunately
don't have time to write or debug code for you, so I hope this helps a
bit.Greetings,Benne

Reply

André du Toit says

June 9, 2019 at 10:01 am (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-96)
 Now worries , I don’t expect you to write me code. I’m actually excited to
figure it out myself (with the help of Google obviously ?). Every bit of
information helps me in the right direction, like if else! So thank you

Reply

Tim Vukman says

June 21, 2019 at 11:19 pm (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-132)

Thank you for the well presented tutorial. It is very helpful. Once I get my project
working, I will let you know what it is.

Reply

Marc says
June 25, 2019 at 12:19 pm (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-148)

Hi,
Great tuto it’s very clear thank you! But did you manage to make the function
ping_median of new ping work? I had HCSRO4 and this functions worked perfectly
but now it does not… My issue is that I have to get really precise measurements
(with millimeters) so with the HCRO4 I used 5 captors and I filtered the values but
now I can’t manage to get precise measurements without instability with the JSN
SRO4T V2.
Could you please help me? I feel like I tried everything…

Reply

Benne de Bakker says

June 26, 2019 at 7:52 pm (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-158)
Hi Marc,

I haven’t extensively tested the NewPing library with the V2 sensor board
myself, but I have read about similar problems before. It mostly has to do with
the length of the trigger pulse. For the HC-SR04 this can be slightly below 10us
but for the JSN-SR04T V2 it needs to be a bit longer. You can change this in the
library source code (sadly there is no other way). You have to change the file
NewPing.cpp around line 134. Change the delay time from 10us to around 13 or
more microseconds. Tim mentions in this post that you should also add ” #define
ONE_PIN_ENABLED false ” to your sketch. See this post:
https://bitbucket.org/teckel12/arduino-new-ping/issues/41/jsn-sr04t-20-needs-
to-have-longer-high (https://bitbucket.org/teckel12/arduino-new-
ping/issues/41/jsn-sr04t-20-needs-to-have-longer-high)

I am not 100% sure whether or not this solution always works, but I hope it fixes
your problem.

Benne

Reply
Scott Wilson says
June 26, 2019 at 7:16 pm (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-156)

In the Conclusion (above) you say “We used one of these sensors and modified it so
it could be used in a narrow tube.” In the link to Hackaday you provide I didn’t find
that information.

Am doing a similar thing in Mexico trying to monitor flood levels in streets, and
water levels in holding tanks. That pesky 45-70 degree “beam” of the ultrasonic
sensor creates problems. The modification to the sensor you mentioned to use a
narrow tube would be extremely beneficial. Thanks!

Reply

Benne de Bakker says

June 26, 2019 at 7:33 pm (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-157)

Hi Scott,

Thanks for the comment. The answer to your question is buried somewhere in
the project logs on Hackaday. What we did is create a 3d printed funnel/cone
that we mounted in front of the sensor. On the inside of the funnel we placed
some sound absorbing material (in this case we used felt). The funnel has
roughly 4 degree walls and combined with the sound absorbing material, we
could reduce the effective beam angle quite a bit. Basically, just part of the
‘beam’ is absorbed and only a small narrow part of it can exit the funnel.

I think there are some SolidWorks files on Hackaday, but you can quite easily
DIY something together. Hope this helps a bit.

Benne
 Reply

Scott Wilson says

July 1, 2019 at 9:19 pm (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-175)

Hi Benne! Thanks for the info. I do see a funnel thing in one of the Solidworks
files. Looks like its about 60mm long and shaped roughly 4 degrees. That
must be it. I will do up something like it in Sketchup and 3D print it to
experiment. Thanks so much!

Reply

edgardo u. villacorte says

July 10, 2019 at 9:11 am (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-226)

Your article provided very useful information for a planned disaster mitigation project
in my country. We have a lot of mining companies who have the so called mine
tailings dam whose water levels can rise to dangerously high levels during the rainy
season.. Several environmental catastrophes have occurred when the dammed
water breached the dikes. A simple water level monitoring instrument employing the
jsn-sr04t sensor with arduino and gsm modem will likely prevent such a disaster by
alerting the mining company’s personnel to open the sluice valves to relieve the
water pressure. We are currently in a discussion on how best to implement the
project.

Reply

Trackbacks

Test post | Makerguides.com (https://www.makerguides.com/tutorial-test-post/)

says:
June 16, 2019 at 10:00 am (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-110)
[…] Waterproof JSN-SR04T Ultrasonic Distance Sensor with Arduino Tutorial […]

How to use HC-SR04 Ultrasonic Sensor with Arduino (5 examples)

(https://www.makerguides.com/hc-sr04-arduino-tutorial/) says:
June 16, 2019 at 12:38 pm (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-111)
[…] Waterproof JSN-SR04T Ultrasonic Distance Sensor with Arduino Tutorial […]

How to use SHARP IR Distance Sensor with Arduino (GP2Y0A710K0F)

(https://www.makerguides.com/sharp-gp2y0a710k0f-ir-distance-sensor-
arduino-tutorial/) says:
June 20, 2019 at 5:34 pm (https://www.makerguides.com/jsn-sr04t-arduino-
tutorial/#comment-124)
[…] Waterproof JSN-SR04T Ultrasonic Distance Sensor with Arduino Tutorial […]

© 2019 Makerguides.com - All Rights Reserved