Cookie Consent by Free Privacy Policy Generator website How Capgemini Uses AWS IoT to Monitor Farmland Through Agricultural Insights u

Portal Nachrichten

628 FEEDS: viele neue ai feets und Windows Tipps und Tricks. Diverse caching Probleme. 3.12.22.


➠ How Capgemini Uses AWS IoT to Monitor Farmland Through Agricultural Insights

The human population is predicted to reach around 10 billion by 2050. To sustain the exponential needs of this growth in terms of food and nutrition, our existing farming methods will be stressed to increase yields within the limited supply of available land.

Current methods to increase farming yields include the application of chemical fertilizers and the widespread use of pesticides. These methods have the advantage of increasing the quantity, but at the cost of adverse effects on the overall environment—destruction of biodiversity and contaminating ground water, soil and its fertility, and even the air.

Capgemini is an AWS Premier Consulting Partner and Managed Service Provider (MSP) with a multicultural team of 220,000 people in 40+ countries. Capgemini’s solution, outlined in this post, proposes an alternative method by using technology to manage moisture for optimum plant growth.

Capgemini believes in sustainable IT solutions, which refers to the application of IT practices and technologies for the benefit of customers and other stakeholders that ensure long-term well-being in economic, social, and environmental sustainability pillars.

Capgemini’s solution is called “Smart Hub Cropping” and checks precipitation in the farming fields, combines weather data from the government, and analyzes agricultural data to provide farmers with actionable insights and automation of the irrigation process. All of this is aligned to the most needed farmer experience of higher crop yield.

To achieve this outcome, Capgemini cloud technologies from Amazon Web Services (AWS) in areas like the Internet of Things (IoT), monitoring, insights, integration, and machine learning (ML).

Solution overview

Capgemini’s Smart Hub Crop solution provides an interface for farmers that provides data and insights about the moisture levels in the fields within their farms. This is combined with weather data focusing on forecasted precipitation levels, and data provided by the Government of India’s Department of Agriculture, Cooperation & Farmers Welfare, which details the levels and types of crops harvested for the nation.

This combined dataset helps farmers understand which crop type to plant and in which area of the farm to do so. It also helps them maintain their crops to ensure productive growth.

Farmers register and authenticate through a mobile application to get access to their dataset, view data about their fields, weather forecast data for the forthcoming week, and see a graphical representation of moisture levels for their farmland.

Smart Hub Crop encompasses the following:

  • Moisture sensor and GPS-enabled (IoT) device deployed to farmland.
  • Central monitoring and analysis platform on AWS.
  • Mobile application for insights and interactions on AWS.
Figure 1 – High-level solution diagram.

Capgemini

The solution uses a moisture sensor which is connected to an Arduino electronics device. This provides the capability for sending moisture level data to the Smart Hub Crop core via a connected GPS interface.

The IoT device is set to periodically send data into the Smart Hub Crop service to be processed together with the soil type of the farmer’s fields by the moisture algorithms. This happens before being stored in the Smart Hub Crop database, along with the third-party environmental data received.

This information is made available to the farmer via the mobile application via web browser or mobile phone.

Figure 2 – High-level architecture diagram.

Capgemini

The AWS toolbox

Capgemini developed the Smart Hub Crop solution using React Native, an open-source mobile application framework together with the AWS SDK for JavaScript. React primitives render the user interface (UI) and the application, via the AWS SDK, and uses the same native platform APIs to interact with AWS services.

The end user (farmers, in this case) use a mobile application interface as part of the solution. Users authenticate through the React application interface via Amazon Cognito and receives a JWT token. This token is used to authorize API calls from the application to AWS AppSync.

Once authenticated, the user retrieves the information from the Amazon DynamoDB table that holds the data that’s been provided by the IoT devices situated in the farmer’s fields.

Smart Hub Crop uses the following AWS services:

  • AWS AppSync is a managed service that uses GraphQL to make it easy for applications to get exactly the data they need by letting you create a flexible API to securely access, manipulate, and combine data from one or more data sources.
  • AWS Amplify Framework allows developers to create, configure, interact, and implement scalable mobile and web apps powered by AWS. Amplify seamlessly provisions and manages your mobile backend, and provides a simple framework to easily integrate your backend with iOS, Android, web, and React Native frontends. Amplify also automates the application release process of both your frontend and backend, allowing you to deliver.
  • AWS Amplify CLI is a unified toolchain to create, integrate, and manage the AWS services for your app.
  • Amazon Cognito is a user management service with rich support for users’ authentication and authorization. You can manage those users within Cognito or from other federated third-party identity providers (IdPs).
  • Amazon DynamoDB is a key-value and document database that delivers single-digit millisecond performance at any scale.
  • AWS IoT Core provides the cloud services that connect your IoT devices to other devices and AWS services.

Building the solution

To implement the Smart Hub Crop solution, complete the following steps.

Step 1: Initialize the project and set up AWS Amplify

To begin, you need to have installed and configured the AWS Command Line Interface (CLI)Amplify CLI, and NPM.

To create the React project, run the following command:

npx create-react-app farmhub-demo

This command creates a folder called farmhub-demo containing an empty React application.

Follow the instructions below to initialize an Amplify project within the React application:

  • Switch to the project directory by typing cd farmhub-demo.
  • Initialize an Amplify project by running the following command and answers to the prompts:

amplify init

  • Enter a name for the project: farmhubdemo
  • Enter a name for the environment: dev
  • Choose your default editor: Visual Studio Code (or your choice of editor)
  • Choose the type of app you’re building: JavaScript
  • What JavaScript framework are you using: React
  • Source directory path: src
  • Distribution directory path: build
  • Build command: npm run-script build
  • Start command: npm run-script start
  • Select the authentication method you want to use: AWS profile/AWS Keys

The amplify init command initialized a new project inside of the React site and deploys resources in the cloud with AWS CloudFormation stacks.

You’ll see a new folder called Amplify in the root of the project and a file called aws-exports.js in the src directory. This folder and files hold the Amplify project configuration.

Step 2: Configure authentication for the Amplify project

To add authentication to the application, use the following command:

amplify add auth

  • Do you want to use default authentication and security configuration? Default configuration
  • How do you want users to be able to sign in when using your Cognito User Pool? Username
  • Do you want to configure advanced settings? No, I am done

Step 3: Configure the API in the Amplify project

To add a GraphQL API to the application, use the following command:

amplify add api

  • Select from one of the above mentioned services: GraphQL
  • Provide API name: farmhubdemo
  • Choose an authorization type for the API: Amazon Cognito User Pool
  • Do you want to configure advanced settings for the GraphQL API? No, I’m done
  • Do you have an annotated GraphQL schema? No
  • Choose a schema template (use arrow keys): Single object with fields (e.g. “Todo” with ID, name, description)
  • Do you want to edit the schema now? Yes

When prompted from your chosen code editor, replace any default text with the schema below:

type Farm @model {
  id: ID!
  user_id: String!  
  field_name: String!
  soil_type: String!
  location: String!
  moisture_level: String!
  timestamp: Int!
}

This completes the configuration required for the Amplify project. To deploy the application, use the following command:

amplify push

  • Are you sure you want to continue? Yes
  • Do you want to generate code for your newly created GraphQL API? Yes
  • Choose the code generation language target: JavaScript
  • Enter the file name pattern of GraphQL queries, mutations and subscriptions: src/graphql/**/*.js
  • Do you want to generate/update all possible GraphQL operations – queries, mutations and subscriptions? Yes
  • Enter maximum statement depth: 2

Step 4: Configuring the frontend React application

The first thing to do is add the Amplify library to the project. This provide modules that simplify the code required to integrate with the AWS services.

Run the following command in the root of your project:

npm install -S aws-amplify && npm install -S aws-amplify-react

To configure the React application to be aware of the new AWS Amplify project, reference the auto-generated aws-exports.js file in the src folder, within the src/index.js file.

Open src/index.js and add the following code below the last import:

import Amplify from 'aws-amplify'
import config from './aws-exports'
Amplify.configure(config)

Now, add the code to the website that will be used to interact with the API. Open src/app.js and add the following code, replacing the default contents:

import React from 'react';
 
// imports from Amplify library
import { API, graphqlOperation, Auth } from 'aws-amplify'
 
// import query definition
import { listFarms } from './graphql/queries'
 
// import the new Amplify authentication component
import { withAuthenticator } from 'aws-amplify-react'
 
class App extends React.Component {
  // define state to hold the data returned from the API
  state = {
    farms: []
  }
 
  // executes the query when the page is rendered in the browser, retrieving data from the API
  async componentDidMount() {
 
    const user = await Auth.currentAuthenticatedUser()
    console.log('user:', user)
    console.log('user info:', user.signInUserSession.idToken.payload)
 
    try {
      const farmData = await API.graphql(graphqlOperation(listFarms))
      console.log('farmData:', farmData)
      this.setState({
        farms: farmData.data.listFarms.items
      })
    } catch (err) {
      console.log('error fetching farms...', err)
    }
  }
  render() {
    return (
      <>
        {
          this.state.farms.map((farm, index) => (
            <div key={index}>
              <p>{farm.user_id}</p>
              <p>{farm.field_name}</p>
              <p>{farm.soil_type}</p>
              <p>{farm.location}</p>
              <p>{farm.moisture_Level}</p>
              <p>{farm.timestamp}</p>
            </div>
          ))
        }
      </>
    )
  }
}
 
export default withAuthenticator(App, { includeGreetings: true })

Feel free to add styling to this site if you wish. Use the following command to start the site on your local system:

yarn start

This command compiles the React site locally. You’ll be able to view and interact with the site on http://localhost:3000

Step 5: Testing the frontend and API

Browse to the React site on your local system and follow the instructions to create and validate a new account. You’ll need to use a valid email address to receive the confirmation code.

Once you have registered an account and signed in, you’ll see a page with a hello message and a sign out button. Next, sign in to the AWS Management Console to test the API and add some data using a GraphQL mutation.

Open the AWS AppSync console and go into the farmhubdemo-dev API. On the left-hand side of the console, navigate to Queries.

The first thing to do is authenticate to Amazon Cognito. To do this, click Login with User Pools and enter the account information your used in the previous step, and then select Login.

Figure 3 – Login screen for access to AppSync API via Amazon Cognito User Pool.

Capgemini

To add some data to the application, execute the following mutation and create a new moisture recording entry:

mutation createFarm {
createFarm(input: {
                  user_id: "[email protected]", 
                  field_name: "Corn field 1 ",
                  soil_type: "Loam Soil",
                  location: "London", 
                  moisture_level: "1.2",
                  timestamp: 687247
} ) {
  user_id
  field_name
  soil_type
  location
  moisture_level
  timestamp
  id
  }
}

If successful, the right-hand side of the console will display the JSON record that’s been written to storage. To validate this, open the Amazon DynamoDB console and then the table that has the prefix of Farm- and select the Items tab. You should see one record:

Figure 4 – Items in the Amazon DynamoDB table.

Capgemini

Make a note of the complete table name, as this will be used in the next section.

Lastly, refresh the React webpage to see the data displayed.

Setting Up the AWS IoT core components

AWS IoT enables internet-connected devices to connect to the AWS Cloud, allowing applications to interact with the physical devices, or to collect and process data from these devices.

This next section walks you through creating the logical IoT device in the IoT Core console, an IoT Rule used to take the data sent in by the IoT device, and add it to the DynamoDB table for our application.

Step 1: Create a “Thing” in AWS IoT Core

Open the AWS IoT console and expand Manage, and then select Things.

Choose Create (or Register a thing if you don’t have any things yet) and then Create a single thing. Specify moisture_thing as the name of your thing and select Next.

Note that you can apply a type to this thing, which simplifies management and provides consistent registry data for things that share a type. You can also add this thing to a group, which allows you to manage several things at once. For this walkthrough, we’ll not configure either of these.

Click Next, and then select the option to Create certificate. This will generate the X.509 certificates used to protect communication between your device and AWS IoT Core.

Figure 5 – Successful creation of IoT device certificate.

Capgemini

Download the certificates, and then choose Activate to activate the X.509 certificate. Finally, choose Attach a policy.

For testing, select the Default policy. Policies are used to provide your device authorization to perform AWS IoT operations, such as subscribing or publishing to a topic.

Next, select Register Thing.

Step 2: Set Up an IoT rule for moving data to your storage

The next thing to do is configure a rule that takes the data sent to the thing and writes it to the DynamoDB table the API will interact with.

From the AWS IoT console, expand Act and then select Rules.

Choose Create a rule. Give the rule a name, moisture_rule, and a description. In the Rule query statement section, add the following IoT SQL statement:

SELECT state.reported.field_data.id as id,
        state.reported.field_data.user_id as user_id,
        state.reported.field_data.field_id as field_id,
        state.reported.field_data.field_name as field_name,
        state.reported.field_data.soil_type as soil_type,
        state.reported.field_data.location as location,
        state.reported.field_data.moisture_level as moisture_level,
        state.reported.field_data.timestamp as timestamp, 
        state.reported.field_data.createdAt as createdAt, 
        state.reported.field_data.updatedAt as updatedAt
FROM  'farmhubcropping/moisture_thing'

This rule query statement listens to the topic farmhubcropping/moisture_thing defined using the FROM condition. This means every device that sends data to this topic will trigger the rule.

When the rule triggers the SELECT clause, it extracts the information from the message.

Next, in the Set one or more actions section, choose Add action.

On the Select an action page, select Split message into multiple columns of a DynamoDB table (DynamoDBv2), and then choose Configure action.

Choose Create a resource and select the DynamoDB table that was created following the test mutation, starting with farm-

Then, choose Create Role to grant the rule the required access to the table. Finally, specify the name farmhub_dynamodb_rule_role and choose Create role.

Figure 6 – IoT Configure Action screen with Table and Role configured.

Capgemini

Choose Add action to add this action to the rule, and then select Create a rule.

Step 3: Test the system

To test the system, create a simulated ‘thing’ using a Node.js script.

Open a terminal window and use the following command to create a new folder named iot_thing:

mkdir iot_thing

Inside the iot_thing folder, create a folder called certs to store the certificates downloaded previously, and the Node.js script that will be used to simulate our moisture IoT device:

cd iot_thing

mkdir certs

touch index.js

Copy the certificate files you downloaded previously to the iot_thing/cert directory. To make it simpler, rename the files as follows:

  • File that ends with certificate.pem.crt to moisture_thing_crt.pem
  • File that ends with private.pem.key to moisture_thing_key.pem

In the terminal, within the iot_thing directory, run the following command to download the Amazon root certificate authority (CA):

wget -O certs/rootCA.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem

You should now have the following folders and files:

Iot_thing    # root folder
|___certs     # folder with certificate files
       |_____moisture_thing_crt.pem   # certificate
       |_____moisture_thing_key.pem   # private key
       |_____rootCA.pem   # Amazon Root CA

In the iot_thing, add the AWS IoT SDK using the following command:

npm i –save aws-iot-device-sdk

Copy the following code in to the index.js file in the iot_thing folder:

// Declare the AWS IoT Device SDK for JavaScript and Node library
const awsiot = require('aws-iot-device-sdk')
 
// Declare the thingName and the topic
const thingName = 'moisture_thing'
const topic = `farmhubcropping/${thingName}`
 
//Declare the aws IoT endpoint
const endpoint = YOUR AWS IOT ENDPOINT' // xxxxxxxxxxxxx-ats.iot.AWS_REGION.amazonaws.com
 
const device = awsiot.device({
   keyPath: `./certs/${thingName}_key.pem`,
  certPath: `./certs/${thingName}_crt.pem`, 
    caPath: `./certs/rootCA.pem`,
  clientId: thingName,
      host: endpoint 
    })
    
   
    let field_data = {
        id: Math.random().toString(36).substr(2, 12),
        user_id: "[email protected]", 
        field_name: "Corn Field",
        soil_type: "Loam Soil",
        location: "London",
        moisture_level: "1",
        timestamp:12345678,
        createdAt: "2021-04-01T15:54:59.713Z",
        updatedAt: "2021-04-01T15:54:59.713Z"
 
    }
 
device.on('connect', () => {
    console.log(`${thingName} is connected to ${endpoint}`)
    device.publish(topic, JSON.stringify({ state:{
                reported: {
                    field_data
                } }}))
})

Within the index.js file, replace the variable “YOUR AWS IOT ENDPOINT” with your own IoT endpoint. This is your custom endpoint that allows you to connect to AWS IoT. Each of your things has a REST API available at this endpoint.

From the AWS IoT console, in the left navigation pane, choose Settings. Your endpoint will be listed in the Device data endpoint section at the top.

From the AWS IoT console, choose Test.

For Subscription topic, enter and then choose Subscribe to topic. We are subscribing to all topics to check if your device is publishing.

In the iot_thing folder on your local system, launch the script index.js with the command:

node index.js

Back in the AWS IoT console, you’ll see the data being sent to the topic:

Figure 7 – Image showing the IoT console capturing incoming data.

Capgemini

As we have set up an IoT Rule, the data has also been added to the DynamoDB table. So, refreshing the website running on your localhost, you will now see a second entry.

Conclusion

With the “Smart Hub Cropping” IoT solution by Capgemini, farmers can get real-time status of agriculture fields, such as soil type and moisture levels, and monitor and execute operations from anywhere.

You can make it easy for farmers to securely share the status of their fields. This enables farmers to maintain their crops to ensure productive growth.

We look forward to seeing how you use this example to start building the future of Smart Hub Cropping with AWS IoT.

Visit us to learn more about AWS and Capgemini, and get in touch with one of our experts.

Internet of Things
...

➦ IT Security Nachrichten ☆ cio.com

➠ Komplette Nachricht lesen


Zur Startseite

➤ Ähnliche Beiträge für 'How Capgemini Uses AWS IoT to Monitor Farmland Through Agricultural Insights'

How Capgemini Uses AWS IoT to Monitor Farmland Through Agricultural Insights

vom 2623.2 Punkte
The human population is predicted to reach around 10 billion by 2050. To sustain the exponential needs of this growth in terms of food and nutrition, our existing farming methods will be stressed to increase yields within the limited supply of available l

Re:invent 2022 Releases sorted

vom 1561.22 Punkte
An overview of all the releases sorted per group. This re:invent was very focused on Data & Analytics. With a total of 42 out of 83 this year. Data & Analytics Sagemaker amazon sagemaker-studio-redesigned-user-interface amazon-sagemaker-jumpstart-enables-share-ml-artifacts-within-organization launch-amazon-sagemaker-aut

Reimagining Digital Transformation with Capgemini’s Digital Cloud Platform for Restaurants on AWS

vom 1189.3 Punkte
The restaurant industry is experiencing an unprecedented transformational change. Business disruptions from the global health crisis prompted the restaurant industry to restructure and diversify its operating model and digital portfolio in response

How Capgemini is Enabling Organizations and Employees to Return to the Office Using AWS Services

vom 1151.76 Punkte
As the world continues to respond to COVID-19, Capgemini is working to find ways to prepare our communities for such pandemics in the future. During this extraordinary time, digital solutions have played a crucial role in enabling employees to work

How Capgemini Simplifies Pandemic Management with AWS Machine Learning Services

vom 1031.95 Punkte
Pandemic is defined by the dictionary as “(of a disease) prevalent throughout an entire country, continent, or the whole world; epidemic over a large area.” Much of 2020 saw one of the worst global pandemics we have faced. The medical situation this raises with

Capgemini’s Trusted Logistics and Drug Counterfeit Solution for the Pharma Industry

vom 961.15 Punkte
The traditional supply chain has a lot of inefficiencies and bottlenecks that can lead to losses and pilferage. There are losses because of logistical inefficiencies, or because perishable goods or drugs may not be transported in the required time pe

Automating Signature Recognition Using Capgemini MLOps Pipeline on AWS

vom 894.57 Punkte
Recognizing a user’s signature is an essential step in banking and legal transactions. The process involves relying on human verification of a signature to establish a person’s identity. However, this can be error prone, time consuming, and li

Capgemini Simplifies the Letter of Credit Process with Amazon Managed Blockchain

vom 767.33 Punkte
A letter of credit (LC) in financial terms is a contractual agreement between a bank, customer, and beneficiary. The bank issues the overall process on behalf of its applicant and authorizes the beneficiary’s bank to complete the money transfer.

Building an Agile Business Rules Engine on AWS

vom 609.92 Punkte
Mutual or insurance companies are often governed by members and have business and/or membership rules that govern membership grants. Such rules are classified as Inclusion rules and Exclusion rules. Inclusion rules are business rules that reward cu

Terraform AWS Secure Baseline - Terraform Module To Set Up Your AWS Account With The Secure Baseline Configuration Based On CIS Amazon Web Services Foundations

vom 497.23 Punkte
Terraform Module RegistryA terraform module to set up your AWS account with the reasonably secure configuration baseline. Most configurations are based on CIS Amazon Web Services Foundations v1.2.0.See Benchmark Compliance to check which items in C

Virtual Build spotlights IoT updates and rollouts

vom 492.75 Punkte
As people around the globe adapt to new ways of working, the Microsoft Build 2020 conference took a new approach as well. Rather than gathering the developer community in person as planned, Microsoft shifted gears and put together 48 hours of streaming co

AWS Credentials: from Environment Variables to credentials_process

vom 475.07 Punkte
If you need to clarify what are the different kinds of AWS Credentials available, how they’re generated, what they’re used for, and what are the best practices to manage them in a proper way, I think you landed in the right spot! Spoiler: we’re g

Team Security Diskussion über How Capgemini Uses AWS IoT to Monitor Farmland Through Agricultural Insights