157 lines
4.5 KiB
Python
157 lines
4.5 KiB
Python
import os
|
|
import json
|
|
import time
|
|
import requests
|
|
import dash
|
|
import dash_core_components as dcc
|
|
import dash_html_components as html
|
|
from dash.dependencies import Input, Output
|
|
import plotly.graph_objects as go
|
|
from dotenv import load_dotenv
|
|
from datetime import datetime
|
|
import sqlite3
|
|
|
|
# Load environment variables for credentials
|
|
load_dotenv()
|
|
|
|
# Function to get token for OwenCloud
|
|
def get_token():
|
|
login = os.getenv("LOGIN")
|
|
password = os.getenv("PASSWORD")
|
|
if not login or not password:
|
|
raise ValueError("Логин или пароль не заданы в .env")
|
|
|
|
data = {'login': login, 'password': password}
|
|
headers = {"Content-Type": "application/json", "Accept": "application/json"}
|
|
req = requests.post("https://api.owencloud.ru/v1/auth/open/", json=data, headers=headers)
|
|
|
|
if req.status_code == 200:
|
|
answer = req.json()
|
|
token = "Bearer " + answer["token"]
|
|
return token
|
|
else:
|
|
print(f"Ошибка авторизации: {req.status_code}, {req.text}")
|
|
return None
|
|
|
|
# Function to fetch device data
|
|
def fetch_device_data(device_id, token, codes_to_search):
|
|
headers = {'Authorization': token}
|
|
data = json.dumps({'filter': ''})
|
|
|
|
req = requests.post(f"https://api.owencloud.ru/v1/device/{device_id}", data=data, headers=headers)
|
|
|
|
if req.status_code != 200:
|
|
print(f"Ошибка запроса устройства: {req.status_code}, {req.text}")
|
|
return None
|
|
|
|
response = req.json()
|
|
result = {}
|
|
|
|
# Process parameters to check if they are among the codes we need
|
|
if 'parameters' in response and isinstance(response['parameters'], list):
|
|
for item in response['parameters']:
|
|
if isinstance(item, dict) and 'code' in item and item['code'] in codes_to_search:
|
|
result[item['code']] = item['value']
|
|
|
|
return result
|
|
|
|
# SQLite Database Setup
|
|
def init_db():
|
|
conn = sqlite3.connect('device_data.db')
|
|
c = conn.cursor()
|
|
c.execute('''
|
|
CREATE TABLE IF NOT EXISTS device_data (
|
|
timestamp TEXT,
|
|
code TEXT,
|
|
value REAL
|
|
)
|
|
''')
|
|
conn.commit()
|
|
conn.close()
|
|
|
|
# Function to store device data in the database
|
|
def store_data(timestamp, code, value):
|
|
conn = sqlite3.connect('device_data.db')
|
|
c = conn.cursor()
|
|
c.execute('''
|
|
INSERT INTO device_data (timestamp, code, value)
|
|
VALUES (?, ?, ?)
|
|
''', (timestamp, code, value))
|
|
conn.commit()
|
|
conn.close()
|
|
|
|
# Initialize Dash app
|
|
app = dash.Dash(__name__)
|
|
|
|
# List of codes to monitor
|
|
codes_to_search = [
|
|
"P16385", "P16386", "P16387", "P16388", "P16389", "P16390", "P16391",
|
|
"P16392", "P16393", "P16394", "P16395", "P16396", "P16397", "P16398"
|
|
]
|
|
|
|
device_id = "459205"
|
|
token = get_token()
|
|
|
|
# Data structure to store the collected data for each device code
|
|
collected_data = {code: [] for code in codes_to_search}
|
|
timestamps = []
|
|
|
|
# Generate a Plotly figure
|
|
def generate_figure():
|
|
fig = go.Figure()
|
|
for code in codes_to_search:
|
|
fig.add_trace(go.Scatter(
|
|
x=timestamps, y=collected_data[code], mode='lines', name=code
|
|
))
|
|
|
|
fig.update_layout(
|
|
title="Real-time Device Data Comparison",
|
|
xaxis_title="Time",
|
|
yaxis_title="Value",
|
|
template="plotly_dark"
|
|
)
|
|
return fig
|
|
|
|
# Function to update data every 10 seconds and store it in the database
|
|
def update_data():
|
|
global timestamps
|
|
data = fetch_device_data(device_id, token, codes_to_search)
|
|
if data:
|
|
# Get current timestamp
|
|
timestamp = datetime.now().strftime("%H:%M:%S")
|
|
timestamps.append(timestamp)
|
|
|
|
# Update the collected data for each device and store it in the database
|
|
for code in codes_to_search:
|
|
if code in data:
|
|
value = data[code]
|
|
collected_data[code].append(value)
|
|
store_data(timestamp, code, value)
|
|
|
|
# Dash layout
|
|
app.layout = html.Div([
|
|
html.H1("Real-time Device Data Comparison"),
|
|
dcc.Graph(id='live-update-graph'),
|
|
dcc.Interval(
|
|
id='interval-component',
|
|
interval=10000, # Update every 10 seconds
|
|
n_intervals=0
|
|
)
|
|
])
|
|
|
|
# Callback to update the graph
|
|
@app.callback(
|
|
Output('live-update-graph', 'figure'),
|
|
Input('interval-component', 'n_intervals')
|
|
)
|
|
def update_graph(n_intervals):
|
|
# Update data
|
|
update_data()
|
|
|
|
# Generate the updated figure
|
|
return generate_figure()
|
|
|
|
# Run the Dash app
|
|
if __name__ == '__main__':
|
|
init_db() # Initialize the database
|
|
app.run_server(debug=True)
|