JalTantra: Saving 30% Water with IoT

Here's a number that should terrify you: agriculture consumes 70% of the world's freshwater, and nearly half of it is wasted. In India, where most farms still rely on flood irrigation, the waste is even worse — farmers pump groundwater 24/7 on a timer, hoping for the best. I watched my uncle do this every summer, and the result was always the same: some crops drowned, others dried out, and the electricity bill was devastating.

JalTantra (जलतंत्र — "Water Mechanism" in Sanskrit) was born from that frustration. It's not a fancy AI product. It's a $15 embedded system that replaces guesswork with ground-truth data. A capacitive soil moisture sensor tells the microcontroller exactly when to turn the pump on and off. No cloud. No subscription. No internet required.

1. Why Timer-Based Irrigation Fails

The fundamental problem with traditional irrigation is that it operates on time, not need. A sprinkler set to run at 6 AM for 30 minutes doesn't know — or care — that it rained last night. It doesn't adjust for humidity, temperature, or soil type. It just runs.

This creates a cascade of problems:

• Over-watering: Saturated soil leaches nitrogen and potassium, the two nutrients plants need most. You're literally washing away fertilizer.
• Root rot: Waterlogged roots can't absorb oxygen. In our test garden, over-watered tomato plants showed 40% lower yield than optimally-watered ones.
• Groundwater depletion: In western Maharashtra, the water table has dropped 15 meters in the last decade. Timer-based pumping accelerates this crisis.

2. System Architecture

The system is built around the PIC16F877A microcontroller, chosen over Arduino for two reasons: industrial temperature rating (-40°C to +85°C) and a built-in 10-bit ADC with 8 channels. In agricultural environments where temperatures can exceed 45°C in Indian summers, consumer-grade boards fail.

3. Sensor Calibration: The Unsexy Critical Step

The Capacitive Soil Moisture Sensor v1.2 outputs an analog voltage between 0V and 3.3V. But "what does 2.1V mean?" is a question the datasheet doesn't answer — because it depends entirely on your soil type.

We calibrated the sensor empirically across three soil types:

Key learning: The sensor's response is non-linear near the extremes. We used a piecewise linear interpolation rather than a simple map() to improve accuracy in the critical 20-60% range where irrigation decisions are made.

4. Embedded Logic with Hysteresis

The naive approach — "if moisture < 30%, turn on pump; if > 80%, turn off" — works in theory but fails in practice. Why? Because sensor readings fluctuate. A reading hovering around 30% would cause the relay to chatter: on-off-on-off-on-off, dozens of times per minute. This destroys the relay and burns out the pump motor.

The solution is hysteresis — once the pump turns on, it stays on until moisture reaches 80% (not 30%). And once off, it stays off until moisture drops below 30%. This creates a dead zone that prevents oscillation.

#define _XTAL_FREQ 20000000
#define PUMP_RELAY RC0
#define RAIN_PIN   RC1
#define LOW_THRESHOLD   30   // Turn ON below this
#define HIGH_THRESHOLD  80   // Turn OFF above this
#define SAMPLE_COUNT    10   // Readings to average

// State machine: prevents relay chatter
typedef enum { PUMP_OFF, PUMP_ON } PumpState;
PumpState state = PUMP_OFF;

int read_moisture_avg(void) {
    long sum = 0;
    for (int i = 0; i < SAMPLE_COUNT; i++) {
        sum += ADC_Read(0);
        __delay_ms(50);
    }
    int raw = (int)(sum / SAMPLE_COUNT);
    
    // Piecewise linear calibration (red soil)
    if (raw > 820) return 0;
    if (raw > 450) return (820 - raw) * 45 / 370;   // 0-45% range
    if (raw > 180) return 45 + (450 - raw) * 33 / 270; // 45-78% range
    return 78;
}

void main() {
    ADC_Init();
    TRISC0 = 0;  // Pump relay as output
    TRISC1 = 1;  // Rain sensor as input
    LCD_Init();
    GSM_Init();
    
    while(1) {
        int moisture = read_moisture_avg();
        int is_raining = RAIN_PIN;
        
        // Hysteresis state machine
        switch(state) {
            case PUMP_OFF:
                if (moisture < LOW_THRESHOLD && !is_raining) {
                    PUMP_RELAY = 1;
                    state = PUMP_ON;
                    LCD_String("Status: Watering");
                    GSM_Send("PUMP ON | Moisture: %d%%", moisture);
                }
                break;
                
            case PUMP_ON:
                if (moisture > HIGH_THRESHOLD || is_raining) {
                    PUMP_RELAY = 0;
                    state = PUMP_OFF;
                    LCD_String("Status: Optimal");
                    GSM_Send("PUMP OFF | Moisture: %d%%", moisture);
                }
                break;
        }
        
        // Display current readings
        LCD_Line2("Soil: %d%%  %s", moisture, 
                  is_raining ? "RAIN" : "DRY");
        __delay_ms(1000);
    }
}

5. Field Trial Results

We deployed JalTantra in a 500 sq. ft. garden plot in Pune for 90 days (June–August 2024, monsoon season — the hardest test because of unpredictable rainfall). We ran two identical plots side-by-side: one with JalTantra, one with traditional timer-based watering.

The project was recognized as the "Best Eco-Innovation" at the College Tech Fest 2024. But the real validation came from Kisan (farmer) feedback: "If this costs less than ₹2000 ($24), I'll put it in every field."

6. Energy Budget: Running on Solar

For a truly off-grid solution, we calculated the power budget:

• PIC16F877A: ~25mA @ 5V = 125mW
• Soil sensor: ~15mA (active), 0mA (sleep)
• LCD (16×2): ~3mA with backlight off
• GSM (idle): ~15mA, (transmit): ~2A peak for 1s
• Relay coil: ~70mA when active

Total idle power: ~300mW. A single 10W solar panel with a 3.7V 3000mAh LiPo battery provides 48+ hours of autonomy without sunlight. The pump itself runs on a separate 12V supply (car battery or mains).

7. Future: LoRaWAN for Large Farms

For a 500 sq. ft. garden, a single sensor is enough. For a 50-acre commercial farm, you need dozens of sensors spread across different soil zones, and Wi-Fi's 100-meter range won't cut it.

The next version will use LoRaWAN — a low-power, long-range protocol that can transmit sensor data up to 15 km on a single AA battery lasting 2+ years. Data flows to a central gateway, then to AWS IoT Core for predictive analytics: "Based on tomorrow's weather forecast, we recommend skipping the morning watering cycle."