Team GO B: Alicia Chuah, NARENDRAN, Dani Zaky, Vladislav Cherskoy, Ali Zahid

Published August 20, 2023

Automated Vertical Farming

A system using light, soil moisture and humidity sensors to control the water, light and humidity needed by the vertical farm.

IntermediateFull instructions provided24 hours1,584

Things used in this project

Hardware components

Seeed Studio Arduino Uno Rev3

Breadboard (generic)

Jumper wires (generic)

Adafruit DHT22 temperature-humidity sensor

Micro Submersible Water Pump DC 3V-5V

SparkFun Soil Moisture Sensor (with Screw Terminals)

Digital Light Intensity BH1750FVI Sensor Module

3V-5V 0.2A Cooling Fan for RPi with Screws

Single Channel 5V Relay Breakout Board

2 Channel 5V Active Low Relay Module

4xAA battery holder

Battery Holder, AA x 3

Software apps and online services

Arduino IDE

Blynk

Story

Introduction

In this group project, the design was to introduce an automation to vertical farming. The automation on vertical farming would bring a better solution for efficiency and higher yield output for crops to answer the future food supply shortage. Making the vertical farm automated with the help of sensors and actuators would reduce the need of manual inspections on vegetation conditions. The automation system would provide consistent observation on the plants to provide the best condition of the plants environment at all times. The objective was to be able to integrate all 3 working sensors with supporting components altogether using the developed Arduino UNO code with GUI (WIFI module) to display the readings at remote location.

Automation system of vertical farming

The vertical plants as an example in which has been automated using various sensors and supporting components to maintain the optimal condition of the plants. The types of sensors used as part of the automation was DHT22 (humidity and temperature sensor), light intensity sensor and soil moisture sensor. The DHT22 sensor would provide data on the humidity level and temperature of the surrounding environment, the light intensity would read and provide data on the amount of light the plants has received while the moisturization sensor provides the data on the soil condition in the vertical farming.

Light Intensity Sensor + Light Control(Vlad)

It is essential for the “Automated Vertical Farming” system to have the automated process of supplying the plants with light, especially for indoor locations, at the required light intensity level, which is identified by the “lux” unit. Therefore, since the prototype system is located indoors, plants will require sunlight to perform the photosynthesis process, which allows stable and secure growth. Although the sunlight can infiltrate through windows or doors of the enclosed area, the intensity of the light might be insufficient for the plant to grow and absorb the sunlight characteristics and energy.

So, for the stated project it becomes necessary to develop an artificial lighting source for the plant to receive the needed and important light energy for the internal processes, which will stimulate its growth. Moreover, to make the system work independently, it was decided to include the automatization components, such as relays. Subsequently, their combination with LED lamps, DH1750 light intensity sensor, Arduino Uno Rev3 Board, shared Breadboard, and Power Supply (4xAA 1.5V batteries) with the jumper wires will establish the independent and automated light detection and control system for the plant. The prototyped representation of the system with sensors and lamps attached near the plant can be seen in the figure below:

Implementation of the light intensity sensors and lamps to the system.

Regarding the components used, their connections can be seen in the figures below, where the Arduino Board is represented by a key and hub element, which connects all the parts of the system together. To be more specific, the Arduino Board will collect the data from the DH1750 light sensor through its communication pins and send the respective output to the relay from the associated digital pin.

Connectivity between LED Lamp and Relay and the Arduino Board.

Connectivity between the BH1750 light intensity sensor and the Arduino Board.

Moreover, to avoid the overload of the system, since the system utilizes the set of two relays, lamps, and DH1750 sensors, it was decided to add an external power supply of 4x1.5V batteries to the lamps, since they are the most power-consumed element used for the circuit, while the Arduino Board also has separate 9V battery supply to power up the board itself and attached sensors.

Speaking in terms of sensors and actuators, once the light intensity sensor collects the information of the lux (illumination) from surroundings, it will be sent to the Arduino Process, which will process the information with the uploaded program. Hence, for the demonstration and test purposes in the scope of the project development, it was decided to limit the allowed lux limit to 50 lux, while developing the program, and to 10 lux for video-demonstration purposes.

Subsequently, once the microprocessor determines that the light intensity is lesser than its required/set value, the signal will be sent to the “Active-Low” type relay to change its state from ON to OFF, and to deliver the ON condition to the lamp. So, the associated part of the program code can be seen below:

Part of the Program Code to control the relay based on the "lux" value.

Consequently, to ensure the expected results of the prototype system, the set of tests were performed in the indoor surrounding conditions, which can be seen in the attached video:

Experimental Test of the Light Intensity Detection and Control System

Soil Moisture Sensor + Water Pump Control(Alicia)

For the monitoring and control of the water supply of the vertical farm, the following equipment was used: a soil moisture sensor, water pump, 3x1.5AA batteries, 5V electrical relay, breadboard and Arduino.

The Arduino was powered using a power supply of 9V. The 5V output of the Arduino was then used to power the soil moisture sensor. The analog pin of the soil moisture sensor was connected to the Arduino analog input pins to allow for the data generated by the sensor to be sent to the Arduino. In order to control the water pump using the soil moisture readings through the Arduino, a 5V relay was used with the input pins of the relay connected to the digital input pins of the Arduino. Similar to the sensor, the relay is also powered using the Arduino power supply. The positive terminal of the pump is connected to the normally open (NO) terminal of the relay while the common port of the relay is connected to the batteries that supply power for the pump. When the soil moisture sensor records readings of less than 78%, the pump will be activated. When the readings are above this threshold, the pump will stop.

Soil Moisture Sensor + Pump Control Interface Design

The pump is placed in the reservoir at the bottom of the vertical farm system and the hose connected to the pump is then placed in the container of the top plant of the vertical farm system. The container of the plants are connected to another container (top part of plastic bottles) which acts as funnel for the excess water to flow through. Several holes are made on the bottle caps attached to the plastic bottle.

This arrangement allows for water to be pumped from the reservoir at the bottom of the system to the top plant of the system. The excess water from the top plant will then drip from the bottom plant through the holes in the bottle cap. This process repeats itself for the bottom plant such that the excess water from the bottom plant will be returned to the reservoir. The water usage for the vertical farm system can then be conserved as it is constantly being recycled in the system.

Placement of Pump (Left), Placement of Hose of Pump into Top Plant of Sytem (Right)

The video shows the physical connections of the system along with how the system functions in real time.

Video of Automated Vertical Farm System - Soil Moisture Sensor + Pump Control

Humidity Sensor + Fan Control(Dani)

As part of the automation installation on vertical farming to make the crops have an ideal environmental condition was to provide a humidity and temperature control system. The type of sensor used was DHT22, which has the capability to detect and read both temperature and humidity level on the surrounding environment of the plants. Moreover, a fan would be installed into the vertical planting system in which would help reduce the temperature and humidity level to a suitable level for vegetation (60%-70%). The fan was to turned ON and OFF based on the data collected by the Arduino UNO in which would displayed in serial monitor. When the Arduino UNO received a high humidity, it would send signal to 2-channel relay to provide power to the fan which result to turn ON the fan.

Humidity and Temperature sensor connection (DHT22)

The image above shows overview connection that was done to connect the DHT22 sensor (input voltage 3.3V-5V) with the Arduino UNO rev3 and relay as the information/data transfer to the fan. The operating voltage of the Arduino UNO rev3 was 5V with a recommended input voltage to power the Arduino of 7V minimum. The fan was powered by the 5V 2-channel relay and ground through the battery pack. The relay was powered by the 6V battery pack (1.5V per battery) where is would received data input from the Arduino UNO and ground connected to the Arduino UNO GND port. The input reading from the DHT22 sensor would be transferred to the Arduino UNO in which would display on the GUI and also send signal to the relay and fan when to switch on and off. The DHT22 was powered by the Arduino VCC of 5V and ground ports connected to GND pin. Similar set up was done to the second fan. Both the DHT22 and fan takes up a minimum input voltage of 3.3V.

Humidity and temperature sensor (RED) with fan

The image above shows the physical view of the placement done on DHT22 sensor with the 1st fan. The DHT22 sensor was placed in between 1st and 2nd layer of plants where the place would be an ideal for reading the environmental condition of both layers. Moreover, the fans were place on the tip of the pot facing the side of the pot as it would help reduces the surrounding moisture causing high humidity in which disturbs the plants growth. Both fans were placed facing the same direction on each plants layers.

Video on DHT22 attachment with fan using Arduino UNO

The video above shows the system of DHT22 sensor working on both ON and OFF state based on the level of humidity the sensor has detected in which would sent data signal to Arduino UNO and relay with fan.

Code structure

The code structure made was based on researched humidity value in which the ideal humidity percentage for a plant are ranged from 60-80%. With this data researched, IF statement was used to take data from the DHT22 sensor in which when the humidity percentage is lower than 70%, it would turn OFF the fan (low). If the relay has a low input it means that the output signal to the fan is high like wise for high input is the wise versa.

GUI and Wifi(Ali)

Arduino Uno Rev3 (Top) and ESP 01 Wifi Module connected to a ESP 01 Adapter (Bottom)

This system connects the Arduino Uno Rev3 Board to the Blynk platform. Since this board does not have integrated WiFi, an external WiFi module is needed to allow our board to transmit data wirelessly.

The wireless module chosen was the ESP01 connected to a ESP 01 adapter board.

This WiFI module was then connected to our Arduino via Port 11 and 12, which have been defined as Software serial ports, since the hardware ports are used to communicate with the compute (Port 0 and 1).

This systems takes data obtained from all sensors mentioned previously (DHT22, GY30 BH1750 light sensor and Moisture Sensor), and transfers it to Blynk via its virtual pins, allowing obtained data to be viewed graphically from the Blynk IoT App. The Virtual pins used were V0, V1, V2, V3, V4 respectively.

Blynk must first be setup before we can upload data to it.

SETTING UP BLYNK GUI.

Blynk New Template Creation

1. Blynk Account is first created to start the process of setting up Blynk, via url

https://docs.blynk.io/en/getting-started/signup

2. Then we create a new template with our chosen name, hardware selection (Arduino in our case), connection type (WiFi in our case) and finally, a short description on the purpose of our template.

Blynk Datastreams made

3. After creating our template, we now define the datastreams through which data from our Arduino will reach Blynk itself. Since we have 5 output values, we will define 5 Virtual pins:

V0 for Temperature, Celsius
V1 for Humidity, %
V2 for Light Sensor 1, Lux
V3 for Light Sensor 2, Lux
V4 for Soil Moisture, %

4. After defining our datastreams, we now define the physical graphics through which our data is displayed, For our project, we will primarily be using Gauges, each having the same name as our datastreams.

Blynk GUI Gauges

5. With our GUI finally setup, we simply now need to connect it to our Arduino, to do that, we must first create a device in Blynk; the main object through which we communicate with Blynk servers. We created a device called "Humidity Sensor" as shown below

Blynk Device Details

6. With this we get 3 specific lines of code, containing our template ID, device name, and our Authentication token

Blynk Access Details

7. With this we can now finally connect to Blynk servers to our specific GUI, and upload the data obtained from our sensors as shown below with some data being already transmitted

GUI we obtained sensor data

Final Assignment Code

#define BLYNK_TEMPLATE_ID           "TMPL6BtHcHcBz"
#define BLYNK_TEMPLATE_NAME         "gui"
#define BLYNK_AUTH_TOKEN            "7lbErGB2plF-rZW2XY3q5YqAkH2NdUbt"
/* Comment this out to disable prints and save space */
#define BLYNK_PRINT Serial
#include <DHT.h>
#include <ESP8266_Lib.h>
#include <BlynkSimpleShieldEsp8266.h>
#include <Wire.h>
#include <BH1750.h>
BH1750 GY30_1;
BH1750 GY30_2;
// Your WiFi credentials.
// Set password to "" for open networks.
char ssid[] = "D-20-09";
char pass[] = "0189718976";
#define DHTPIN 4            // Defines pin number of humidity sensor
#define DHTTYPE DHT22       // Define DHT Type
DHT dht(DHTPIN, DHTTYPE);   // Create DHT Object
#define FAN_PIN_1 6 // Relay channel pin to fan1
#define FAN_PIN_2 7 // Relay channel pin to fan2
#define light_relay_pin1  9 // Relay channel pin to light2 (Connections are reversed)
#define light_relay_pin2  8 // Relay channel pin to light1 (Connection are reversed)
#define pump_relay 13 
#define SoilMoisturePin A3   // Soil moisture sensor data input
// or Software Serial on Uno, Nano...
#include <SoftwareSerial.h>
SoftwareSerial EspSerial(11, 12); // RX, TX
// Your ESP8266 baud rate:
#define ESP8266_BAUD 9600
ESP8266 wifi(&EspSerial);
BlynkTimer timer;


float humidity;
float temperature;
float moisture_percentage;
int sensor_analog1;
float lux1;
float lux2;



void moisture_sensor()
{
  
  sensor_analog1 = analogRead(SoilMoisturePin);
  moisture_percentage = ( 100 - ( (sensor_analog1/1023.00) * 100 ) );
  Blynk.virtualWrite(V4, moisture_percentage);
  Serial.print(" moisture_percentage = ");
  Serial.println(moisture_percentage);
}
void pump_control()
{
  if (moisture_percentage <= 78 )
  {
    digitalWrite(pump_relay, LOW);
  }
  else 
  {
    digitalWrite(pump_relay, HIGH);
  }
}
void HumiditySensor()
{
  humidity = dht.readHumidity();
  Serial.print("Humidity = ");
  Serial.print(humidity);
  Serial.println(" % ");
  Serial.println(""); 

  if (isnan(humidity))
  {
    Serial.println("Failed to read from DHT sensor!");
    return;
  }
  // You can send any value at any time.
  // Please don't send more that 10 values per second.
  Blynk.virtualWrite(V0, humidity);
}
void TempSensor()
{
  temperature = dht.readTemperature(); // or dht.readTemperature(true) for Fahrenheit
  Serial.print("Temperature = ");
  Serial.print(temperature);
  Serial.print(" ");
  Serial.print("C | ");
  Serial.print((temperature * 9.0) / 5.0 + 32.0);//print the temperature in Fahrenheit


  if (isnan(temperature)) 
  {
    Serial.println("Failed to read from DHT sensor!");
    return;
  }

  Blynk.virtualWrite(V1, temperature);
}
void fan_control_1()
{
  if (humidity >= 80)
  {
    digitalWrite(FAN_PIN_1, LOW);
  }

  else 
  {
    digitalWrite(FAN_PIN_1, HIGH);
  }
}
void fan_control_2()
{
  if (humidity >= 80)
  {
    digitalWrite(FAN_PIN_2, LOW);
  }

  else 
  {
    digitalWrite(FAN_PIN_2, HIGH);
  }
}
void light_sensor1() 
{

  lux1 = GY30_1.readLightLevel();
  Serial.print ("lux reading 1: ");
  Serial.print (lux1);
  Blynk.virtualWrite(V2, lux1);
  delay(1000);
}
void light_sensor2() 
{
  lux2 = GY30_2.readLightLevel();
  Serial.print ("| lux reading 2: ");
  Serial.println (lux2);
  Blynk.virtualWrite(V3, lux2);
  delay(1000);
}
void light_control1()
{
  if (lux1 <= 50)
  {
    digitalWrite(light_relay_pin1, LOW);
  }

  else 
  {
    digitalWrite(light_relay_pin1, HIGH);
  }
}
void light_control2()
{
  if (lux2 <= 50)
  {
    digitalWrite(light_relay_pin2, LOW);
  }

  else 
  {
    digitalWrite(light_relay_pin2, HIGH);
  }
}


void myTimerEvent(){
  HumiditySensor();
  TempSensor();
  light_sensor1();
  light_sensor2();
  moisture_sensor();
  fan_control_1();
  fan_control_2();
  light_control1();
  light_control2();
  pump_control();}
void setup(){
  Serial.begin(9600);
  digitalWrite(FAN_PIN_1, HIGH);
  digitalWrite(FAN_PIN_2, HIGH);
  pinMode(FAN_PIN_2, OUTPUT);
  pinMode(FAN_PIN_1, OUTPUT);
  digitalWrite(pump_relay, HIGH);
  pinMode(pump_relay, OUTPUT);
  digitalWrite(light_relay_pin1, HIGH);
  digitalWrite(light_relay_pin2, HIGH);
  pinMode(light_relay_pin1, OUTPUT);
  pinMode(light_relay_pin2, OUTPUT);
  EspSerial.begin(ESP8266_BAUD);
  delay(10);
  Blynk.begin(BLYNK_AUTH_TOKEN, wifi, ssid, pass);
  dht.begin();
  Wire.begin();
  GY30_1.begin(BH1750::CONTINUOUS_HIGH_RES_MODE, 0x23);
  GY30_2.begin(BH1750::CONTINUOUS_HIGH_RES_MODE, 0x5C);
  timer.setInterval(5000L, myTimerEvent); }
void loop(){
  Blynk.run();
  timer.run();}