Finding the perfect spot in your yard for a new plant can be tricky. Does a nursery tag's "partial shade" mean harsh morning sun, or dappled light all day? Instead of guessing and risking your new greenery, you can build a simple, battery-powered data logger to measure the exact light levels (lux) in any spot in your garden over time.

By combining an Adafruit ESP32-S2 Feather with a highly accurate VEML7700 Lux sensor and a LiPo battery, you can track the sun's path and intensity throughout the day. To keep it weather-resistant outside without firing up a 3D printer or buying a specialized enclosure, the whole setup slips perfectly into a standard clear Rubbermaid food storage container straight from your kitchen.

Using Adafruit IO and a bit of code to manage power, this guide will show you how to log environmental data straight to the cloud. Best of all, there's zero soldering required thanks to the plug-and-play STEMMA QT system.

Using AI to help you pick the right plant (optional)

Once you’ve logged a few days or weeks of sunlight data, Adafruit IO allows you to easily export your history as a simple CSV file. You can then take this raw data and feed it into your favorite AI to act as a virtual master gardener. Just provide your downloaded light readings alongside your specific USDA hardiness zone (like my chilly Zone 4 or 5). The AI can analyze the exact peak sun hours and lux intensity of your garden's microclimate to generate a list of vegetables or perennials that would grow well in that exact spot.

How it works

This project relies on the power of Adafruit IO to log your garden's ambient light data, and custom code to keep your hardware running as efficiently as possible. The ESP32-S2 Feather wakes up at a set interval, connects to your home WiFi, reads the light levels from the VEML7700 sensor over a simple STEMMA QT cable, and sends that data directly to an Adafruit IO Dashboard before going back to sleep.

Placed in its clear, water-resistant Rubbermaid housing, it can safely sit in the dirt among your garden beds. You can then log into Adafruit IO to view a beautiful, continuous graph of your yard's sunlight over days or weeks, making it perfectly clear whether that corner is meant for sun-loving tomatoes or shade-tolerant hostas.

Deep Sleep?

When running a project on battery power outdoors, energy efficiency is critical. If the microcontroller and WiFi radio run continuously, a standard LiPo battery would drain in a matter of hours. By writing code that utilizes CircuitPython's deep sleep mode, the board essentially powers down between readings. It only wakes up for a few seconds to take a lux measurement and transmit it via WiFi. This software trick extends your battery life from hours to weeks, giving you long-term environmental data without constant recharging.

Parts

Either of the below batteries will work. Because we put this device into deep sleep, it really doesn't consume that much power. If you are doing a shorter test you can get away with an even smaller capacity battery.

Upload the code and libraries to your ESP32-S2 Feather

After downloading the Project Bundle, plug your ESP32-S2 Feather into the computer's USB port with a known good USB data+power cable. You should see a new flash drive appear in the computer's File Explorer or Finder (depending on your operating system) called CIRCUITPY. Unzip the folder and copy the following items to the ESP32-S2 Feather's CIRCUITPY drive. 

• lib folder
• code.py

Your ESP32-S2 Feather CIRCUITPY drive should look like this after copying the lib folder and the code.py file.

Add Your settings.toml File

As of CircuitPython 8, there is support for Environment Variables. These Environmental Variables are stored in a settings.toml file. Similar to secrets.py, the settings.toml file separates your sensitive information from your main code.py file. Add your settings.toml file as described in the Create Your settings.toml File page earlier in this guide. You'll need to include your CIRCUITPY_WIFI_SSID, CIRCUITPY_WIFI_PASSWORD, aio_username and aio_key in the file.

Understanding the Code

At first glance, connecting to WiFi and beaming sensor data to the cloud might sound a bit intimidating, but CircuitPython makes it incredibly straightforward!

The code for the light logger follows a simple, repeatable routine:

1. The microcontroller wakes up
2. Grabs the current ambient light reading from the VEML7700 sensor
3. Connects to your local network to push that data to your Adafruit IO dashboard
4. Immediately goes into a deep sleep to conserve battery life

The sections below break down exactly what is happening in each section so you can see how all the pieces fit together.

1. Importing Libraries

What this does: Microcontrollers don't know how to do everything right out of the box. The import statements tell the board to load specific "instruction manuals" (libraries) so it knows how to talk to your hardware and the internet.

• board, time, and alarm handle the physical pins on the board, time delays, and the deep-sleep functionality.

• wifi, adafruit_connection_manager, adafruit_requests, and IO_HTTP give your board the ability to connect to your local Wi-Fi and send data securely to the Adafruit IO servers.

• adafruit_veml7700 contains the specific instructions for reading the light sensor.

• getenv allows your code to securely read the WiFi passwords and API keys you stored in your settings.toml file.

2. User Settings

What this does: a couple of variables are defined up top so they are easy to find and change without having to dig through the rest of the code.

• SLEEP_INTERVAL tells the board how long to snooze between readings to save battery.

• FEED_NAME is the exact name of the digital "bucket" on Adafruit IO where you want to send your light data.

3. Hardware Setup

What this does: Before starting to taking measurements, you have to introduce the sensor to the microcontroller.

• board.I2C() sets up the communication pipeline (the STEMMA QT cable) between the Feather and the sensor.

• veml = adafruit_veml7700.VEML7700(i2c) creates a code object representing your physical sensor.

• A tiny half-second delay (time.sleep(0.5)) is added to give the sensor a moment to wake up and take its very first light reading before we ask for the data.

4. The Main Loop & Reading Data

What this does:

• while True: creates an infinite loop. Everything indented under this line will run over and over again.

• try: is the start of our error handling. We are telling the board, "Try to do the following steps, but if something goes wrong (like the WiFi dropping), don't completely crash."

• lux = veml.lux is where the magic happens! We ask the sensor for the current ambient light level and store it in a variable called lux. We then print it out to the Serial console so you can see it working on your computer.

5. Connecting to Wi-Fi & Adafruit IO

What this does: This chunk gets your data onto the internet.

• First, it checks if you are already connected to WiFi. If not, it uses the credentials from your settings.toml file to log into your router.

• Next, it sets up a pool and ssl_context. Think of this as opening a secure browser window so your board can talk to websites safely.

• Then, it logs into your specific Adafruit IO account using your username and secret key.

• Finally, io.send_data(FEED_NAME, lux) packages up your light reading and beams it directly into your Adafruit IO dashboard!

6. Error Catching & Deep Sleep

What this does:

• except Exception as e: pairs with the try: from earlier. If the Wi-Fi disconnects or Adafruit IO is unreachable, it simply prints the error to the console instead of freezing the board.

• To make this project run for a long time on a battery, we use Deep Sleep. We set a time_alarm for 5 minutes (our 300-second interval).

• alarm.exit_and_deep_sleep_until_alarms shuts down almost the entire microcontroller to sip the absolute minimum amount of power.

• When the 5 minutes are up, the board wakes up. If it's running on battery, waking from deep sleep acts like pressing the reset button: the code starts entirely over from line 1. (Note: If your board is plugged into your computer via USB, it skips the deep sleep and just waits 5 minutes before looping, so you don't lose your serial connection!).

Wiring Connections

• Plug the VEML7700 STEMMA QT Port to the Feather ESP32-S2's STEMMA QT port with a STEMMA QT cable
• LiPoly battery to the Feather ESP32-S3's LiPoly battery connector

Assembling Your Sun Tracker

You don't need to do anything fancy to get this project up and running. If you're in a hurry, you can simply toss the components into a clear, waterproof container and place it in your garden wherever you want to track light.

However, if you want to take a few extra minutes to secure your electronics, the Adafruit Swirly mounting system is a great option. It lets you cleanly screw down almost any Adafruit board or microcontroller. All you need is a Swirly board and a few plastic M2.5 mounting screws.

Learn more about the Adafruit Swirly grid system here.

If you have everything set up right, your new sun tracker should slowly start uploading data to Adafruit IO under the feed name 'ambient-light'.

Log into https://io.adafruit.com/ and click on feeds, you should see this new feed in your My Feeds list. You can view the data by clicking the ambient-light feed name.

Interpreting Your Light Data

Once your sun tracker has been running for a few days, you’ll have a clear picture of the "light profile" for that specific spot. While the raw numbers are interesting, the goal is to translate those peaks and valleys into a plant-friendly plan.

Understanding the Graph

The graph displays Light Intensity on the vertical axis and Time on the horizontal axis.

• The Peaks: Each peak represents the brightest part of the day. A tall, wide peak indicates a long stretch of direct, intense sunlight.

• The Valleys: These show when the area is in shadow, whether from a building, a tree, or simply because the sun has set.

• Consistency: Look for patterns over 3 to 5 days. A single sunny day is great, but seeing how clouds or shifting shadows affect the spot over a week gives you a more reliable average.

Matching Data to Plant Needs

Most plants come with a tag categorized by "Sun Requirements." Here is how to manually calculate which category your spot falls into based on your Adafruit IO data:

Light Category: Full Sun

• Direct Sun Exposure (Daily): 6+ Hours

• What to look for on your graph: A wide, high plateau of high-intensity values that lasts for the majority of the day.

Light Category: Partial Sun / Shade

• Direct Sun Exposure (Daily): 3 to 6 Hours

• What to look for on your graph: A narrower peak, or several smaller peaks if the spot gets "dappled" light through trees.

Light Category: Full Shade

• Direct Sun Exposure (Daily): Less than 3 Hours

• What to look for on your graph: Very low intensity values all day, or only one very brief spike of direct light.

How to Pick Your Plant

1. Now that you have your light data, it’s time to cross-reference it with your "Hardiness Zone." Sunlight tells you if a plant will eat, but your climate zone tells you if it will survive.

   1. Count the "High" Hours: Look at your graph and count how many hours the light stays above a "direct sun" threshold.

      • 6+ Hours: Full Sun (Peppers, Tomatoes, Zinnias).

      • 3 to 6 Hours: Partial Sun/Shade (Root veggies, Herbs, Hydrangeas).

      • less than 3 Hours: Shade (Hostas, Ferns, Moss).

   2. Identify Your USDA Hardiness Zone: Before buying, look up your zip code on the USDA Plant Hardiness Zone Map.

      • This number (e.g., Zone 4 here in Minneapolis) tells you the lowest temperature your area typically reaches in winter.

      • If you find a "Full Sun" plant that is only hardy to Zone 9, it will love your sunny deck in the summer, but it won't survive the winter outdoors. You'll need to treat it as an "annual" or bring it inside.

   3. Check for "Peak Heat" (10 AM to 4 PM): The intensity of the light matters as much as the duration.

      • Northern Climates (Zones 3-5): Morning sun is gentle. You often need those peak afternoon hours to get enough heat for "heat-loving" plants like peppers.

      • Southern Climates (Zones 8-11): Peak afternoon sun can actually be too intense. If your graph shows a massive spike at 2:00 PM in Arizona, you might actually need a "Partial Shade" plant to prevent scorching.

   4. The Perfect Match: Your sun data matches the plant tag (e.g., 6+ hours) AND the plant is rated for your Hardiness Zone.

      • The "Summer Guest": The sun data matches, but the plant isn't hardy to your zone. Great for a seasonal pot, but don't plant it in the ground!

      • The "Reach" Plant: If you have 5 hours of sun but the plant wants 6, try a "Partial Sun" variety instead of forcing a "Full Sun" variety to struggle.

While looking at a graph is great for a quick check, your sun tracker likely collected hundreds of data points. Instead of manually counting hours, you can use Gemini to analyze the "shape" of your data and cross-reference it with your specific climate.

Step 1: Exporting Your Feed Data from Adafruit IO

First, to get the raw data out of the cloud and onto your computer.

1. Navigate to your Feeds page on Adafruit IO.

2. Select the feed you’ve been using for your sun tracker (e.g., ambient-light).

3. Right below the graph, you will see a big blue Download All Data button.

4. Click Download All Data. Then in the popup, choose the Download as CSV button. Wait a minute, then click the 'Click to Refresh' link and you should see a 'Link' show up on the left of the request.

Step 2: Quick Cleanup

AI works best when the data is "clean." Before we hand this over to Gemini, let's tidy it up.

1. Open your favorite spreadsheet app (like Google Sheets) and go to File > Import > Upload to open your CSV.

2. You’ll see columns for value, created_at, and potentially some metadata.

3. Delete any columns that aren't the light value or the timestamp.

4. Filter for a "Good" couple of days. If you had a week of rain, that data isn't useful for finding "Full Sun" spots. Find a 24–48 hour window that was clear and sunny, and copy those rows into a new sheet.

5. Download as PDF or CSV that we can have an AI read.

Step 3: Let Gemini Interpret the Data

Now for the fun part. Give AI your data and your location (Hardiness Zone) so it can act as your personal botanist.

The Prompt

Upload your file to your AI of choice, then use a prompt similar to this:

"I am attaching a CSV of light intensity data collected by my sun tracker over the last 48 hours. I live in USDA Hardiness Zone 4.

Please analyze this data and:

1. Calculate the total number of 'High Intensity' sun hours per day.

2. Determine if this spot is Full Sun, Partial Sun, or Shade.

3. Recommend 5 plants (a mix of vegetables, herbs, and flowers) that would thrive in this specific light profile AND survive in Zone 4."

Step 4: The Response

I used Gemini to interpret my few days of data and here is what it came up with for me:

Based on the light measurements provided and the climate of Minneapolis, MN (USDA Hardiness Zone 4b), here is an analysis of your garden spot and recommendations for what will grow best there.

Light Analysis

The data indicates that this spot receives Partial Sun to Partial Shade.

• Intensity: The light levels peak between 10:00 AM and 3:00 PM (Central Time), with average values around 14,000 lux and maximum peaks reaching over 31,000 lux on sunny days.

• Duration: You are getting approximately 4 to 6 hours of significant light (above 10,000 lux) per day. This is ideal for plants that prefer "Part Sun" or "Part Shade"—they need some direct sunlight to thrive but may struggle or wilt in the intense, all-day heat of a full-sun exposure.

Recommended Plants for Minneapolis (Zone 4b)

Since Minneapolis has very cold winters, you need "hardy" plants that can survive temperatures down to -25°F.

1. Perennials (Flowers that come back every year)

• Hostas: These are the gold standard for partial shade in Minnesota. They come in hundreds of varieties and colors.

• Astilbe: These produce beautiful, plume-like flowers in summer and thrive in the 4–6 hour light window, especially if the soil stays moist.

• Bleeding Heart (Lamprocapnos spectabilis): A classic spring-blooming perennial that loves partial shade.

• Coral Bells (Heuchera): Grown primarily for their stunning foliage (purple, lime, silver, or red), they do very well in partial sun.

• Daylilies (Hemerocallis): Extremely hardy in Zone 4. While they love sun, many varieties will bloom well with 5–6 hours of light.

• Bee Balm (Monarda): Look for mildew-resistant varieties; they attract pollinators and handle partial sun well.

2. Shrubs

• Annabelle Hydrangea (Hydrangea arborescens): These are very hardy in Minnesota and produce massive white flower heads in partial shade.

• Serviceberry (Amelanchier): A native shrub/small tree that offers white spring flowers, edible berries, and great fall color.

• Dogwood (Cornus sericea): Specifically the Red-Osier Dogwood, which provides beautiful red stems in the winter.

3. Edibles

• Leafy Greens: Lettuce, spinach, kale, and Swiss chard actually prefer partial shade in the heat of a Minneapolis summer, as it prevents them from "bolting" (going to seed) too early.

• Herbs: Mint, chives, and cilantro will grow very well in this light profile.

• Root Vegetables: Carrots and beets can tolerate partial sun, though they may grow slightly slower than in full sun.