How We Won Smart India Hackathon: The Inside Story

1. The Problem Statement: PS-1289 Smart Irrigation

The prompt issued by the Ministry of Agriculture was deceptive in its apparent simplicity: "Build an intelligent, low-cost precision irrigation system that conserves water by automatically activating field pumps based on soil moisture gradients."

Most competitor teams fell into the classic engineering trap: they tried to build everything. They demonstrated speculative drone imagery, blockchain crop certificate marketplaces, and mobile apps with 20 input forms. But they overlooked the harsh operational reality of rural Indian farms:

• Zero Connectivity: Fields in rural Maharashtra, Rajasthan, or Bihar do not have reliable 4G cellular coverage or Wi-Fi.
• Severe Power Fluctuations: Agricultural single-phase and three-phase power lines experience frequent brownouts and voltage surges.
• Corrosive Soil Chemistry: Resistive copper moisture prongs corrode via electrolysis within 48 hours, outputting false readings that drown crops.

2. The 36-Hour Sprint Timeline

Chronology of the 36-Hour National Sprint

• H 00–06 Topology Design Selected LoRa 433MHz star topology over Wi-Fi
• H 06–16 Hardware Assembly Embedded C firmware on PIC microcontroller & relays
• H 16–22 Cloud Integration Attempted GSM MQTT uplink to AWS Lambda
• H 22–26 The Crisis & ADR GSM link collapsed; drafted offline edge ADR
• H 26–32 Edge Rewrite Local SQLite WAL queue & edge threshold engine
• H 32–36 Rehearsal & Pitch Rehearsed the physical "cable pull" demo 5 times

3. The Hour 25 Emergency Pivot: ADR-001

When the GSM module dropped 94% of packets inside the auditorium at 3:00 AM, we realized that our cloud-centric architecture was our single point of failure. We formally recorded our decision as an Architecture Decision Record (ADR):

# ADR-001: Transition from Cloud Lambda to Edge Gateway Autonomy
Date: 2023-12-20 (Hour 25 of SIH Finale)
Status: ACCEPTED

## Context
1. The hackathon venue exhibits severe RF attenuation (-98 dBm on GSM/GPRS bands).
2. Live jury demonstration in 5 hours requires 100% reliable pump actuation.
3. Rural farmland mirrors this exact connectivity constraint.

## Decision
1. Decouple pump actuation from AWS Lambda completely.
2. Deploy the irrigation decision matrix locally on the Raspberry Pi edge gateway.
3. Use local SQLite with Write-Ahead Logging (WAL) as the primary transaction ledger.
4. Convert cloud sync into an asynchronous, best-effort background daemon with exponential backoff.

## Consequences
+ System is completely immune to network dropouts during live jury evaluation.
+ Pump decision latency drops from ~1,400ms (cloud roundtrip) to <80ms (local edge).
+ Cloud dashboard operates via eventually consistent sync when connectivity resumes.
- Requires local RTC clock or NTP fallback for time-of-day irrigation scheduling.

Architecture Comparison Matrix

4. Edge Hardware Architecture & LoRa Protocol

The deployed field station consisted of three decoupled hardware units:

• Sensor End-Nodes Capacitive soil moisture sensor (v1.2, corrosion-proof) + DHT22 temperature/humidity sensor interfaced via ADC to a low-power microcontroller.
• Radio Uplink (LoRa SX1278) Operating at 433 MHz with +20 dBm transmission power, achieving 3.5 km line-of-sight range across heavy agricultural foliage.
• Edge Gateway & Optoisolated Actuator Industrial Raspberry Pi gateway driving an optoisolated 10A 250V AC relay with snubber circuit protection against pump inductive kickback.

5. Local Offline Gateway Implementation

Below is the production Python state machine we wrote between 3:30 AM and 5:00 AM. It listens on the LoRa serial UART, calculates evapotranspiration thresholds, trips the relay, and commits the transaction to local SQLite:

import time
import serial
import sqlite3
import json

class EdgeIrrigationController:
    def __init__(self, port="/dev/ttyUSB0", baud=9600, db_path="local_telemetry.db"):
        self.ser = serial.Serial(port, baud, timeout=2.0)
        self.db = sqlite3.connect(db_path, check_same_thread=False)
        self.init_db()

    def init_db(self):
        with self.db:
            # Enable WAL mode for high-concurrency non-blocking local commits
            self.db.execute("PRAGMA journal_mode=WAL;")
            self.db.execute("""
                CREATE TABLE IF NOT EXISTS sensor_logs (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    node_id TEXT,
                    moisture_vwc REAL,
                    temp_c REAL,
                    pump_status INTEGER,
                    timestamp REAL,
                    synced_to_cloud INTEGER DEFAULT 0
                )
            """)

    def evaluate_irrigation(self, moisture_vwc: float, temp_c: float) -> bool:
        """
        Determines irrigation actuation locally without any cloud connection.
        Volumetric Water Content (VWC) < 32% triggers pump unless extreme heat
        suggests mid-day evaporative loss (postpones to evening cycle).
        """
        if moisture_vwc < 30.0 and temp_c < 38.0:
            return True  # Activate pump
        return False

    def process_packet(self):
        raw = self.ser.readline().decode('utf-8', errors='ignore').strip()
        if not raw.startswith("{") or not raw.endswith("}"):
            return
        
        try:
            data = json.loads(raw)
            node_id = data["node"]
            vwc = float(data["vwc"])
            temp = float(data["temp"])
            
            should_pump = self.evaluate_irrigation(vwc, temp)
            pump_int = 1 if should_pump else 0
            
            # Direct physical relay actuation over local GPIO
            # gpio.output(RELAY_PIN, gpio.HIGH if should_pump else gpio.LOW)
            
            with self.db:
                self.db.execute(
                    "INSERT INTO sensor_logs (node_id, moisture_vwc, temp_c, pump_status, timestamp) "
                    "VALUES (?, ?, ?, ?, ?)",
                    (node_id, vwc, temp, pump_int, time.time())
                )
            print(f"[EDGE ACTUATED] Node: {node_id} | VWC: {vwc}% | Pump: {'ON' if should_pump else 'OFF'}")
        except Exception as e:
            print(f"Packet parse error: {e}")

6. The "Pull the Cable" Judging Moment

At 9:30 AM, our judging panel arrived. Two of the judges had inspected twelve consecutive booths, watching student after student apologize for failed cloud API calls and Wi-Fi disconnects.

When our turn came, we did not start with PowerPoint slides. I reached behind our edge gateway, visibly yanked the Ethernet cable out, and placed the severed cable on the table:

The lead judge smiled, turned to his colleagues, and said: "Finally. An engineering team that understands real Indian agriculture."

7. Engineering Lessons from Hackathon Battlegrounds

8. Post-Hackathon Takeaways

Winning Smart India Hackathon taught our team that world-class engineering is not about using the newest buzzword framework; it is about building software and hardware that solves real physical constraints under adverse conditions.

Award

1st Prize Winner • Smart India Hackathon 2023 Hardware Edition (Govt. of India)

Tech Stack

Embedded C, PIC16F877A, LoRa SX1278, Raspberry Pi, Python 3.11, SQLite WAL

Repository

github.com/kulkarnishub377/SIH-AgroTechies