1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
#!/usr/bin/python3
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
import argparse
from datetime import datetime, timedelta
import matplotlib.dates as mdates
import sqlite3
def read_data_from_db(db_name):
"""
Liest alle gespeicherten Temperatur- und Zeitstempeldaten aus der SQLite-Datenbank.
:param db_name: Name der SQLite-Datenbankdatei
:return: Liste von Tupeln mit (timestamp, temperature)
"""
try:
# Verbindung zur Datenbank herstellen
conn = sqlite3.connect(db_name)
cursor = conn.cursor()
# Abfrage zum Abrufen aller Daten aus der Tabelle
cursor.execute("SELECT timestamp, temperature FROM cpu_temperature")
data = cursor.fetchall() # Alle Ergebnisse abrufen
conn.close() # Verbindung schließen
return data
except sqlite3.Error as e:
print(f"Fehler beim Lesen aus der Datenbank: {e}")
return []
# Funktion zum Erstellen des Temperaturdiagramms mit Achsenbeschriftungen und Transparenz
def create_temperature_plot_with_labels(output_filename):
db_name = "/var/www/html/cpu_temperature.db"
records = read_data_from_db(db_name)
if records:
for timestamp, temperature in records:
print(f"Zeit: {timestamp}, Temperatur: {temperature}°C")
else:
print("Keine Daten gefunden.")
# Aktuelle Zeit und Filterzeitraum (letzte 24 Stunden)
now = datetime.now()
last_24_hours = now - timedelta(hours=24)
# Filtern der Datensätze nach den letzten 24 Stunden
filtered_records = [
(datetime.strptime(timestamp, "%Y-%m-%d %H:%M:%S"), temperature)
for timestamp, temperature in records
if datetime.strptime(timestamp, "%Y-%m-%d %H:%M:%S") >= last_24_hours
]
if not filtered_records:
print("Keine Daten in den letzten 24 Stunden gefunden.")
return
# Extrahieren von Zeitstempeln und Temperaturen aus den gefilterten Datensätzen
times = [timestamp for timestamp, _ in filtered_records]
temperatures = [temperature for _, temperature in filtered_records]
# Grenzen für die y-Achse basierend auf den Temperaturdaten
min_temp = np.floor(min(temperatures) / 5) * 5 # Abrunden auf das nächste Vielfache von 5
max_temp = np.ceil(max(temperatures) / 5) * 5 # Aufrunden auf das nächste Vielfache von 5
# Temperaturdiagramm zeichnen
plt.figure(figsize=(8, 2), dpi=100) # Größe des Diagramms: 800x100 Pixel
plt.plot(times, temperatures, color='yellow', linewidth=2, label='Temperatur')
plt.ylim(min_temp, max_temp) # Y-Achse auf den Bereich der Daten begrenzen
plt.xlabel('Uhrzeit', color='white') # X-Achsenbeschriftung
plt.ylabel('CPU Temp in °C', color='white') # Y-Achsenbeschriftung
plt.xticks(color='white') # X-Achse beschriften (automatisch), gedreht für bessere Lesbarkeit
plt.yticks(np.arange(min_temp, max_temp + 1, 5), color='white') # Y-Achse in Schritten von 5 beschriften
plt.grid(color='white', linestyle='--', linewidth=0.5, alpha=0.7)
plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
plt.tight_layout()
# Diagramm mit transparentem Hintergrund speichern
plt.savefig(output_filename, transparent=True, bbox_inches='tight')
plt.close()
# Funktion zum Laden und Überprüfen des Basisbildes
def load_and_check_base_image(image_path):
try:
base_image = Image.open(image_path)
if base_image.size != (1024, 768):
raise ValueError("Das Basisbild muss eine Größe von 1024x768 Pixeln haben.")
return base_image
except Exception as e:
print(f"Fehler beim Laden des Basisbildes: {e}")
return None
# Funktion zum Überlagern des Diagramms auf das Basisbild
def overlay_plot_on_image(base_image_path, plot_image_path, output_image_path):
try:
base_image = Image.open(base_image_path)
plot_image = Image.open(plot_image_path)
# Überlagern des Diagramms auf das Basisbild (mit Transparenz)
base_image.paste(plot_image, (112, 0), plot_image) # Zentrieren: (1024 - 800) / 2 = 112
# Kombiniertes Bild speichern
base_image.save(output_image_path)
print(f"Kombiniertes Bild gespeichert als {output_image_path}")
except Exception as e:
print(f"Fehler beim Überlagern des Diagramms: {e}")
# Hauptfunktion
def main():
parser = argparse.ArgumentParser(description="Overlay transparentes Temperaturdiagramm auf ein Bild.")
parser.add_argument("image", help="Pfad zum Basisbild (1024x768 Pixel)")
parser.add_argument("output", help="Pfad zum kombinierten Ausgabebild")
args = parser.parse_args()
base_image_path = args.image
output_image_path = args.output
# Temporäre Datei für das transparente Temperaturdiagramm
plot_filename = "temperature_plot_with_labels.png"
# Schritte ausführen: Diagramm erstellen und überlagern
create_temperature_plot_with_labels(plot_filename)
overlay_plot_on_image(base_image_path, plot_filename, output_image_path)
if __name__ == "__main__":
main()
|
