Upload 8 files

app.py

@@ -0,0 +1,77 @@
+from flask import Flask, render_template, request, jsonify, Response
+from flask_bootstrap import Bootstrap
+from flask_sqlalchemy import SQLAlchemy
+from datetime import datetime
+import json
+import plotly 
+import requests
+from device_core import Camera, Sensor
+from models import init_db, Device
+from device_routes import SENSORS, CAMERAS, LIGHTING_DATA
+from config import Config
+from flask import Flask, render_template, jsonify
+from device_blueprints import sensor_blueprint, camera_blueprint
+
+app = Flask(__name__)
+app.config.from_object(Config)
+Bootstrap(app)
+init_db(app)
+
+# from main import app, db, Device
+# app.app_context().push()
+# db.create_all()
+
+app.register_blueprint(sensor_blueprint, url_prefix='/sensors')
+app.register_blueprint(camera_blueprint, url_prefix='/cameras')
+
+# ---------------------------------------------------------------------------------------------
+        
+@app.route('/')
+def home():
+    # Filter sensors based on their types
+    thermo = [sensor for sensor in SENSORS if sensor.id.startswith('t')]
+    ele = [sensor for sensor in SENSORS if sensor.id.startswith('e')]
+
+    # Render the index template with the plot data and sensor lists
+    return render_template('index.html', thermo=thermo, ele=ele, cameras=CAMERAS)
+
+
+@app.route('/lighting-data/', methods=['POST', 'GET'])
+def receive_data():
+    global LIGHTING_DATA
+    print(LIGHTING_DATA)
+
+    try:
+        if request.method == 'POST':
+            address_value = request.json.get('address')
+            intensity_value = request.json.get('value')
+
+            if intensity_value is None:
+                return jsonify({"error": "Value not provided"}), 400
+            if address_value is None:
+                return jsonify({"error": "Address not provided"}), 400
+            address_value = int(address_value)
+
+            LIGHTING_DATA[address_value] = intensity_value
+
+            response = requests.post(f"http://127.0.0.1:1880/", json={"daliData_flask":[address_value, intensity_value]}, timeout=1)
+            response.raise_for_status()
+
+            return jsonify({"address": address_value, "value": intensity_value}), 200
+        
+        elif request.method == 'GET':
+            address_value = request.args.get('address')
+            if not address_value:
+                return jsonify({"error": "Address not provided"}), 400
+            address_value = int(address_value)
+            intensity_value = LIGHTING_DATA.get(address_value, 0)
+
+            return jsonify({"address": address_value, "value": intensity_value}), 200
+    
+    except requests.RequestException as e:
+        print("debug")
+        return jsonify({"error": str(e)}), 500
+
+
+if __name__ == '__main__':
+    app.run(host='localhost', port=5000, debug=True)

camesa.py

@@ -0,0 +1,30 @@
+import cv2
+
+# Replace with your camera's RTSP URL
+rtsp_url = 'rtsp://169.254.0.99:554/live.sdp'
+rtsp_url = 0
+
+# Create a VideoCapture object
+cap = cv2.VideoCapture(rtsp_url)
+
+while True:
+    # Capture frame-by-frame
+    ret, frame = cap.read()
+
+    # If frame is read correctly, ret is True
+    if not ret:
+        print("Can't receive frame (stream end?). Exiting ...")
+        break
+
+    # Display the resulting frame
+    cv2.imshow('IP Camera stream', frame)
+
+    # Press 'q' on keyboard to exit
+    if cv2.waitKey(1) == ord('q'):
+        break
+
+# When everything done, release the VideoCapture object
+cap.release()
+
+# Close all OpenCV windows
+cv2.destroyAllWindows()

config.py

@@ -0,0 +1,3 @@
+class Config:
+    SQLALCHEMY_DATABASE_URI = 'sqlite:///devices.db'
+    # Other configurations

device_blueprints.py

@@ -0,0 +1,85 @@
+from flask import Blueprint, render_template, jsonify, request, Response
+from models import Device, db  # Assuming Device is your database model from models.py
+from device_core import Sensor, Camera  # Import your Sensor class
+from device_routes import SENSORS, CAMERAS  # Import your SENSORS list
+import json
+import plotly
+
+sensor_blueprint = Blueprint('sensor_blueprint', __name__, template_folder='templates')
+camera_blueprint = Blueprint('camera_blueprint', __name__, template_folder='templates')
+
+@sensor_blueprint.route('/plot/<sensor_id>')
+def generate_plot(sensor_id):
+    sensor = Sensor.find(SENSORS, sensor_id)  # Assuming SENSORS is accessible here
+    if not sensor:
+        return jsonify({"error": "Sensor not found"}), 404
+
+    fig = sensor.plot(Device, title=sensor.name)
+    return json.dumps(fig, cls=plotly.utils.PlotlyJSONEncoder)
+
+
+@sensor_blueprint.route('/postplain/', methods=['POST'])
+def post_plain():
+    data = request.get_json()
+    if not data:
+        return jsonify({'message': 'No input data provided'}), 400
+
+    device_id = data.get('id')
+    device_values = data.get('values')
+    device_units = data.get('units')
+
+    if device_values and device_id:
+        sensor = Sensor.find(SENSORS, device_id)
+        if sensor:
+            sensor.update_values(device_values, device_units)
+
+            device = Device(
+                sensor_id=device_id,
+                name=sensor.name,
+                time=sensor.time,
+            )
+
+            for i, value in enumerate(sensor.values):
+                setattr(device, f"value{i + 1}", value)
+            for i, unit in enumerate(sensor.units):
+                setattr(device, f"unit{i + 1}", unit)
+
+            db.session.add(device)
+            db.session.commit()
+
+            return jsonify({'message': 'Success!'}), 200
+        else:
+            return jsonify({'message': 'Sensor not found'}), 404
+    else:
+        return jsonify({'message': 'Missing data'}), 400
+    
+
+# -------------- CAMERA ROUTES --------------
+
+
+@camera_blueprint.route('/video_feed/<camera_id>')
+def stream_camera(camera_id):
+    """
+    Stream the video feed from a specific camera.
+    """
+    camera = next((cam for cam in CAMERAS if cam.id == camera_id), None)
+    if not camera:
+        return Response("Camera not found or could not be opened", status=404)
+    
+    return Response(camera.gen_frames(), mimetype='multipart/x-mixed-replace; boundary=frame')
+
+
+@camera_blueprint.route('/refresh_camera')
+def refresh_camera():
+    success = True
+    message = "All cameras refreshed successfully."
+    
+    for cam in CAMERAS:
+        cam.close_camera()
+        try:
+            cam.__init__(cam.id, cam.name, cam.index)
+        except:
+            success = False
+            message = "Error occurred while refreshing cameras."
+            
+    return jsonify({"success": success, "message": message})

device_core.py

@@ -0,0 +1,156 @@
+import cv2
+from datetime import datetime, timedelta
+from plotly.subplots import make_subplots
+import plotly.graph_objects as go
+import threading
+import os
+import time
+
+class Camera:
+    def __init__(self, id, name, index=0, fps=1, save_duration=0.1, rtsp=None):
+        self.name = name
+        self.id = id
+        self.fps = fps
+        self.save_duration = save_duration
+        self.index = rtsp if rtsp else index
+
+        # Initialize camera in a separate thread to avoid blocking
+        self.out = None
+        self.cap = None
+        self.frame_width = 1980
+        self.frame_height = 720
+        self.frame_count = 0
+        self.start_time = time.time()
+        self.initialization_thread = threading.Thread(target=self.initialize_camera)
+        self.initialization_thread.start()
+
+    def initialize_camera(self):
+        self.cap = cv2.VideoCapture(self.index)
+        self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, self.frame_width)
+        self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, self.frame_height)
+        self.cap.set(cv2.CAP_PROP_FPS, self.fps)
+
+        # Wait for camera to open or timeout after 10 seconds
+        start_time = time.time()
+        while not self.cap.isOpened():
+            time.sleep(0.1)
+            if time.time() - start_time > 10:  # 10 seconds timeout
+                print(f"Timeout: Unable to open camera {self.id} - {self.name}")
+                break
+
+
+    def save_frame(self, frame):
+        filename = "video/frames/frame_{}.jpg".format(self.frame_count)
+        cv2.imwrite(filename, frame)
+        self.frame_count += 1
+
+    def create_video_from_frames(self):
+        filename = "video/outpy_{}.mp4".format(time.strftime("%Y%m%d-%H%M%S"))
+        self.out = cv2.VideoWriter(filename, cv2.VideoWriter_fourcc(*'mp4v'), self.fps, (self.frame_width, self.frame_height))
+        for i in range(self.frame_count):
+            frame = cv2.imread("video/frames/frame_{}.jpg".format(i))
+            self.out.write(frame)
+            os.remove("video/frames/frame_{}.jpg".format(i))
+        self.out.release()
+        self.frame_count = 0
+
+    def gen_frames(self):
+        i = 0
+        if not self.cap or not self.cap.isOpened():
+            yield b''  # Return empty bytes if camera is not available
+            return
+        while True:
+            success, frame = self.cap.read()
+            if not success:
+                break
+            else:
+                if i % 20 == 0:
+                    self.save_frame(frame)
+                ret, buffer = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 100])
+                frame = buffer.tobytes()
+                yield (b'--frame\r\n'
+                       b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')
+                i += 1
+                if time.time() - self.start_time > self.save_duration * 3600:
+                    self.create_video_from_frames()
+                    self.start_time = time.time()
+
+    def close_camera(self):
+        try:
+            self.cap.release()
+        except: print("No camera to release")
+        try:
+            self.out.release()
+        except: print("No video to release")
+
+
+class Sensor:
+    def __init__(self, id, name):
+        self.id = id
+        self.name = name
+        self.time = datetime.now()
+        self.measurement = ["Spotřeba","Napětí","Výkon","Teplota","Vlhkost","Vlhkost"]
+        self.values = [12,None,50,None,None,None]  # store sensor values in a dictionary
+        self.units = ["A","V","D",None,None,None]  # store sensor units in a dictionary
+
+    def update_values(self, data, units):
+        self.values = [round(float(d), 4) for d in data]
+        self.units = units
+        self.time = datetime.now()
+        print(self.values, self.units)
+
+    def find(devices, id):
+        for device in devices:
+            if device.id == id:
+                return device
+        return None  # device not found
+
+    def plot(self, Db_class, title = "graph"):
+        # Get the current date and time
+        now = datetime.now()
+
+        # Calculate the date and time 10 days ago
+        ten_days_ago = now - timedelta(days=300)
+
+        # Query the database for records from the last 10 days
+
+        ele_1 = Db_class.query.filter(Db_class.sensor_id == self.id, Db_class.time >= ten_days_ago).all()
+
+        x = [record.time for record in ele_1]
+        y1 = [record.value4 for record in ele_1]
+        y2 = [record.value3 for record in ele_1]  # Assuming value2 exists
+
+        fig = make_subplots(specs=[[{"secondary_y": True}]])
+
+        # Add traces
+        fig.add_trace(
+            go.Scatter(x=x, y=y1, name="Spotřeba['kWh'])"),
+            secondary_y=False,
+        )
+
+        fig.add_trace(
+            go.Scatter(x=x, y=y2, name="Aktuální výkon['W']"),
+            secondary_y=True,
+        )
+
+        fig.update_layout(
+            autosize=True,
+            title=title,
+            width=1200,
+            height=512,
+            margin=dict(
+                l=40,
+                r=20,
+                b=20,
+                t=60,
+                pad=2
+            ),
+            paper_bgcolor='#F5F5F5',
+            plot_bgcolor='#FFFFFF'
+        )
+
+        fig.update_xaxes(title_text='Datum a čas')
+        fig.update_yaxes(title_text="Spotřeba [kWh]", secondary_y=False)
+        fig.update_yaxes(title_text="Aktuální výkon [W]", secondary_y=True)
+
+        return fig

device_routes.py

@@ -0,0 +1,20 @@
+from device_core import Camera, Sensor
+
+# Define devices
+SENSORS = [
+    Sensor("e1", "elektro spodní byt"),
+    Sensor("e2", "elektro horní byt"),
+    Sensor("e3", "elektro dílna"),
+    Sensor("e4", "elektro čerpadlo"),
+    Sensor("t1", "teplota spodní kuchyň"),
+    Sensor("t2", "teplota horní kuchyň"),
+    Sensor("t3", "teplota půda"),
+    Sensor("t4", "teplota venkovní"),
+]
+
+CAMERAS = [
+    #Camera(id="c1", name="Garáže", rtsp='rtsp://169.254.0.99:554/live.sdp'),
+    Camera(id="c2", name="Kůlna", index=0)
+]
+
+LIGHTING_DATA = {}

models.py

@@ -0,0 +1,27 @@
+from flask_sqlalchemy import SQLAlchemy
+from datetime import datetime
+
+db = SQLAlchemy()
+
+class Device(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    time = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
+    sensor_id = db.Column(db.String(64), nullable=False)
+    name = db.Column(db.String(50), nullable=False)
+    value1 = db.Column(db.Float, nullable=False)
+    value2 = db.Column(db.Float)
+    value3 = db.Column(db.Float)
+    value4 = db.Column(db.Float)
+    value5 = db.Column(db.Float)
+    value6 = db.Column(db.Float)
+    unit1 = db.Column(db.String(10))
+    unit2 = db.Column(db.String(10))
+    unit3 = db.Column(db.String(10))
+    unit4 = db.Column(db.String(10))
+    unit5 = db.Column(db.String(10))
+    unit6 = db.Column(db.String(10))
+
+def init_db(app):
+    db.init_app(app)
+    with app.app_context():
+        db.create_all()

requirements.txt

@@ -0,0 +1,6 @@
+pip install Flask 
+pip install Flask-SQLAlchemy 
+pip install Flask-Bootstrap 
+pip install plotly 
+pip install requests 
+pip install opencv-python