AdvancedIrrigationStrategy

determineIrrigationAmount$($double moistureLevel, String weatherCondition,

double cropWaterRequirement$)$:

This method calculates the optimal amount of water needed for irrigation

considering the current soil moisture level, weather condition, and specific

water requirements of the crop.

adjustIrrigationSchedule$()$:

This method dynamically adjusts the irrigation schedule based on real$-$time

sensor data, weather forecasts, and crop water demand.

considerSoilTypeAndTopography$()$:

This method takes into account the soil type and topography of the field to

adjust irrigation strategies accordingly.

Develop a SmartIrrigationSystem class that coordinates the interaction between

sensors and irrigation strategies. This class should have methods to collect data from

sensors $($user inputs$)$ and invoke appropriate irrigation strategies.

Use the existing SmartIrrigationSystem class to include methods for crop

management, such as monitorCropHealth$()$ and applyFertilizer$().$

Implement classes for any $2$ types of crops, each inheriting from a common Crop

superclass. Each crop class should include properties such as growth stage, nutrient

requirements, and susceptibility to diseases.

Create interfaces for the decision$-$making module, such as DecisionMaker, with

methods like makeIrrigationDecision$(),$ makeFertilizationDecision$(),$ and

makePestControlDecision$().$

Implement concrete classes that implement the DecisionMaker interface.

Include additional functionality, such as detecting pest presence or measuring nutrient

levels in the soil.

Incorporate a menu interface component that allows farmers to interact with the system,

view sensor data, and adjust settings for crop management.

Develop classes to represent different types of livestock, such as cattle, poultry, and

sheep, each inheriting from a common Livestock superclass. Include properties such as

health status, diet requirements, and production metrics $($e$.$g$.,$ milk yield, egg

production$).$

Implement classes for managing livestock health and productivity, with properties such

as LivestockHealthMonitor and LivestockProductionManager, with methods to

monitor health indicators, administer medication, and optimize feeding schedules.

Enhance the menu interface to provide farmers with insights into both crop and

livestock health, enabling them to make informed decisions for overall farm

productivity.

Implement messages to notify farmers of potential health issues or production anomalies

in crops and livestock Project $2$: Smart Farming

You can choose to work in groups of $2$ or $3$ or individually $($Please complete on time if

individual$).$ You can select your group members from the people's list on canvas, email and

ask them for forming groups.

If you are working in groups, you must write your partner's name on top of the file when

submitting on canvas. If you are working individually, you must write that you have worked

individually on the project. Please also submit your. java files and outputs screenshots.

Grading Policy

Some classes$/$interfaces are given to you in this document. If you need any more classes or

interfaces, using your own creativity, you can create required classes, interfaces, methods,

objects, arraylists, functionality and interlink them with details $-15$ points.

Required Outputs $-15$ points.

Task Description

In this project, you are required to implement a simulation of a Smart Farming system. you

should assume that some input values $($user inputs$)$ are coming from Sensors, since we are not

incorporating sensor hardware's in this project. Before starting this project, research about the

domain of smart farming and try to understand about the required inputs and outputs.

Configure them as needed.

Here, you are supposed to model various types of sensors and irrigation strategies.

Define an interface named Sensor with methods to read sensor data such as

readMoistureLevel$(0$ and readWeatherCondition$().$

Implement classes SoilMoistureSensor and WeatherSensor that inherit from the

Sensor interface. These classes should simulate sensors to read soil moisture levels and

weather conditions, respectively.

Create an abstract class named IrrigationStrategy with methods such as

determineIrrigationAmount $)$ and scheduleIrrigation$().$

Implement concrete subclasses of IrrigationStrategy, such as BasicIrrigationStrategy

and AdvancedIrrigationStrategy, which utilize different algorithms to determine when

and how much to irrigate based on sensor data.

BasicIrrigationStrategy:

determineIrrigationAmount$($double moistureLevel, String weatherCondition$)$:

This method calculates the amount of water needed for irrigation based on the

current soil moisture level and weather condition.

It may use simple heuristics or predefined thresholds to determine the

irrigation amount.

scheduleIrrigation$()$:

This method schedules irrigation sessions based on predetermined intervals or

fixed times of the day.

It does not take into account dynamic factors such as weather forecasts or soil

moisture trends.