LiDAR Snow/Water Depth Sensor

Ultrasonic sensors have been successfully implemented at a large number of locations around the world and have been in use for quite some time but they do have some drawbacks that can be improved upon:

1. Sound waves spread out once the pulse is emitted and this means that the measurement footprint of these devices can be large, especially in high snowpack areas where they're mounted on arms far above the snowpack surface. The larger the measurement footprint, the more likely it is that something undesirable will be measured with the desired variable.

2. Precipitation particles can interfere with the signal and produce erroneous data. This is especially true during events with large snowflakes, such as aggregates, or during periods of increased precipitation rates.

LiDAR sensors, like the TF Luna that we'll be working with in this tutorial, work in a similar way to ultrasonic sensors but determines distance using the speed of light after emitting and receiving a laser pulse instead of sound waves for measurement of the surface. While no sensor is perfect, LiDAR based distance sensors can address the two above drawbacks as the laser footprint is substantially smaller than that of a sound pulse and that also means less interference from large precipitation particles. LiDAR and ultrasonic distance sensor components for Raspberry Pis are also relatively close in price, which can make the decision to incorporate a LiDAR sensor into a snow or water depth system easy.

LiDAR Use At The CSSL

We decided to incorporate a LiDAR sensor on the control system for the Sky-To-Stream automated adjustable-height arm discussed in the Obs System Controller tutorial. We already have plenty of snow depth sensors and regularly make manual measurements of snow depth as well, so we were more interested in planning a way for the LiDAR to automate our radiation and eddy covariance measurements by continually monitoring the arm's height above the snowpack rather than monitoring the overall snowpack depth. However, that doesn't change the application of this project or its usefulness for monitoring of snow and/or water depth. Additionally, these measurement systems can be incredibly inexpensive compared to traditional sensors. At the time of writing, the TF-Luna LiDAR Range Finder that we'll be using in this tutorial is $26 and a Raspberry Pi Zero for $18, which makes mass production of these tiny systems incredibly affordable if you're looking to measure many locations. 

Side note, I quoted the Raspberry Pi Zero above but we're using a Raspberry Pi 5, which is more expensive and has more features, in this tutorial. It's only because I have an extra Raspberry Pi 5 on hand that I'm using it here but the processing for this sensor is so miniscule that a small Raspberry Pi can easily be used.

Project Component List

This project is relatively straightforward as far as components goes, it really just boils down to supplies needed for the Raspberry Pi and the LiDAR. As always, we add a terminal block to the list because it's easier to use for our purposes than a breadboard. For this project, you will need these:

Setting Up The Raspberry Pi

Raspberry Pis are fully functional miniature computers that run on their own operating system, which is just a modified version of Linux. As with any computer, setup needs to be done with a monitor, keyboard, and mouse. Make sure you have a USB keyboard and mouse (not bluetooth) as you can plug them directly into the Raspberry Pi board. 

Now that we have our components ready, we're going to install the Raspberry Pi Operating System (OS). The easiest way to do this is using the Raspberry Pi Imager and instructions on how to install and use the imager can be found here. When using the imager, you'll select the version of Rasperry Pi that you have (we have version 5), the version of the Raspberry Pi OS that you'd like to use, and the storage device to put the operating system on. Make sure you select you micro-SD card when choosing the storage device and not a local drive for your computer.

Once the OS is on your micro-SD card, insert the card into the slot on the Raspberry Pi, attach your keyboard, mouse, and monitor, and plug in your USB-C power supply to it. It will start up and then will take you through the setup steps using the connected monitor.

Enabling Serial Communication

Our TF Luna LiDAR will use serial communication to transmit data to our Raspberry Pi and, as such, we need to enable serial communication on our Raspberry Pi. The easiest way that I've found to do this is using the Terminal on the Raspberry Pi.

First, we need to edit the config.txt file in the /boot/firmware/ directory by typing this command:

sudo vi /boot/firmware/config.txt

Add these entries to the bottom of the config file if they're not there already

[all]

dtparam=uart0=on

enable_uart=1

Then we'll reboot our Raspberry Pi to have these settings take effect and it should be ready for serial communication.

Code

Starting with a good base

We based our code on that script developed by Joshua Hrisko on the Maker Portal Distance Detection with the TF-Luna LiDAR and Raspberry Pi tutorial with a couple of changes to make it suit our purpose of measuring snow (or water) depth:

1. We added a time component to align observations with the top of each minute.

2. Defining a mounting height was necessary as we're not measuring a distance away from the sensor but, instead, depth of a medium.

Opening a blank file

I like to use VIM to edit scripts but you can use any editing program or IDE that you would like to use to create the script. There are several built in code editors on Raspberry Pi 5, such as Thonny, that can also be used. For this new script, regardless of editing program, we're going to call it lidarMeasurement.py.

Python environment designation and code information

The very first line of our script is known as the shebang line, which tells Unix which interpreter to use to execute the script. As we're working in python, our shebang line will look like this: 

#!/usr/bin/env python

It's always good practice to give information about the program, instrument used, author, and anything else pertinent in the comments at the top of the python script. This ensures that others that may use your script know what it's for but can also serve as a reminder if it has been a while since you've used it and have forgotten some of the information. We also like including wiring information because this can be helpful in the future. Here, you can see the top of our script:

# Author(s): Andrew Schwartz (email); Marianne Cowherd (email); Mia Jones (email)

# Program info: In this program, a lidar distance sensor is used to determine the height of the snowpack

# Wiring: 

#   TF Luna Power -- Raspberry Pi 5V

#   TF Luna Ground -- Raspberry Pi Ground

#   TF Luna RXD/SDA -- Raspberry Pi Tx (GPIO 14)

#   TF Luna TXD/SCL -- Raspberry Pi Rx (GPIO 15)

Next, we're going to import some packages to help us keep track of time and output time in our data file (timedelta and datetime from datetime; time), allow the script to interact with the Raspberry Pi's operating system (os), allow serial communication wit the LiDAR (serial, time), and give us the ability to do some quick calculations (math). 

import os

from datetime import datetime, timedelta

import serial,time

import math

Defining our variables for data collection

Here we define the number of measurements that we want the LiDAR to make so that we can obtain an average for the depth measurement (N_MEAS). We selected 5 becasue the TF Luna sensor has relatively high precision and we didn't feel like we needed more. A quick note: this system operates at 10 Hz (10 measurements per second), which means 10 is the maximum number of measurements before the measurement process begins affecting the file output times with lag but any number of measurements is possible. 

In this section we also define how often we want our measurements made in minutes (MEAS_FREQ), which for us was 1 minute observations as we're interested in snowfall and snow accumulation rates but this can easily be made less frequent for monitoring similar to the SNOTEL network, which occurs once per hour. 

Finally, we define the height of our sensor above the soil surface, which gives the script a frame of reference for our snow depth measurements. As we were testing this system inside before putting it outside, our height was 142.890 cm.

N_MEAS = 5 #How many LiDAR range measurements we want averaged to get our snow depth measurement

MEAS_FREQ = 1 #Time, in minutes, of how often we want measurements

SENSOR_HEIGHT = 142.890 #Height of the sensor above the surface (in cm)

Telling the Raspberry Pi that we plan on using serial communication

Our TF Luna LiDAR uses serial communication and, as such, we need to tell the Raspberry Pi which serial port to use ("/dev/serial0"), our baud rate (115200), and timeout length (timeout = 0). If you'd like to explore serial communication and how it works, here's a helpful video that goes into some of the specifics.

# Serial comms with LIDAR

ser = serial.Serial("/dev/serial0", 115200,timeout=0) # mini UART serial device

Setting the measurement interval

As we want a five minute temporal resolution using UTC time for our data collection (generally preferable to using local time when collecting data), we're going to get our most recent time that was a multiple of 5. This can be changed to give any resolution you would like. If you're using a tipping bucket to examine extreme rainfall events, it would be worth it to use one minute observations. If you're just interested in precipitation accumulation totals, hourly or daily data may be enough.

# Bootstrap by getting the most recent time that had minutes as a defined multiple of the MEAS_FREQ value

time_now = datetime.utcnow()  # Or .now() for local time

prev_minute = time_now.minute - (time_now.minute % MEAS_FREQ)

time_rounded = time_now.replace(minute=prev_minute, second=0, microsecond=0)

Defining how to get the LiDAR data and our averaging function

Below you can see how we defined the getLidarData() function, which will tell the Raspberry Pi how to get object distance data from the TF Luna sensor. We are primarily interested in snow depth, so we commented out other variables that can be obtained from the TF Luna, such as strength of signal and temperature but those can be added again if you're interested in using them.

Second, we define the get_mean() function, which, as the name implies, will be used to get the mean of the distance values that we collect.

def getLidarData():

    distance = None

    #strength = None

    #temperature = None

    counter = ser.in_waiting # count the number of bytes of the serial port

    if counter > 8:

        bytes_serial = ser.read(9) # read 9 bytes

        ser.reset_input_buffer() # reset buffer

        if bytes_serial[0] == 0x59 and bytes_serial[1] == 0x59: # check first two bytes

            distance = bytes_serial[2] + bytes_serial[3]*256 # distance in next two bytes

            # strength = bytes_serial[4] + bytes_serial[5]*256 # signal strength in next two bytes

            # temperature = bytes_serial[6] + bytes_serial[7]*256 # temp in next two bytes

            # temperature = (temperature/8.0) - 256.0 # temp scaling and offset

    return distance #,strength,temperature

def get_mean(values):

    return(sum(values)/len(values))

Now we want to use all of the above information to actually make and record the measurements

In our while True loop:

1. First we want to wait until the next time interval to start the measurements.

2. We then want to check whether the lidarDepth.csv file exists and open it to append it. If it doesn't exist, we want to create it.

3. Next we want to get the measured distances (dists) from the LiDAR.

4. We then take those distances, get the mean, and calculate the snow (or water) distance.

5. We get the current time and write the time and depth to the file.

6. Finally, the script loops back to do the same thing until it is stopped.

while True:

    # Wait until next interval minute

    time_rounded += timedelta(minutes=MEAS_FREQ)

    time_to_wait = (time_rounded - datetime.utcnow()).total_seconds()

    time.sleep(time_to_wait)

    # Check if the file exists before opening it in 'a' mode (append mode)

    file_exists = os.path.isfile('lidarDepth.csv')

    file = open('lidarDepth.csv', 'a')

    if not file_exists:

        file.write('Time (UTC), Snow Depth (cm)\n')

    dists = []

    count = 0

    while count < N_MEAS:

    ## run the lidar on 0.1 second delay until you have N_MEAS measurements

        dists.append(getLidarData())

        count +=1

        time.sleep(0.1)

    distance = get_mean(dists)

    snow_depth = abs(distance - SENSOR_HEIGHT)

    # Get current time

    timestamp_tz = datetime.utcnow()

    file.write(timestamp_tz.strftime('%Y-%m-%d %H:%M:%S') + ', {:.3f}'.format(snow_depth) +'\n')

When we put all of that code together, it will look like this

Here we have the completed script that can be executed by python to find and log our snow or water depth measurements. 

#!/usr/bin/env python

# Author(s): Andrew Schwartz (email); Marianne Cowherd (email); Mia Jones (email)

# Program info: In this program, a lidar distance sensor is used to determine the height of the snowpack

# Wiring: 

#   TF Luna Power -- Raspberry Pi 5V

#   TF Luna Ground -- Raspberry Pi Ground

#   TF Luna RXD/SDA -- Raspberry Pi Tx (GPIO 14)

#   TF Luna TXD/SCL -- Raspberry Pi Rx (GPIO 15)

import os

from datetime import datetime, timedelta

import serial,time

import math

N_MEAS = 5 #How many LiDAR range measurements we want averaged to get our snow depth measurement

MEAS_FREQ = 1 #Time, in minutes, of how often we want measurements

SENSOR_HEIGHT = 142.890 #Height of the sensor above the surface

# Serial comms with LIDAR

ser = serial.Serial("/dev/serial0", 115200,timeout=0) # mini UART serial device

# Bootstrap by getting the most recent time that had minutes as a defined multiple

time_now = datetime.utcnow()  # Or .now() for local time

prev_minute = time_now.minute - (time_now.minute % MEAS_FREQ)

time_rounded = time_now.replace(minute=prev_minute, second=0, microsecond=0)

def getLidarData():

    distance = None

    #strength = None

    #temperature = None

    counter = ser.in_waiting # count the number of bytes of the serial port

    if counter > 8:

        bytes_serial = ser.read(9) # read 9 bytes

        ser.reset_input_buffer() # reset buffer

        if bytes_serial[0] == 0x59 and bytes_serial[1] == 0x59: # check first two bytes

            distance = bytes_serial[2] + bytes_serial[3]*256 # distance in next two bytes

            # strength = bytes_serial[4] + bytes_serial[5]*256 # signal strength in next two bytes

            # temperature = bytes_serial[6] + bytes_serial[7]*256 # temp in next two bytes

            # temperature = (temperature/8.0) - 256.0 # temp scaling and offset

    return distance #,strength,temperature

def get_mean(values):

    return(sum(values)/len(values))

while True:

    # Wait until next interval minute

    time_rounded += timedelta(minutes=MEAS_FREQ)

    time_to_wait = (time_rounded - datetime.utcnow()).total_seconds()

    time.sleep(time_to_wait)

    # Check if the file exists before opening it in 'a' mode (append mode)

    file_exists = os.path.isfile('lidarDepth.csv')

    file = open('lidarDepth.csv', 'a')

    if not file_exists:

        file.write('Time (UTC), Snow Depth (cm)\n')

    dists = []

    count = 0

    while count < N_MEAS:

    ## run the lidar on 0.1 second delay until you have N_MEAS measurements

        dists.append(getLidarData())

        count +=1

        time.sleep(0.1)

    distance = get_mean(dists)

    snow_depth = abs(distance - SENSOR_HEIGHT)

    # Get current time

    timestamp_tz = datetime.utcnow()

    file.write(timestamp_tz.strftime('%Y-%m-%d %H:%M:%S') + ', {:.3f}'.format(snow_depth) +'\n')

It's always a good idea to save scripts as you make progress on them but, in case you haven't done so yet, save the script and get ready to test it.

Running your script to collect data

This is easiest done on the command line on your Raspberry Pi and is as simple as calling python to execute the script:

python3 lidarMeasurement.py

As the script runs, you should initially see a new .csv created (lidarDepth.csv) and see values being added to the file at the measurement interval that you selected.

Often, it's better to run a process in the background so other tasks can be undertaken on the command line. To do this, we can add an ampersand to the end of the command:

python3 lidarMeasurement.py &

Ensuring The Program Runs On Start-Up

One of the easiest ways to ensure your program runs if there has been a power outage or the device needs to be rebooted is through Cronjobs. We covered using Cronjobs for ensuring the program starts up when the Raspberry Pi reboots in the Tipping Bucket Datalogger Tutorial, so we won't go over it again here but the process is identical for the two scripts and can be implemented from that tutorial.

You Now Have A Cheap, Accurate, and Easily Deployable LiDAR Depth Sensor!

Thank you for working through this tutorial with us! We do have a couple of notes for you:

1. The TF Luna sensor is not waterproof but we've gotten around this at the CSSL by using waterproof junction boxes such as these with the LiDAR mounted on the bottom of the box and some caulking applied around the outside of the TF Luna.

2. This tutorial will have the data stored on the micro-SD attached to the Raspberry Pi but there are other communication options such as bluetooth and ethernet.

If you have feedback or suggestions on how on this tutorial or how we can improve it, please feel free to reach out to us!