•

Published June 2, 2019 © GPL3+

Smart Water Management System for Developing Farmers

Would like to solve the problems of water scarcity and lack of farming techniques in developing nations through the use of IoT and AI.

AdvancedFull instructions provided10 hours6,507

Smart Water Management System for Developing Farmers

Things used in this project

Hardware components

Raspberry Pi Zero

Huawei MS2131 USB Stick

SORACOM Air Global IoT SIM

Seeed Studio Grove Base Hat for Raspberry Pi Zero

SparkFun Soil Moisture Sensor (with Screw Terminals)

9V battery (generic)

ITead 12v Channel Relay

12v Water Solenoid

Software apps and online services

SORACOM Air IoT Connectivity Platform

IFTTT Maker service

Amazon Web Services AWS Lambda

Amazon Web Services AWS IoT

Story

The problem:

Agriculture is the single largest employer in the world, providing livelihoods for 40% of today’s global population. There are approximately 475 million smallholder farms (less than 2ha in size), which make up 12% of the world’s agricultural land and produce 80% of food that is consumed in Asia & sub-Saharan Africa.

Most of these are subsistence farmers earning less than USD$5 per day, who rely on traditional practices to achieve their crop yields. For these farmers, enabling productivity and finding efficient processes will have a direct impact on their income.

Furthermore, emerging population growth and changing food consumption patterns are expected to drive demand for these farmers to almost double their food production by 2050.

However, with 1.5 billion ha of arable land on the planet almost fully utilised, the only way to sustainably increase food production is by increasing crop yields and intensity. To achieve this we must develop cost effective technology that will provide efficient irrigation and agricultural water management.

The solution:

Our solution is centered around Artificially Intelligent Irrigation technology, to help small farmers improve their livelihoods and efficiency. Our irrigation technology will be a low cost and scalable solution to enable a more efficient use of inputs, such as water, fertiliser, energy & labour, resulting in increased yields and enhanced quality of crops.

The benefits have been documented through research surrounding the impact of efficient irrigation technology on small farmers (IFC, World Bank Group):

1. Water

Efficient irrigation allows farmers to:

Use less water to grow the same amount of crops
More productively farm larger areas of land using the same amount of water
Use the same amount of water to grow higher value, more water-intensive crops

2. Fertiliser

Efficient irrigation reduces the amount of fertiliser needed per plant:

Nutrients can be dissolved in irrigation water & applied equally
Reduced waste product
Reduced labour requirement

3. Energy

Efficient irrigation reduces energy usage:

Less water is needed for a comparable area of irrigation
Less energy is required for pumping less water
Automation means irrigation can take place at optimal energy times (night)

4.Labour

Efficient irrigation decreases the amount of time spent:

Reduced time watering - as is now automated through irrigation system
Applying fertiliser as this is also achieved through the system

How does it work?

The solution can be broken into 3 parts:

Data collection of Soil Moisture
AI program to determine when to trigger system
Triggering watering systems

Data collection of soil moisture:

Using the Soracom Global Air SIM, Raspberry Pi Zero, Grove Base Hat, Huawei USB Stick and a moisture sensor, we could send readings of the soil moisture to our AI Code (AWS Lambda function) through Soracom Funnel. This can be placed anywhere in the farm.

Set up of this system can be viewed here:

Set up of Soil Reader

Also code for the Raspberry Pi Zero:

Full code available at the end

The data passes through Soracom funnel to AWS IoT, where the set up of a simple rule allows the data to be passed to AWS Lambda.

Soracom Funnel Set Up

Set up of rule on AWS IoT

The Lambda function will then place the data into a dynamoDB table and determine whether the water system should be triggered.

AWS Lambda Function parsing data to DynamoDB

DynamoDB Table of Moisture Data

AI program:

This code will decipher the measurement relative to what crop is growing in the soil and decide whether watering is needed. However, before watering the program will check weather patterns 12 hrs in the future to look out for rain and prevent wasting water through the over watering of crops.

Furthermore, this program can also look at the optimum watering times of the days and automatically trigger the watering at those times.

To trigger the watering, the program will trigger a webhook, set up up previously, to activate the watering system and then after 10 minutes (depending on watering strategy) it will trigger another webhook that deactivates the watering system.

*Due to lack of time I was only able to program a check that if water moisture is less then a threshold, it will trigger the water system

AWS Lambda code checking moisture levels

Access to trigger watering systems:

We will be triggering the water systems by leveraging ITEAD's 12V Channel Relay as well as a solenoid valve.

When a webhook is triggered, the ITEAD switch will activate the solenoid valve to let water through the watering system as well as deactivating the system to stop the water flow.

This can be achieved using the platform IFTT and which can be connected directly to the 12V Channel Relay using the webhooks and EWeLink Applets.

Applet configured using Webhooks and EWeLink

The webhooks can be triggered using our AWS lambda code after collating the soil moisture data and future weather predictions, this trigger was seen above in our Lambda Code.

Here is a picture of the set up fo the 12V Channel Relay with the solenoid valve:

12V Channel Relay with the solenoid valve

Conclusion:

This project is missing some fine tuning but the fundamentals are there to turn this into a true solution for developing farmers.

Code

AWS Lambda Code

console.log('Loading event'); 
var AWS = require('aws-sdk');
var dynamodb = new AWS.DynamoDB();
var iotData = new AWS.IotData({endpoint: '{your_endpoint}'});
var callback;

//make sure your replace your_AWS_endpoint_you_copied_earlier with the value you copied just before

exports.handler = function(event, context,callback) {
    console.log("Request received:\n", JSON.stringify(event));
    console.log("Context received:\n", JSON.stringify(context));
    
    var tableName = event.operatorId;
    var time = event.timestamp;
    var Moisture = event.payloads.measure;
    
    var sleep = require('sleep');
    
    if (Moisture <= 300) {
        console.log("Turning Water On");
        var command = 'wateron';
        httpsGet(command);
        sleep.sleep(40);
        console.log("Turning Water Off");
        var command = 'wateroff';
        httpsGet(command);
    };
    
    function returnTime(value){
        return new Date((value)*1000 + 39600000); 
    }
    //replace 39600000 with the Unix time offset according to your timezone. Here it is set to Sydney time offset. 




 //Next function will store the message in a dynamoDB table
    dynamodb.putItem({
            "TableName": event.operatorId,
            "Item": {
                "deviceId": {
                    "S": event.operatorId
                }, 
                "time": {
                    "S": event.timestamp.toString() 
                },
                 "Moisture" :{
                    "S": Moisture.toString() 
                }
                
            }
        },
    
        function(err, data){
            if (err) {
                context.fail('ERROR: Dynamo failed: ' + err);
            } else {
        console.log('Dynamo Success: ' + JSON.stringify(data, null, ' '));
                context.succeed('SUCCESS');
            }
        }); 
        
        
        
    var https = require('https');
    function httpsGet(command) {
        var options = {
            host: 'maker.ifttt.com',
            port: 443,
            path: '/trigger/'+command+'/with/key/{your_webhook_key}',
            method: 'GET',
        };
    
        var req = https.request(options, res => {
            res.setEncoding('utf8');
            callback('Success');
            var returnData = "";
    
            res.on('data', chunk => {
                returnData = returnData + chunk;
            });
        });
        req.end();

    }    
     
      
        
        
        
};