Green Guardian - An IoT Solution for Plant Care

Recent Updates

June 10, 2024: Second testbed ended

June 5, 2024: Second testbed started

June 5, 2024: Green Guardian presented

May 25, 2024: First testbed done, finetuning for Green Guardian macros.

May 23, 2024: First testbed set up, data collection started.

May 22, 2024: First prototype assembeled - All sensors and actuators functional.

May 19, 2024: Energy harvesting circuit added to prototype, test successful.

May 17, 2024: Code update for Wifi connection to Arduino, time synchronization, and entering low power mode.

May 13, 2024: Code update for reading sensor data of water level of actuator.

May 12, 2024: Code update for reading sensor data (Temperature, Humidity, Ambient Light, Soil Moisture).

May 8, 2024: Problem definition, product survey insights and technical approach added. Temperature and humidity sensor calibrated. Initial design of algorithms.

April 24, 2024: Updated timeline and milestones. Created related work section.

April 20, 2024: Created product interest survey, please answer here!

Green Guardian Presentation and Demo

Milestones

Timeline

Week 1: Project kickoff, initial research, and component ordering are scheduled.

Week 2: Start of hardware assembly and basic software setup.

Week 4: Completion of the prototype assembly.

Week 5: Begin functional testing and iterate based on initial results.

Week 6: Development of the user interface and integration testing.

Week 7: Final testing, project documentation, and preparation for the demonstration.

Abstract

The Green Guardian project aims to address economic and environmental losses in the houseplant industry due to neglect. This IoT device simplifies plant care with near-autonomous soil moisture management and an integrated watering system. It monitors key variables (light, soil moisture, humidity, temperature), adjusts watering schedules, and indicates optimal plant placement. Powered by an energy-harvesting system, Green Guardian minimizes environmental impact and operates independently of external power sources.

Problem Definition

In the United States alone, consumers spend approximately billions annually on houseplants and related accessories [2]. Despite this investment, around half of these plants die prematurely due to neglect and improper care [1]. This not only results in financial losses but also contributes to environmental waste, as valuable resources such as water, soil, and plant materials are squandered. The primary issues include a lack of proper plant care knowledge, as many plant owners lack the necessary expertise to maintain optimal conditions for their houseplants, leading to overwatering, underwatering, insufficient light, and poor environmental conditions. Additionally, busy lifestyles often prevent individuals from dedicating the necessary time and attention to their plants, resulting in neglect and inconsistent care routines. Improper care practices also lead to the wasteful use of resources such as water and fertilizers, which has broader environmental implications. Furthermore, the premature death of plants results in discarded plant material, contributing to landfill waste and the unnecessary consumption of resources used in plant production and distribution.

Motivation

The motivation behind the Green Guardian project stems from the desire to address the significant economic and environmental issues associated with houseplant care. Americans spend approximately billions annually on houseplants [2], yet around half of these plants die prematurely due to neglect and improper care [1]. This not only results in financial losses but also leads to environmental waste, as resources such as water, soil, and plant materials are squandered.

Green Guardian aims to mitigate these issues by providing an IoT-based solution that automates plant care, ensuring optimal conditions for plant health with minimal human intervention. The project seeks to reduce plant mortality, promote sustainable practices, and enhance the overall experience of plant ownership by using an edge system capable of sensing, decision-making, and actuating. Additionally, we aim to collect data on individual plants to address the current lack of detailed plant care information, which could be highly beneficial for advancements in the agricultural and environmental fields.

Product Survey

A survey was conducted with 119 participants to gauge potential user interest in the Green Guardian. Questions aimed to assess how often individuals interact with their plants and their interest in a self-sustaining plant care system.

The survey results for the Green Guardian product reveal promising insights into the market's readiness and potential interest in an autonomous plant care solution. A majority of respondents interact with their plants frequently (daily or several times a week), indicating an existing commitment to plant care that the Green Guardian could support and enhance. Additionally, a significant number of respondents reported having plants that died prematurely, suggesting a prevalent challenge in maintaining plant health that the Green Guardian aims to address. Importantly, the strong inclination towards a self-contained watering system, with a substantial majority expressing interest, underscores the demand for such innovative solutions. This interest, coupled with respondents' willingness to invest in the price range of $20 to $60, positions the Green Guardian as a viable product in the houseplant care market.

Survey response chart1 Survey response chart2 Survey response chart3 Survey response chart4 Survey response chart5 Survey response chart6

System Design

The components and design used for this project focused on its constraints and requirements: energy efficiency, plant care through sensing, decision-making, and actuation, and minimal user intervention.

System Architecture and Component Specification

The system, as seen in Fig. 1, is divided into four units: control, sensing, power management, and actuation. All of the hardware used for this project was over-the-counter and specified in the Components Used in the Project

The control unit is centered around the Arduino UNO R4 WiFi [ABX00087], featuring the Renesas RA4M1 and ESP32-S3 for Wi-Fi and Bluetooth connectivity. This microcontroller was chosen for its robust performance, ease of use, extensive community support, network support, affordability, pins, and peripheral compatibility. Additionally, we chose this Arduino model for its integrated LED matrix, which can serve as a notification system for the user.

The sensing unit is made up of four sensors that allow measurement of five essential variables for plant care: soil moisture, environment temperature, air humidity, light exposure, and remaining water in storage. We chose these because "environmental factors that affect plant growth include light, temperature, water, humidity, and nutrition" [3]. Measuring soil nutrition is still unaffordable and complex, so we based our model on the other factors. The sensors we used were the lowest consuming and most affordable ones available in our market.

The power management unit is composed of a solar controller, a battery, and a solar cell. We deemed solar energy as the most effective energy harvesting method given the environmental factors needed for plants to thrive and its ample energy collection ability. The 3.7V 1000mAh LiPo battery provides reliable energy storage, ensuring continuous operation during low-light conditions.

Finally, the actuation unit is composed of a standard servo. The servo is connected to a valve that enables drip irrigation. We chose this irrigation system for two reasons. First, it takes advantage of the potential energy from storing water above the plants, allowing gravity to assist in water delivery. Second, drip irrigation is 90% efficient in allowing plants to use the applied water, and it reduces runoff and evaporation [4], making this system highly suitable for our requirements.

Implementation Diagram
Fig. 1: System architecture diagram

Sensor Calibration

To ensure our decision-making model had accurate data input, and given that the sensors involved in this project could compromise accuracy for affordability, sensor calibration was necessary for all of them.

The moisture sensor is capacitive, returning arbitrary values that only had relative meaning in the context of the data points it collected. Because of this, we had to create a function to map these arbitrary values to soil moisture content percentages. To achieve this, we dried the soil in an oven until it reached a consistent weight, indicating minimal levels of moisture, which allowed us to measure 0% soil moisture. After this, we determined the field capacity (100% moisture content) by thoroughly watering the soil sample until it was completely saturated and then letting it drain until consistent. You can see both of these samples in Fig. 2. With these capacitive thresholds, we were able to map arbitrary values to actual moisture percentages

The rest of the sensors returned their values in International System units, so the only calibration needed was accuracy-based. Our approach for them was to use one-point calibration. For example, we had to add an offset to our humidity and temperature sensor values as they were inconsistent with other local, more accurate sensors.

Soil Moisture Calibration Samples
Fig. 2: Soil at 0% and 100% soil moisture content

Energy Profiling

We need to understand how much the setup consumes to make decisions regarding energy management, sleep time, and sensing time. For this, we used a Direct Voltage supply to measure the current drawn during 5V supply by our device in different states. The measurements are as follows:

  • In low power mode, current drawn is 140 mA.
  • In active mode, current drawn is 160 mA.
  • In active mode with sensing, current drawn is 180 mA.
  • When the servo is active to turn on/off the valve, current drawn is 240 mA.
Testbed Testbed
Fig. 3: Energy Profiling Setup and Findings

Energy Autonomy through Energy Harvesting

Our system goals are self-sufficiency, long lifespan, and energy efficiency. However, the system components are battery powered and will get depleted over time. Therefore, we design an energy harvesting system to power GreenGuardian as a stand-alone, long-term solution.

  • Harvest Solar Energy to power system.
  • Apply optimization techniques.
Energy harvesting component specifications
Fig. 4: Energy harvesting components

Optimization Techniques

  • Have separate power sources for sensing module and control module. - Gives software control over sensor activation and operation.
    We implemented this by connecting the power supply of the sensors to the Digital Pin 9 of the Arduino, so that we can write HiGH or LOW to that pin to turn the sensing module ON or OFF in order to conserve energy. Only the actuator valve was directly connected to 5V supply, since it required more power than supplied by the digital pin of the Arduino. However, the actuator only consumes power when turning the valve ON/OFF, which is an instantaneous occurence.

  • Sensor data is not highly variable, so we are not sensing continuously. Sensors are turned off and Arduino is in low-power mode for majority of the time.
  • Adaptive Duty Cycling - Battery is charged on good weather days, and sensor activity is lessened on bad weather days (Low Battery Level + Ambient Light below threshold). This enables us to adapt duty cycling to battery power and availability of ambient light.

  • We discuss implementation of the last two techniques in the Algorithm Section.

Actuation Unit: Irrigation Technique

For this project, the actuation unit needed to be energy-efficient, effective, and capable of conserving resources while delivering water directly to the plant roots. Given the project constraints, we opted for a servo-activated valve to utilize the potential energy of the water in the bottle. Drip irrigation is known to be 90% efficient in allowing plants to absorb the water applied, significantly reducing runoff and evaporation (University of Rhode Island, n.d.). Consequently, we decided to fabricate our own drip irrigation system using an irrigation dripper, a valve, and a servo motor to control the water flow. The servo motor is managed by an Arduino, which is in turn regulated by the decision-making model. Below is a video demonstration of how our system works.

Algorithm

For the algorithmic design of our system, we considered that the best initial approach would be a rule-based decision-making system grounded in prior research on optimal plant growth. Our experimental setup, detailed in Here, will utilize ordinary basil plants to assess the effectiveness of our system. The algorithm is specifically tailored to maintain these plants, ensuring their optimal growth conditions are consistently met.

Plant care essentials

To design an effective algorithm, we first need to understand the essentials of plant care. Plants must maintain a specific soil moisture range to thrive; for basil, this range is typically between 25% and 50% [8]. Over the long term, basil plants also require specific humidity and temperature ranges to stay healthy, with ideal humidity levels around 40-60% [9] and temperatures between 21-26°C [6]. The amount of water a plant needs is also influenced by the ambient humidity, as plants can absorb some moisture from the air [9]. It is generally not recommended to water plants at night, as this can lead to mold or other fungal growths that can adversely affect plant health [5]. Additionally, excessive temperatures can be fatal to plants in a short amount of time [6], requiring plant owners to respond quickly to prevent damage or loss. Finally, it is important for basil plants to receive the right amount of sunlight during the day for effective photosynthesis; basil plants require at least 6-8 hours of direct sunlight or 14-16 hours of artificial light per day to thrive, which is a daily average of between 150 to 600 μmol·m−2·s−1 [7], equal to an daily average of between 6522 to 26087 LUX.

Setup

The initial steps of the setup process involve connecting the Arduino to a WiFi network and synchronizing its real-time clock (RTC) with the current date and time from an NTP server. This ensures accurate timekeeping necessary for scheduled tasks and data logging. The necessary libraries, are included to provide various functionalities such as time synchronization, WiFi communication, sensor data acquisition, and actuator control.

Sensor thresholds and pin configurations are defined to monitor and control environmental factors like tem- perature, humidity, soil moisture, light levels, and water supply, which are crucial for maintaining optimal plant health. The setup includes defining macros for sensor thresholds, calibration values, and pin assign- ments, ensuring precise and reliable readings from the sensors.

The system then initializes these components, powering up the sensors and connecting to the WiFi network. Once connected, the time is synchronized with an NTP server to ensure the RTC is accurately set. After synchronization, the system disconnects from the WiFi to conserve power.

Following the initial setup, the system enters a low-power mode while performing periodic measurements and actuations. We will get further into this in the following subsections.

Setup(){
  Connect_to_WIFI();
  Synchronize_Time();
  Disconnect_WIFI();
  Power_up_sensors();
  Setup_sensors();
  Setup_low_power_mode();
}      
Low power mode
Power Modes
Fig.5: Different Power Modes of Arduino Uno R4

The Arduino microcontroller supports multiple low power modes. We decided to use the Software Standby Mode which can be directly transitioned to from the normal mode and consumes less power than the Sleep mode. We do a one time setup to configure Arduino to use the Software Standby Mode whenever the "wfi" instruction is executed. The Arduino comes back to normal mode whenever it receives an interrupt from the RTC (Real time clock) module.

void setup_low_power_mode()
{
  *SYSTEM_PRCR = 0xA502u;   // Disable write protection
  *SYSTEM_SBYCR = (volatile unsigned short) 1u << 15u;    // Use Software Standby mode.
  *SYSTEM_PRCR = 0xA500u;   // Enable write protection

  *ICU_WPEN = 1u << 24u;  // Software standby returns by RTC alarm interrupt enabled
}      

Application

The Arduino operates in an infinite loop, beginning with a battery level check. If the battery level exceeds a specified threshold, the Arduino activates the sensors, reads their values, and performs any necessary actuation. It then stores the data in the EEPROM for later retrieval and sets the next wake-up time to one hour. If the battery level is below the threshold but the light intensity is sufficient, the Arduino still performs these steps. However, if both the battery level and light intensity are below their respective thresholds, the Arduino sets the next wake-up duration to three hours. Finally, the Arduino enters low power mode by setting an alarm in the RTC module and executing the "wfi" instruction.
while True do
    Read Battery Level
    if (Battery Level > Threshold) then
        Sense_and_Actuate()
        Set_Next_Wake_up_Time()
        Store_Data()
    else if (Battery Level < Threshold and Light Intensity from RAM > Threshold) then
        Sense_and_Actuate()
        Set_Next_Wake_up_Time()
        Store_Data()
    else
        Set_Next_Wake_up_Time()
    end if
    enter_low_power_mode()
end while      
Entering Low power mode
void enter_low_power_mode(bool wake_up_hour)
{
  // Retrieve the date and time from the RTC and print them
  RTCTime currentTime, alarmTime;
  AlarmMatch alarm, matchTime;
  RTC.getTime(currentTime);
  int minutes, hour;
  if (wake_up_hour == 0){
    hour = currentTime.getHour();
    alarmTime.setHour(hour + 3);
    matchTime.addMatchHour();
  }
  else
  {
    minutes = currentTime.getMinutes();
    alarmTime.setMinute(minutes);
    matchTime.addMatchMinute();
  }
  RTC.setAlarmCallback(alarmCallback, alarmTime, matchTime);  //sets the alarm callback
  delay(500);   // Wait for previous operations to finish
  asm volatile("wfi");           // Stop here and wait for an interrupt
}      

Decision Making

The core of the system is the actuate() function, which ensures optimal conditions for the basil plant by calling the following functions: control_light(), control_temperature(), control_bottle_sensor(), and control_soil_moisture().

void actuate() {
    RTCTime currentTime;
    RTC.getTime(currentTime);
    int hours = currentTime.getHour();
    control_light(hours);
    control_temperature(hours);
    control_bottle_sensor();
    control_soil_moisture(hours);
}
Control temperature():

If the temperature deviates from the ideal range (21-26°C) [6], the respective function to adjust the temperature is called. If the temperature remains outside this range for three consecutive days, the system will notify the user to relocate the plant. Immediate notification is sent if the temperature exceeds the emergency threshold (t < 10°C or t > 32°C).

#define TEMPERATURE_LOW_THRESHOLD  10   // THE PLANT NEEDS TO BE MOVED INMEDIATELLY
#define TEMPERATURE_HIGH_THRESHOLD  32  // THE PLANT NEEDS TO BE MOVED INMEDIATELLY
#define TEMPERATURE_LOW_IDEAL 21
#define TEMPERATURE_HIGH_IDEAL  26

void control_temperature(int currentTime) {
    // Handle low temperature
    if (sensor_data.temperature < TEMPERATURE_LOW_IDEAL) {
        handle_low_temperature();
    } else {
      if (!different_day_temp && currentTime == 23)
        cold_days = 0; // Reset cold days counter
    }

    // Handle high temperature
    if (sensor_data.temperature > TEMPERATURE_HIGH_IDEAL) {
        handle_high_temperature();
    } else {
      if (!different_day_temp && currentTime == 23)
        hot_days = 0; // Reset hot days counter
    }
}

void handle_low_temperature() {
    if (sensor_data.temperature < TEMPERATURE_LOW_THRESHOLD) {
        //light_up_matrix(MATRIX_NEED_WARM_NOW);
        DEBUG_PRINTLN("Move the plant to a warmer location now.");
        return;
    }

    if (cold_days < MAX_NOT_IDEAL_DAYS && !different_day_temp) {
        cold_days++;
        different_day_temp = true;
    } else {
        //light_up_matrix(MATRIX_NEED_WARM);
        DEBUG_PRINTLN("Move the plant to a warmer location.");
    }
}

void handle_high_temperature() {
    if (sensor_data.temperature > TEMPERATURE_HIGH_THRESHOLD) {
        DEBUG_PRINTLN("Move the plant to a cooler location now.");
        //light_up_matrix(MATRIX_NEED_COLD_NOW);
        return;
    }

    if (hot_days < MAX_NOT_IDEAL_DAYS && !different_day_temp) {
        hot_days++;
        different_day_temp = true;
    } else {
        DEBUG_PRINTLN("Move the plant to a cooler location.");
        //light_up_matrix(MATRIX_NEED_COLD);
    }
}
Control light():

This function manages the light exposure for the plant. If the average light intensity falls outside the acceptable range (lux < 6,522 or lux > 26,087) [7], the corresponding function is triggered. Continuous exposure to inappropriate light levels for three days will prompt the system to alert the user to move the plant.

#define LUX_LOW_THRESHOLD 6,522.0
#define LUX_HIGH_THRESHOLD  26,087.0

void control_light(int currentTime) {
  // to calculate the average
  if(currentTime >= 8 && currentTime <= 19) {
    lux_sum += sensor_data.lux;
    lux_times++;
  }
  
  else if(currentTime == 23){
    lux_average = lux_sum / lux_times;
    lux_sum = 0;
    lux_times = 0;
    
    // Handle low light
    if (lux_average < LUX_LOW_THRESHOLD) {
        handle_low_light(currentTime);
    } else {
        shade_days = 0; // Reset shade days counter 
    }

    // Handle high light
    if (sensor_data.lux > LUX_HIGH_THRESHOLD) {
        handle_high_light(currentTime);
    } else {
        light_days = 0; // Reset light days counter 
    }
  }
}

void handle_low_light(int currentTime) {
    if (shade_days < MAX_NOT_IDEAL_DAYS) {
        shade_days++;
    } else {
        DEBUG_PRINTLN("Move the plant to a lighter location.");
        light_up_matrix(MATRIX_NEED_SUN);
    }
}

void handle_high_light(int currentTime) {
    if (light_days < MAX_NOT_IDEAL_DAYS) {
        light_days++;
    } else {
        DEBUG_PRINTLN("Move the plant to a location with more shade.");
        light_up_matrix(MATRIX_NEED_SHADE);
    }
}
Control bottle sensor():

This function monitors the water bottle. If the water level is low, the system will notify the user to refill it.

void control_bottle_sensor() {
  if (sensor_data.water_level == 0) {
    DEBUG_PRINTLN("Fill the bottle with water. ");
    light_up_matrix(MATRIX_NEED_WATER);
  }
}
Control soil moisture():

Operating hourly between 8AM and 7 PM, this function checks the soil moisture level. If the soil moisture drops below 25% [8], the plant will be watered for three cycles. The default time is three minutes, which may be increased or decreased depending on the humidity. If the humidity is below 40%, the time will increase by 15%; conversely, if humidity exceeds 60%, the duration decreases by 15%. In between the cycles, we will allow the soil to absorb some water for one minute, check if the soil moisture has reached the target, and if not, continue with another shorter cycle. If moisture remains below 25%, the watering time increases by 15%. To ensure accuracy when watering, we reduce watering times as the moisture slowly reaches its target value. We do this by reducing the watering time by 15% every cycle that hasn’t reached the target value. Finally, with excessive moisture of over 70%, a notification is sent to move the plant, as it is inferred that it is getting watered excessively through means other than our system.

#define INITIAL_WATERING_DURATION  180 //(3 minutes)
#define MAX_WATERING_CYCLES  3
#define MOISTURE_THRESHOLD      25
#define MOISTURE_HIGH_THRESHOLD      50 //Percentage
void control_soil_moisture(int currentTime) {
  float soil_moisture = sensor_data.moisture_1;
  if(soil_moisture > MOISTURE_HIGH_THRESHOLD){
    DEBUG_PRINTLN("Move the plant indoors. Excesive moisture. ");
  }

  //Water only in between 8:00 A.M. and 7:00 P.M.
  else if(currentTime >= 8 && currentTime <= 19) {
    short int cycles = 0;
    float watering_duration = INITIAL_WATERING_DURATION;

    // Adjust watering duration based on humidity
    if (sensor_data.humidity < HUMIDITY_LOW_IDEAL) 
      watering_duration *= 1.15;
    else if (sensor_data.humidity > HUMIDITY_HIGH_IDEAL)
      watering_duration *= 0.85;

    // Principal cycle
    while (soil_moisture < MOISTURE_THRESHOLD && cycles < MAX_WATERING_CYCLES){
      openValve(watering_duration);

      delay(1000*60);  // Wait for 1 minute to allow water to percolate
      measure_sensors();
      soil_moisture = sensor_data.moisture_1;
      cycles += 1;
      if (soil_moisture < MOISTURE_THRESHOLD)
        // Increase watering duration if the soil is still dry
        watering_duration *= 0.85;
    }
  }
}
Set Next Wake up Time():

The Green Guardian system employs an adaptive duty cycling method to manage energy consumption efficiently. The algorithm evaluates the battery level and sets the next wake-up interval accordingly. If the battery level is above a predefined threshold, the system schedules the next wake-up in one hour. Similarly, if the battery level is below the threshold but the solar panel is receiving sufficient light, the system also sets the next wake-up duration to one hour. However, if both the battery level and the light intensity are below their respective thresholds, the system extends the wake-up interval to three hours. This adaptive approach ensures that the system's energy demand aligns with the available energy supply.

if (Battery Level > Threshold) then
    Set wake up duration = 1 hour
else if (Battery Level < Threshold and Light Intensity > Threshold) then
    Set wake up duration = 1 hour 
else
    Set wake up duration = 3 hours
end if      

Notification System

The notification system is a key component of the Green Guardian project. It provides visual feedback to the user based on the plant's status using an LED matrix display on the Arduino UNO R4 WiFi. Different patterns and symbols are shown to indicate various conditions and alerts, as seen in Fig. 6.

LED Matrix Display

The LED matrix display shows different symbols to alert the user about the plant's conditions. Below are the symbols used in the notification system:

LED Matrix Display Symbols
Fig. 6: LED Matrix Display Symbols

The image on the left shows the Arduino UNO R4 WiFi with the LED matrix display in action. The image on the right explains the different symbols used in the notification system, including:

Evaluation

To evaluate the effectiveness of our system in keeping plants alive, we designed the following testbed, shown in Fig 7. We acquired two basil plants from the same store, ensuring they were in similar conditions. We placed them side by side in the same space and asked two participants to take care of one plant each: one using the Green Guardian system and one without it. We monitored relevant variables in both plants, such as soil moisture, humidity, and temperature. Additionally, we recorded a timelapse of the plants’ progress and evaluated their condition after 5 days.

Testbed
Fig. 7: Evaluation setup. Basil plant with and without Green Guardian

We chose basil plants for this test due to their extreme sensitivity to environmental conditions and their wide availability (most supermarkets sell this plant) making them an ideal candidate for evaluating the effectiveness of automated plant care systems. Basil requires consistent soil moisture, proper light exposure, and adequate temperature for optimal growth. This makes it a good indicator of the Green Guardian’s ability to maintain these parameters within the optimal range. Furthermore, basil is a commonly grown herb both indoors and outdoors, making our findings relevant to a wide range of users.

We also aimed to quantify the time required for the Arduino to wake up from sleep and begin sensing. However, the RTC module we intended to use for this measurement has a resolution of 1 second, which is inadequate since the entire operation takes less than a second. Therefore, we conclude that the interval time between CPU becoming active and turning on the sensing module is less than a second.

We also defined a success metric to evaluate how our system performs compared to a person manually watering the plant. The success metric is defined as the ability of our system to maintain the moisture of plant within 15-40%. We share the results in the next section.

Results

We collected sensor data over five days, as depicted in Fig 8. The first chart illustrates the temperature in Celsius, which remains relatively stable throughout the observation period. The second chart presents humidity data. The third chart displays the amount of light reaching the plant. The fourth chart indicates the presence of water in the bottle, with ’1’ representing a filled bottle and ’0’ indicating an empty one. The fifth chart shows the moisture levels of plant 1, which was managed by the Green Guardian system. The system effectively maintained the plant’s moisture around 20%. The sixth chart depicts the moisture levels of plant 2, which was cared for by an external individual. The data indicates that this plant was predominantly over-watered. The final chart demonstrates the system’s battery level. In summary, the Green Guardian system successfully monitored various parameters and maintained appropriate watering intervals with minimal human intervention, except for refilling the water bottle.

Data of Results
Fig. 8: Data collected from 5th June to 10th June

We decided to record a time-lapse of the test, as seen here:

We also assessed the success metrics (Fig 9.). The Green Guardian system maintained a healthy plant moisture level (15-40%) for 66.10% of the time. In contrast, plant 2, which was watered manually, consistently exhibited high moisture levels and only maintained healthy moisture for 0.0% of the time. These results demonstrate that our system is capable of sustaining healthy moisture levels for plants.

Success Metric
Fig. 9: Success Rate as per defined Metric

Components Used in the Project

Actuation Unit

Energy Management Unit

Sensing Unit

Control Unit

References

  1. A. Narishkin and M. Tejapaibul, “Americans spend billions on houseplants, only to kill half of them” Business Insider, Mar. 8, 2022. [Online]. Available: https://www.businessinsider.com/houseplant-industry-americans-billions-die-2022-3. [Accessed: Jun. 2, 2024].
  2. National Gardening Association, “Houseplants boomed during the pandemic. Gen Z and millennials say their popularity is here to stay,” 2022. [Online]. Available: https://www.kunr.org/business-and-economy/2022-12-28/houseplants-boomed-during-pandemic-gen-z-millennials-say-popularity-stays-tiktok#graphic-2. [Accessed: Jun. 2, 2024].
  3. Oregon State University Extension Service, ”Environmental Factors Affecting Plant Growth.” [Online]. Available: https://extension.oregonstate.edu/gardening/techniques/environmental-factors-affecting-plant-growth. [Accessed: Jun. 2, 2024].
  4. University of Rhode Island, “Drip Irrigation.” [Online]. Available: https://web.uri.edu/safewater/protecting-water-quality-at-home/sustainable-landscaping/drip-irrigation/. [Accessed: May. 7, 2024].
  5. D. Swainston, ”Is watering plants at night a good idea? Experts discuss why it could put plants in danger,” Homes & Gardens, [Online]. Available: https://www.homesandgardens.com/gardens/watering-plants-at-night. [Accessed: May. 28, 2024].
  6. G. Chandler, ”What Temperature Is Too Hot for Basil: Optimal Growing Conditions Revealed,” Evergreen Seeds, May 3, 2024. [Online]. Available: https://www.evergreenseeds.com/what-temperature-is-too-hot-for-basil/. [Accessed: 02-Jun-2024].
  7. D. H. Larsen, E. J. Woltering, C. C. S. Nicole, and L. F. M. Marcelis, ”Response of Basil Growth and Morphology to Light Intensity and Spectrum in a Vertical Farm,” Horticulture and Product Physiology, Dept. of Plant Sciences, Wageningen University & Research, Wageningen, Netherlands; Postharvest Technology, Wageningen Food and Biobased Research, Wageningen University & Research, Wageningen, Netherlands; Signify, Eindhoven, Netherlands, 2024.
  8. J. Krause, ”Unlock The Secrets To Growing The Perfect Basil: The Ideal Soil For Optimal Results,” Shuncy, Apr. 25, 2023. [Online]. Available: https://shuncy.com/article/unlock-the-secrets-to-growing-the-perfect-basil-the-ideal-soil-for-optimal-results. [Accessed: 02-Jun-2024].
  9. M. Glenn, ”How to Prune Basil AeroGarden: A Complete Guide for Maximum Harvests,” Expert Pruning. [Online]. Available: https://expertpruning.com/how-to-prune-basil-aerogarden/. [Accessed: 02-Jun-2024].
  10. K. Rawal and G. Gabrani, ”IoT based computing to monitor indoor plants by using smart pot,” in Proceedings of the International Conference on Innovative Computing & Communications (ICICC), 2020.
  11. J. H. Gultom, et al., ”Smart IoT water sprinkle and monitoring system for chili plant,” in 2017 International Conference on Electrical Engineering and Computer Science (ICECOS), IEEE, 2017.
  12. A. Nurminen and A. Malhi, ”Green Thumb Engineering: Artificial intelligence for managing IoT enabled houseplants,” in 2020 IEEE Global Conference on Artificial Intelligence and Internet of Things (GCAIoT), IEEE, 2020.
  13. M. Ayaz, et al., ”Internet-of-Things (IoT)-based smart agriculture: Toward making the fields talk,” IEEE Access, vol. 7, pp. 129551-129583, 2019.
  14. N. N. Misra, Y. Dixit, A. Al-Mallahi, M. S. Bhullar, R. Upadhyay, and A. Martynenko, ”IoT, Big Data, and Artificial Intelligence in Agriculture and Food Industry,” IEEE Internet of Things Journal, vol. 9, no. 9, pp. 6305-6324, May 2022, doi: 10.1109/JIOT.2020.2998584.
  15. R. Krishnamurthi, A. Kumar, D. Gopinathan, A. Nayyar, and B. Qureshi, ”An Overview of IoT Sensor Data Processing, Fusion, and Analysis Techniques,” Sensors, vol. 20, no. 6076, 2020. [Online]. Available: https://doi.org/10.3390/s20216076. [Accessed: 02-Jun-2024].
  16. T. Sanislav, et al., ”Energy harvesting techniques for internet of things (IoT),” IEEE Access, vol. 9, pp. 39530-39549, 2021.
  17. S. Sudevalayam and P. Kulkarni, ”Energy harvesting sensor nodes: Survey and implications,” IEEE Commun. Surveys Tuts., vol. 13, no. 3, pp. 443-461, 3rd Quart., 2011.
  18. C. Wang, J. Li, Y. Yang, and F. Ye, ”Combining solar energy harvesting with wireless charging for hybrid wireless sensor networks,” IEEE Trans. Mobile Comput., vol. 17, no. 3, pp. 560-576, Mar. 2018.
  19. B. B. Sinha and R. Dhanalakshmi, ”Recent advancements and challenges of Internet of Things in smart agriculture: A survey,” Future Generation Computer Systems, vol. 126, pp. 169-184, 2022.
  20. S. Zeadally, F. Shaikh, A. Talpur, and Q. Sheng, ”Design architectures for energy harvesting in the Internet of Things,” Renewable and Sustainable Energy Reviews, vol. 128, 109901, 2020. [Online]. Available: https://doi.org/10.1016/j.rser.2020.109901. [Accessed: 02-Jun-2024].
  21. J. Gruetter, ”Solar Energy Harvesting—Low Power in a Compact Footprint,” Power Systems Design, Oct. 2010. [Online]. Available: https://www.powersystemsdesign.com/articles/solar-energy-harvesting/22/5742. [Accessed: 03-Jan-2021].
  22. Y. Wu, C. Li, Z. Tian, and J. Sun, ”Solar-driven integrated energy systems: State of the art and challenges,” J. Power Sources, vol. 478, Dec. 2020, Art. no. 228762.
  23. S. Reddy and C. R. Murthy, ”Profile-based load scheduling in wireless energy harvesting sensors for data rate maximization,” in Proc. IEEE Int. Conf. Commun., Cape Town, South Africa, May 2010, pp. 1-5, doi: 10.1109/ICC.2010.5502464.
  24. S. Reddy and C. R. Murthy, ”Dual-stage power management algorithms for energy harvesting sensors,” IEEE Trans. Wireless Commun., vol. 11, no. 4, pp. 1434-1445, Apr. 2012, doi: 10.1109/TWC.2012.032812.110623.
  25. Oregon State University Extension Service, ”Environmental factors affecting plant growth,” [Online]. Available: https://extension.oregonstate.edu/gardening/techniques/environmental-factors-affecting-plant-growth. [Accessed: 06-May-2024].
  26. University of Rhode Island, ”Drip Irrigation,” [Online]. Available: https://web.uri.edu/safewater/protecting-water-quality-at-home/sustainable-landscaping/drip-irrigation/. [Accessed: 23-May-2024].