Upload 3 files

app.py

@@ -0,0 +1,191 @@
+import streamlit as st
+import pandas as pd
+import time
+from datetime import datetime
+import plotly.express as px
+import plotly.graph_objects as go
+from voltage_monitor_ import WeatherSimulator, VoltageMonitor, VoltageStabilizer, NotificationSystem
+
+# Page configuration
+st.set_page_config(
+    page_title="Voltage Monitoring System",
+    page_icon="⚡",
+    layout="wide"
+)
+
+# Initialize session state
+if 'historical_data' not in st.session_state:
+    st.session_state.historical_data = []
+if 'alerts' not in st.session_state:
+    st.session_state.alerts = []
+if 'is_monitoring' not in st.session_state:
+    st.session_state.is_monitoring = False
+
+# Initialize system components
+weather_sim = WeatherSimulator()
+voltage_monitor = VoltageMonitor()
+notification_system = NotificationSystem()
+stabilizer = VoltageStabilizer()
+
+# Function to add alert to session state
+def add_alert(alert):
+    st.session_state.alerts.append(alert)
+
+# Function to clear all alerts
+def clear_alerts():
+    st.session_state.alerts = []
+
+# Title and description
+st.title("⚡ Real-time Voltage Monitoring System")
+st.markdown("""
+This dashboard provides real-time monitoring of voltage levels with weather impact consideration.
+Monitor voltage fluctuations, weather conditions, and system notifications in one place.
+""")
+
+# Alerts Section - Outside the monitoring loop to persist
+if st.session_state.alerts:
+    st.sidebar.divider()
+    st.sidebar.subheader("🚨 Alert History")
+    col_alerts, col_clear = st.sidebar.columns([3, 1])
+    with col_clear:
+        if st.button("Clear Alerts"):
+            clear_alerts()
+    
+    for alert in st.session_state.alerts:
+        severity_color = "red" if alert.get('severity') == "Severe" else "orange"
+        st.sidebar.markdown(
+            f"""
+            <div style='padding: 10px; border-left: 3px solid {severity_color}; margin: 5px 0;'>
+                <small>{alert['timestamp']}</small><br>
+                <strong style='color: {severity_color};'>{alert['severity']} Alert</strong><br>
+                Voltage: {alert['voltage']}V<br>
+                Weather: {alert['weather']}
+            </div>
+            """,
+            unsafe_allow_html=True
+        )
+
+# Sidebar controls
+with st.sidebar:
+    st.header("Control Panel")
+    
+    if not st.session_state.is_monitoring:
+        if st.button("Start Monitoring", type="primary"):
+            st.session_state.is_monitoring = True
+    else:
+        if st.button("Stop Monitoring", type="secondary"):
+            st.session_state.is_monitoring = False
+    
+    st.divider()
+    st.subheader("System Settings")
+    nominal_voltage = st.slider("Nominal Voltage", 200.0, 250.0, 230.0, 0.5)
+    update_interval = st.slider("Update Interval (seconds)", 1, 10, 2)
+
+# Create three columns for metrics
+col1, col2, col3 = st.columns(3)
+
+# Main monitoring loop
+if st.session_state.is_monitoring:
+    placeholder = st.empty()
+    
+    with placeholder.container():
+        # Get current readings
+        weather_data = weather_sim.get_current_weather()
+        current_voltage = voltage_monitor.measure_voltage(weather_data['impact_factor'])
+        voltage_analysis = voltage_monitor.analyze_voltage(current_voltage)
+        
+        # Update historical data
+        st.session_state.historical_data.append({
+            'timestamp': datetime.now(),
+            'voltage': voltage_analysis['voltage'],
+            'weather': weather_data['condition'],
+            'status': voltage_analysis['status'],
+            'severity': voltage_analysis['severity'],
+            'impact_factor': weather_data['impact_factor']
+        })
+        
+        # Add alert if status is not normal
+        if voltage_analysis['status'] != "Normal":
+            add_alert({
+                'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                'voltage': voltage_analysis['voltage'],
+                'weather': weather_data['condition'],
+                'status': voltage_analysis['status'],
+                'severity': voltage_analysis['severity']
+            })
+        
+        # Display current metrics
+        with col1:
+            st.metric(
+                label="Current Voltage",
+                value=f"{voltage_analysis['voltage']}V",
+                delta=f"{voltage_analysis['deviation_percentage']}%",
+                delta_color="inverse"
+            )
+        
+        with col2:
+            st.metric(
+                label="Weather Condition",
+                value=weather_data['condition'],
+                delta=f"Impact: {weather_data['impact_factor']:.2f}"
+            )
+        
+        with col3:
+            status_color = "normal" if voltage_analysis['status'] == "Normal" else "inverse"
+            st.metric(
+                label="System Status",
+                value=voltage_analysis['status'],
+                delta=voltage_analysis['severity'],
+                delta_color=status_color
+            )
+        
+        # Create DataFrame from historical data
+        df = pd.DataFrame(st.session_state.historical_data)
+        
+        # Display charts
+        if not df.empty:
+            # Voltage trend chart
+            fig_voltage = px.line(
+                df,
+                x='timestamp',
+                y='voltage',
+                title='Voltage Trend Over Time'
+            )
+            fig_voltage.add_hline(y=nominal_voltage, line_dash="dash", line_color="green", annotation_text="Nominal")
+            st.plotly_chart(fig_voltage, use_container_width=True)
+            
+            # Weather impact chart
+            col_weather, col_status = st.columns(2)
+            
+            with col_weather:
+                weather_counts = df['weather'].value_counts()
+                fig_weather = px.pie(
+                    values=weather_counts.values,
+                    names=weather_counts.index,
+                    title='Weather Conditions Distribution'
+                )
+                st.plotly_chart(fig_weather)
+            
+            with col_status:
+                status_counts = df['status'].value_counts()
+                fig_status = px.bar(
+                    x=status_counts.index,
+                    y=status_counts.values,
+                    title='Voltage Status Distribution',
+                    labels={'x': 'Status', 'y': 'Count'}
+                )
+                st.plotly_chart(fig_status)
+        
+        # Display historical data table
+        if st.session_state.historical_data:
+            st.divider()
+            st.subheader("Historical Data")
+            df_display = pd.DataFrame(st.session_state.historical_data).tail(50)
+            st.dataframe(df_display, use_container_width=True)
+        
+        # Add a small delay before next update
+        time.sleep(update_interval)
+        st.rerun()
+
+else:
+    st.info("Click 'Start Monitoring' in the sidebar to begin voltage monitoring.")

requirements.txt

@@ -0,0 +1,46 @@
+altair==5.5.0
+attrs==24.3.0
+blinker==1.9.0
+cachetools==5.5.0
+certifi==2024.12.14
+charset-normalizer==3.4.1
+click==8.1.8
+gitdb==4.0.12
+GitPython==3.1.44
+idna==3.10
+Jinja2==3.1.5
+joblib==1.4.2
+jsonschema==4.23.0
+jsonschema-specifications==2024.10.1
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+mdurl==0.1.2
+narwhals==1.21.1
+numpy==2.2.1
+packaging==24.2
+pandas==2.2.3
+pillow==11.1.0
+plotly==5.24.1
+protobuf==5.29.3
+pyarrow==18.1.0
+pydeck==0.9.1
+Pygments==2.19.1
+python-dateutil==2.9.0.post0
+pytz==2024.2
+referencing==0.35.1
+requests==2.32.3
+rich==13.9.4
+rpds-py==0.22.3
+scikit-learn==1.6.0
+scipy==1.15.0
+six==1.17.0
+smmap==5.0.2
+streamlit==1.41.1
+tenacity==9.0.0
+threadpoolctl==3.5.0
+toml==0.10.2
+tornado==6.4.2
+typing_extensions==4.12.2
+tzdata==2024.2
+urllib3==2.3.0
+watchdog==6.0.0

voltage_monitor_.py

@@ -0,0 +1,239 @@
+import numpy as np
+import pandas as pd
+from datetime import datetime, timedelta
+import time
+from typing import Dict, List, Tuple
+import random
+import json
+from sklearn.linear_model import LinearRegression
+
+class WeatherSimulator:
+    """Simulates weather conditions with more dramatic impact on voltage"""
+    
+    def __init__(self):
+        self.weather_conditions = ['Clear', 'Rain', 'Storm', 'Heavy Storm']
+        # Increased impact factors for more dramatic effect
+        self.weather_impact = {
+            'Clear': 1.0,
+            'Rain': 0.85,    # More impact
+            'Storm': 0.65,   # Significant impact
+            'Heavy Storm': 0.45  # Severe impact
+        }
+        # Sudden weather change probability
+        self.sudden_change_prob = 0.1
+    
+    def get_current_weather(self) -> Dict:
+        """Simulates current weather with possible sudden changes"""
+        # Sudden severe weather chance
+        if random.random() < self.sudden_change_prob:
+            condition = 'Heavy Storm'
+            print("\n⚠️ SUDDEN SEVERE WEATHER EVENT DETECTED! ⚠️")
+        else:
+            weights = [0.5, 0.3, 0.15, 0.05]
+            condition = np.random.choice(self.weather_conditions, p=weights)
+        
+        return {
+            'condition': condition,
+            'impact_factor': self.weather_impact[condition],
+            'temperature': round(random.uniform(15, 35), 1),
+            'humidity': round(random.uniform(30, 90), 1),
+            'wind_speed': round(random.uniform(0, 50), 1)
+        }
+
+class VoltageMonitor:
+    """Enhanced voltage monitoring with more sensitive thresholds"""
+    
+    def __init__(self, nominal_voltage: float = 230.0, tolerance: float = 0.1):
+        self.nominal_voltage = nominal_voltage
+        self.tolerance = tolerance
+        self.min_voltage = nominal_voltage * (1 - tolerance)
+        self.max_voltage = nominal_voltage * (1 + tolerance)
+    
+    def measure_voltage(self, weather_impact: float) -> float:
+        """Simulates voltage measurement with more dramatic weather impact"""
+        # Increased base variation
+        base_variation = random.uniform(-10, 10)
+        
+        # More dramatic weather impact
+        weather_variation = (1 - weather_impact) * 40  # Doubled impact
+        
+        # Add sudden spikes during bad weather
+        if weather_impact < 0.7:  # During storms
+            spike_chance = random.random()
+            if spike_chance < 0.3:  # 30% chance of spike
+                weather_variation *= random.uniform(1.5, 2.0)
+                print("\n⚡ VOLTAGE SPIKE DETECTED! ⚡")
+        
+        measured_voltage = self.nominal_voltage + base_variation + weather_variation
+        return round(measured_voltage, 2)
+    
+    def analyze_voltage(self, voltage: float) -> Dict:
+        """Analyzes voltage with detailed status information"""
+        if voltage < self.min_voltage:
+            status = "Low"
+            severity = "Severe" if voltage < self.min_voltage * 0.9 else "Moderate"
+        elif voltage > self.max_voltage:
+            status = "High"
+            severity = "Severe" if voltage > self.max_voltage * 1.1 else "Moderate"
+        else:
+            status = "Normal"
+            severity = "Normal"
+            
+        return {
+            'voltage': voltage,
+            'status': status,
+            'severity': severity,
+            'deviation': round(abs(voltage - self.nominal_voltage), 2),
+            'deviation_percentage': round((abs(voltage - self.nominal_voltage) / self.nominal_voltage) * 100, 2),
+            'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        }
+
+class VoltageStabilizer:
+    """Enhanced voltage stabilization system"""
+    
+    def __init__(self):
+        self.correction_factor = 1.0
+        self.correction_history = []
+    
+    def calculate_correction(self, voltage: float, nominal_voltage: float) -> float:
+        """Calculates required correction with improved accuracy"""
+        base_correction = nominal_voltage / voltage if voltage != 0 else 1.0
+        
+        # Add fine-tuning based on deviation
+        deviation = abs(voltage - nominal_voltage)
+        if deviation > 20:  # Large deviation
+            fine_tune = 0.05  # Additional 5% correction
+            base_correction *= (1 + fine_tune if voltage < nominal_voltage else 1 - fine_tune)
+        
+        return base_correction
+    
+    def apply_correction(self, voltage: float, weather_impact: float) -> float:
+        """Applies voltage correction with weather consideration"""
+        correction = self.calculate_correction(voltage, 230.0)
+        corrected_voltage = round(voltage * correction, 2)
+        
+        self.correction_history.append({
+            'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            'original_voltage': voltage,
+            'corrected_voltage': corrected_voltage,
+            'correction_factor': round(correction, 4)
+        })
+        
+        return corrected_voltage
+
+class NotificationSystem:
+    """Enhanced notification system with detailed alerts"""
+    
+    def __init__(self):
+        self.alert_history = []
+        self.notification_count = 0
+    
+    def check_and_notify(self, voltage_data: Dict, weather_data: Dict) -> None:
+        """Checks conditions and generates detailed notifications"""
+        message = None
+        
+        if voltage_data['status'] != "Normal":
+            message = self._generate_alert_message(voltage_data, weather_data)
+            self.alert_history.append({
+                'timestamp': voltage_data['timestamp'],
+                'message': message,
+                'voltage': voltage_data['voltage'],
+                'weather': weather_data['condition'],
+                'severity': voltage_data['severity']
+            })
+            self.notification_count += 1
+        
+        if message:
+            self._send_notification(message)
+    
+    def _generate_alert_message(self, voltage_data: Dict, weather_data: Dict) -> str:
+        """Generates detailed alert message with severity and recommendations"""
+        severity_symbol = "🔴" if voltage_data['severity'] == "Severe" else "🟡"
+        
+        message = (
+            f"{severity_symbol} VOLTAGE ALERT {severity_symbol}\n"
+            f"Status: {voltage_data['status']} ({voltage_data['severity']})\n"
+            f"Current Voltage: {voltage_data['voltage']}V\n"
+            f"Deviation: {voltage_data['deviation']}V ({voltage_data['deviation_percentage']}%)\n"
+            f"Weather Condition: {weather_data['condition']}\n"
+            f"Time: {voltage_data['timestamp']}\n"
+            f"Recommended Action: "
+        )
+        
+        if voltage_data['severity'] == "Severe":
+            message += "Immediate voltage stabilization required!"
+        else:
+            message += "Monitor situation closely and prepare stabilization if needed."
+        
+        return message
+    
+    def _send_notification(self, message: str) -> None:
+        """Sends formatted notification"""
+        print("\n" + "=" * 60)
+        print("🚨 NOTIFICATION ALERT 🚨")
+        print(message)
+        print("=" * 60 + "\n")
+
+def main():
+    """Main simulation loop with enhanced visualization"""
+    print("Starting Enhanced Weather-based Voltage Monitoring System...")
+    print("Monitoring for voltage fluctuations and weather impacts...\n")
+    
+    weather_sim = WeatherSimulator()
+    voltage_monitor = VoltageMonitor()
+    notification_system = NotificationSystem()
+    stabilizer = VoltageStabilizer()
+    
+    historical_data = []
+    
+    try:
+        while True:
+            # Get weather and measure voltage
+            weather_data = weather_sim.get_current_weather()
+            current_voltage = voltage_monitor.measure_voltage(weather_data['impact_factor'])
+            
+            # Analyze voltage
+            voltage_analysis = voltage_monitor.analyze_voltage(current_voltage)
+            
+            # Store historical data
+            historical_data.append({
+                'timestamp': voltage_analysis['timestamp'],
+                'voltage': voltage_analysis['voltage'],
+                'weather': weather_data['condition'],
+                'status': voltage_analysis['status'],
+                'severity': voltage_analysis['severity']
+            })
+            
+            # Check for notifications
+            notification_system.check_and_notify(voltage_analysis, weather_data)
+            
+            # Apply correction if needed
+            if voltage_analysis['status'] != "Normal":
+                corrected_voltage = stabilizer.apply_correction(
+                    current_voltage, 
+                    weather_data['impact_factor']
+                )
+                print(f"⚡ VOLTAGE CORRECTION APPLIED:")
+                print(f"Original: {current_voltage}V → Corrected: {corrected_voltage}V")
+            
+            # Display current status
+            print(f"\nTime: {voltage_analysis['timestamp']}")
+            print(f"Weather Condition: {weather_data['condition']} "
+                  f"(Impact Factor: {weather_data['impact_factor']:.2f})")
+            print(f"Voltage Status: {voltage_analysis['status']} "
+                  f"({voltage_analysis['severity']})")
+            print(f"Current Voltage: {voltage_analysis['voltage']}V "
+                  f"(Deviation: {voltage_analysis['deviation_percentage']}%)")
+            
+            print("-" * 60)
+            time.sleep(2)
+            
+    except KeyboardInterrupt:
+        print("\nSimulation stopped by user")
+        df = pd.DataFrame(historical_data)
+        df.to_csv('voltage_monitoring_history.csv', index=False)
+        print(f"Total alerts generated: {notification_system.notification_count}")
+        print("Historical data saved to voltage_monitoring_history.csv")
+
+if __name__ == "__main__":
+    main()