📈 Pressure TRENDS - The Most Important Indicator!

🛠️ Hardware: Pressure Sensors

🔌 Wiring BME280 to ESP32

═══════════════════════════════════════════════════════════════════════════════
                    BME280 BAROMETRIC PRESSURE SENSOR
═══════════════════════════════════════════════════════════════════════════════

    BME280 Breakout                    ESP32 Dev Board
    ════════════════                    ════════════════
    
    VCC (3.3V/5V)      ─────────────►  3.3V
    GND                ─────────────►  GND
    SDA                ─────────────►  GPIO21 (I2C SDA)
    SCL                ─────────────►  GPIO22 (I2C SCL)
    
    Optional: Some boards have CSB (chip select) and SDO (address select)
    Leave unconnected for I2C mode.

═══════════════════════════════════════════════════════════════════════════════
                    MULTIPLE SENSORS ON SAME I2C BUS
═══════════════════════════════════════════════════════════════════════════════

    You can connect multiple I2C sensors to the same SDA/SCL pins!
    Each sensor needs a unique address.
    
    BME280 default address: 0x76 (SDO LOW) or 0x77 (SDO HIGH)
    
    To change address connect SDO to GND = 0x76, to 3.3V = 0x77

═══════════════════════════════════════════════════════════════════════════════

💻 Complete Barometric Pressure Code with Trend Analysis

/*
 * Professional Barometric Pressure Monitor
 * Predicts weather from pressure trends
 * 
 * Features:
 * - Real-time pressure reading with BME280/BMP280
 * - Trend calculation (1h, 3h, 6h, 24h)
 * - Weather prediction based on pressure changes
 * - Storm alerts and frost warnings
 * - Historical data storage
 * - OceanRemote cloud integration
 */

#include 
#include 
#include 
#include 
#include 
#include 

// ========== WIFI CONFIGURATION ==========
const char* ssid = "YOUR_WIFI";
const char* password = "YOUR_PASSWORD";
const char* oceanRemoteToken = "YOUR_TOKEN";

// ========== I2C PINS ==========
#define I2C_SDA 21
#define I2C_SCL 22

Adafruit_BME280 bme;
ESP32Time rtc;
Preferences preferences;

// ========== PRESSURE TRACKING ==========
const int MAX_HISTORY = 144;  // 72 hours at 30 min intervals
float pressureHistory[MAX_HISTORY];
unsigned long timestampHistory[MAX_HISTORY];
int historyIndex = 0;
int historyCount = 0;

// ========== ALTITUDE CORRECTION ==========
float stationAltitude = 0;  // meters above sea level
float seaLevelPressure = 0;

// ========== WEATHER PREDICTION ==========
struct WeatherPrediction {
    String condition;
    String forecast;
    String recommendation;
    int confidence;  // 0-100%
};

// ========== CALCULATE PRESSURE TREND ==========
float calculateTrend(int hours) {
    if (historyCount < hours * 2) return 0;  // Need enough data (30 min intervals)
    
    int samples = hours * 2;  // 30 min intervals
    int currentIdx = (historyIndex - 1 + MAX_HISTORY) % MAX_HISTORY;
    int pastIdx = (historyIndex - 1 - samples + MAX_HISTORY) % MAX_HISTORY;
    
    float pressureNow = pressureHistory[currentIdx];
    float pressurePast = pressureHistory[pastIdx];
    
    return (pressureNow - pressurePast) / hours;  // hPa per hour
}

// ========== GET WEATHER PREDICTION ==========
WeatherPrediction getWeatherPrediction(float pressure, float trend1h, float trend3h) {
    WeatherPrediction wp;
    
    // Clear weather conditions
    if (pressure > 1020 && trend1h > -0.5 && trend3h > -0.5) {
        wp.condition = "☀️ Clear & Stable";
        wp.forecast = "Fair weather next 24-48 hours";
        wp.recommendation = "✅ Perfect for planting, harvesting, and spraying";
        wp.confidence = 85;
    }
    else if (pressure > 1015 && trend1h > 0) {
        wp.condition = "🌤️ Clearing";
        wp.forecast = "Improving conditions, rain ending";
        wp.recommendation = "✅ Good time for field work";
        wp.confidence = 80;
    }
    // Rain approaching
    else if (trend1h < -1.5 && trend3h < -2) {
        wp.condition = "🌧️ Storm Approaching!";
        wp.forecast = "Heavy rain within 12-24 hours";
        wp.recommendation = "🚨 EMERGENCY: Skip irrigation, secure equipment, check drainage!";
        wp.confidence = 90;
    }
    else if (trend1h < -0.8 && trend3h < -1.5) {
        wp.condition = "🌧️ Rain Likely";
        wp.forecast = "Rain expected within 24-48 hours";
        wp.recommendation = "⚠️ Reduce irrigation by 50%, prepare for wet conditions";
        wp.confidence = 75;
    }
    else if (trend1h < -0.3 && trend3h < -0.5) {
        wp.condition = "☁️ Deteriorating";
        wp.forecast = "Cloudy, possible light rain";
        wp.recommendation = "Monitor conditions, reduce irrigation by 25%";
        wp.confidence = 65;
    }
    // Stable conditions
    else if (abs(trend1h) < 0.3 && abs(trend3h) < 0.5) {
        wp.condition = "➡️ Stable";
        wp.forecast = "Current conditions will continue";
        wp.recommendation = "Maintain normal operations";
        wp.confidence = 70;
    }
    // High pressure drop rate warning
    else if (trend1h < -2.5) {
        wp.condition = "🌀 Rapid Pressure Drop!";
        wp.forecast = "SEVERE STORM possible within 6-12 hours!";
        wp.recommendation = "⚠️⚠️ TAKE IMMEDIATE ACTION: Secure all equipment, check livestock shelters!";
        wp.confidence = 85;
    }
    else {
        wp.condition = "❓ Variable";
        wp.forecast = "Mixed conditions expected";
        wp.recommendation = "Monitor local sky conditions";
        wp.confidence = 50;
    }
    
    return wp;
}

// ========== READ PRESSURE WITH ALTITUDE CORRECTION ==========
float readPressure() {
    float rawPressure = bme.readPressure() / 100.0F;  // Convert Pa to hPa
    
    // If we have station altitude, correct to sea level
    if (stationAltitude > 0) {
        // Standard atmosphere formula: P0 = P * (1 - L*h/T0)^(-gM/RL)
        // Simplified approximation
        float correction = stationAltitude / 8.4;
        rawPressure = rawPressure + correction;
    }
    
    return rawPressure;
}

// ========== GET PRESSURE TREND TEXT ==========
String getTrendText(float trend) {
    if (trend > 1.5) return "📈 Rapidly Rising (+" + String(trend, 1) + " hPa/h)";
    if (trend > 0.5) return "⬆️ Rising (+" + String(trend, 1) + " hPa/h)";
    if (trend > -0.5) return "➡️ Stable (" + String(trend, 1) + " hPa/h)";
    if (trend > -1.5) return "⬇️ Falling (" + String(trend, 1) + " hPa/h)";
    return "📉 Rapidly Falling (" + String(trend, 1) + " hPa/h)";
}

// ========== CHECK FOR FROST RISK ==========
bool checkFrostRisk(float pressure, float temperature) {
    // High pressure + clear skies + low temperature = frost risk
    if (pressure > 1020 && temperature < 5) {
        return true;
    }
    return false;
}

// ========== SEND TO OCEANREMOTE ==========
void sendToOceanRemote(float pressure, float trend1h, float trend3h, WeatherPrediction wp) {
    if (WiFi.status() != WL_CONNECTED) return;
    
    HTTPClient http;
    http.begin("https://api.oceanremote.net/device/state");
    http.addHeader("Content-Type", "application/x-www-form-urlencoded");
    
    String data = "token=" + String(oceanRemoteToken);
    data += "&pressure=" + String(pressure);
    data += "&trend_1h=" + String(trend1h);
    data += "&trend_3h=" + String(trend3h);
    data += "&weather_condition=" + wp.condition;
    data += "&forecast=" + wp.forecast;
    data += "&recommendation=" + wp.recommendation;
    data += "&confidence=" + String(wp.confidence);
    
    http.POST(data);
    http.end();
}

// ========== DISPLAY PRESSURE REPORT ==========
void displayPressureReport(float pressure, float trend1h, float trend3h, 
                           float trend6h, float trend24h, WeatherPrediction wp,
                           float temperature, float humidity) {
    Serial.println("\n╔══════════════════════════════════════════════════════════════╗");
    Serial.println("║                    📊 BAROMETRIC PRESSURE REPORT             ║");
    Serial.println("║                    " + rtc.getTime("%Y-%m-%d %H:%M:%S") + "                  ║");
    Serial.println("╚══════════════════════════════════════════════════════════════╝");
    
    Serial.println("\n📍 CURRENT CONDITIONS:");
    Serial.printf("   🌡️ Temperature: %.1f°C\n", temperature);
    Serial.printf("   💧 Humidity: %.1f%%\n", humidity);
    Serial.printf("   📊 Pressure: %.1f hPa\n", pressure);
    
    Serial.println("\n📈 PRESSURE TRENDS:");
    Serial.printf("   1-hour trend:  %s\n", getTrendText(trend1h).c_str());
    Serial.printf("   3-hour trend:  %s\n", getTrendText(trend3h).c_str());
    Serial.printf("   6-hour trend:  %s\n", getTrendText(trend6h).c_str());
    Serial.printf("   24-hour trend: %s\n", getTrendText(trend24h).c_str());
    
    Serial.println("\n🌤️ WEATHER PREDICTION:");
    Serial.printf("   %s (Confidence: %d%%)\n", wp.condition.c_str(), wp.confidence);
    Serial.printf("   📋 Forecast: %s\n", wp.forecast.c_str());
    
    Serial.println("\n🎯 FARM RECOMMENDATION:");
    Serial.printf("   %s\n", wp.recommendation.c_str());
    
    // Frost alert
    if (checkFrostRisk(pressure, temperature)) {
        Serial.println("\n❄️❄️ FROST ALERT! ❄️❄️");
        Serial.println("   High pressure + clear skies + low temperature = frost risk!");
        Serial.println("   → Cover sensitive crops");
        Serial.println("   → Irrigate before dawn (water releases heat)");
    }
    
    Serial.println("\n══════════════════════════════════════════════════════════════\n");
}

// ========== STORE PRESSURE READING ==========
void storePressureReading(float pressure) {
    pressureHistory[historyIndex] = pressure;
    timestampHistory[historyIndex] = millis();
    historyIndex = (historyIndex + 1) % MAX_HISTORY;
    if (historyCount < MAX_HISTORY) historyCount++;
}

// ========== CONNECT TO WIFI ==========
void connectWiFi() {
    Serial.print("📡 Connecting to WiFi");
    WiFi.begin(ssid, password);
    int attempts = 0;
    while (WiFi.status() != WL_CONNECTED && attempts < 30) {
        delay(1000);
        Serial.print(".");
        attempts++;
    }
    if (WiFi.status() == WL_CONNECTED) {
        Serial.println("\n✅ WiFi connected!");
        
        // Sync time
        configTime(0, 0, "pool.ntp.org", "time.nist.gov");
        delay(2000);
        struct tm timeinfo;
        if (getLocalTime(&timeinfo)) {
            rtc.setTimeStruct(timeinfo);
        }
    } else {
        Serial.println("\n⚠️ WiFi connection failed - running offline");
    }
}

// ========== LOAD ALTITUDE SETTINGS ==========
void loadSettings() {
    preferences.begin("weather", false);
    stationAltitude = preferences.getFloat("altitude", 0);
    preferences.end();
    
    if (stationAltitude > 0) {
        Serial.printf("📍 Station altitude: %.0f meters above sea level\n", stationAltitude);
        Serial.println("🔄 Correcting pressure to sea level for weather prediction\n");
    } else {
        Serial.println("⚠️ Altitude not set! For accurate sea-level pressure, set stationAltitude\n");
    }
}

void setup() {
    Serial.begin(115200);
    delay(1000);
    
    Serial.println("═══════════════════════════════════════════");
    Serial.println("📊 PROFESSIONAL BAROMETRIC MONITOR v2.0");
    Serial.println("   Weather Prediction Using Pressure Trends");
    Serial.println("═══════════════════════════════════════════\n");
    
    // Initialize I2C
    Wire.begin(I2C_SDA, I2C_SCL);
    
    // Initialize BME280
    if (!bme.begin(0x76)) {
        Serial.println("❌ BME280 not found at 0x76, trying 0x77...");
        if (!bme.begin(0x77)) {
            Serial.println("❌ BME280 sensor not found! Check wiring.");
            while (1) delay(100);
        } else {
            Serial.println("✅ BME280 initialized at 0x77");
        }
    } else {
        Serial.println("✅ BME280 initialized at 0x76");
    }
    
    // Load settings
    loadSettings();
    
    // Connect to WiFi
    connectWiFi();
    
    // Initialize arrays
    for (int i = 0; i < MAX_HISTORY; i++) {
        pressureHistory[i] = 1013.25;
    }
    
    Serial.println("\n✅ Barometric monitor ready!");
    Serial.println("   Data will be recorded every 30 minutes\n");
}

void loop() {
    static unsigned long lastReading = 0;
    static unsigned long lastSend = 0;
    unsigned long now = millis();
    
    // Read sensors every 30 minutes (1,800,000 ms)
    if (now - lastReading >= 1800000) {
        float temperature = bme.readTemperature();
        float humidity = bme.readHumidity();
        float pressure = readPressure();
        
        storePressureReading(pressure);
        
        // Calculate trends
        float trend1h = calculateTrend(1);
        float trend3h = calculateTrend(3);
        float trend6h = calculateTrend(6);
        float trend24h = calculateTrend(24);
        
        // Get weather prediction
        WeatherPrediction wp = getWeatherPrediction(pressure, trend1h, trend3h);
        
        // Display report
        displayPressureReport(pressure, trend1h, trend3h, trend6h, trend24h, wp, temperature, humidity);
        
        // Send to OceanRemote
        if (WiFi.status() == WL_CONNECTED) {
            sendToOceanRemote(pressure, trend1h, trend3h, wp);
        }
        
        lastReading = now;
    }
    
    // Quick display every hour (optional)
    static unsigned long lastQuickDisplay = 0;
    if (now - lastQuickDisplay >= 3600000) {
        float currentPressure = readPressure();
        float trend1h = calculateTrend(1);
        Serial.printf("📊 Pressure: %.1f hPa | Trend: %.2f hPa/h\n", currentPressure, trend1h);
        lastQuickDisplay = now;
    }
    
    delay(1000);
}
    

┌─────────────────────────────────────────────────────────────────────────────┐
│                    PRESSURE TREND QUICK REFERENCE GUIDE                     │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│   RATE (hPa/3h)  │  TREND          │  WEATHER        │  FARM ACTION        │
│   ═══════════════╪═════════════════╪═════════════════╪═════════════════════╪
│   +6 to +9       │ Rapidly Rising  │ Clearing, windy │ Secure structures   │
│   +2 to +5       │ Rising          │ Improving       │ Good field work     │
│   -1 to +1       │ Stable          │ Same conditions │ Normal operations   │
│   -2 to -5       │ Falling         │ Rain possible   │ Reduce irrigation  │
│   -6 to -9       │ Rapidly Falling │ STORM COMING!   │ EMERGENCY ACTION    │
│   < -10          │ Crashing        │ SEVERE WEATHER  │ Take cover!          │
│                                                                             │
│   REMEMBER: Pressure tells you WHAT'S COMING, not what's currently happening│
│   The faster the change, the more severe the weather!                       │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

×