php:
Stimmt, wäre nicht sonderlich perfomant die Daten vom Server per Flask zu Client zu übertragen und dann nochmal zurück zum (php) Server zum Rechnen..
JavaScript:
Wer rechnet da? der Server oder der Client?
Python:
..wäre es am geschicktesten per python (Server) zu rechnen und per Flask mitzusenden?
Wie bekomme ich den Inhalt in eine php Variable zum rechnen?
Sprich wie bekomme ich die Zahl von zB "Umgebung_Aussen" in die Varaible T2
Ziel:
$Leistung = 4190 / 3600 * $M1 * ($T2 - $T1);
$Leistung = round($Leistung,0);
echo "<div class='Menge_Solarkreis'> <span id=Solar></span> l/h; $Leistung W</div>";Funktionert!
Vielen Dank!
Im Beitrag „Kann man den Inhalt einer Python variable nach PHP übergeben?" habe ich gelernt, wie man mit Flask Daten bereitstellt.
Nun möchte ich die sich ständig ändernden Daten auf meiner Webpage darstellen.
Aufgrund meine bescheidenen Kenntnisse / nicht vorhanden Kenntnisse in Ajax komme ich nicht weiter.
Hier mein Code zur Orientierung. (funktioniert nicht)
Quelldaten stehen unter http://91.67.114.141:9000/sensors bereit.
Kann mir jemand beim Formulieren des richtigen Syntax helfen?
<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js"></script>
<title>AJAX und flask</title>
</head>
<body>
<h1>Demo für AJAX und flask</h1>
<p>Die aktuelle Temperatur des Sensors "Umgebung_Aussen" ist <span id=$array[0]°C></span></p>
<p>Die aktuelle Temperatur des Sensors "Speicher_Oben" ist <span id=$array[1]°C></span></p>
<script>
function updateSensors()
{
fetch( "http://91.67.114.141:9000/sensors" )
.then( response => {
if( !response.ok )
throw new Error( "fetch failed" ) ;
return response.json() ;
} )
.then( json.sensors => $array=document.querySelector("#Umgebung_Aussen").textContent, ("#Speicher_Oben").textContent ;
.catch( error => alert(error) ) ;
}
updateSensors() ;
setInterval( updateSensors, 30000 ) ;
</script>
</body>
</html>Hier mal zum reinschauen: http://91.67.114.141/page_hydraulis…ischer_plan.php
#!/usr/bin/python
# -*- coding: utf-8 -*-
import MySQLdb # für Datenbank
import sys # für Bildschirmausbage in Datei
import os # für File exists Abfrage
import time # für Warteschleifen
import threading # für Unterprogramme
import RPi.GPIO as GPIO # für Ein- und Ausgaben
import math # für Sonnenauf- und untergangberechnung
import subprocess # zum Abschalten der Unterprogramme
import datetime # zur Überprüfung des Datenbankzeitstempel
# from Solar_GPIOs_abfragen_sub import *
#-----------------------------------------------------------------SETTINGS----------------------------------------------------------------------------
# Dateien
mess_file='Solar_GPIOs_abfragen.txt' # Mengenergebnisse zyklisch dem Datenbankprg übergeben
Ausgabe_file='Solar_GPIOs_abfragen.log' # Log Meldungen für Status ausgeben
Ausgabe_file2='Solar_crontab.log' # Log Meldungen für Messdaten
config_file='Solar_config.txt' # Konfiguartionsfile
GPIO_file='Solar_GPIOs_abfragen.txt' # Ausgabe des GPIO Status
# Bereiche für T Plausibiliät
dead_max = 80
dead_min = -50
dead_hi = -0.02 # -0.02
dead_lo = -0.08
T_oben_max = 65 # Max Speichertemperatur (wenn erreicht, dann Schwimmbadbetrieb bzw. abschalten, default 65)
T_oben_min = 60 # Min Speichertemperatur (w#
......
--------------------------------------------------------------------HAUPTPROGRAMM -------------------------------------------------------------------
save_stderr = sys.stderr # Fehlermeldungen in Datei umleiten
fh = open("errors.txt","a")
sys.stderr = time.strftime("%d.%m.%Y - %H:%M:%S Uhr"), fh
Unterprogramm_Log=threading.Thread(target=Log)
Unterprogramm_Mengenmessungen=threading.Thread(target=Mengenmessungen)
Unterprogramm_Sonnenauf_untergang=threading.Thread(target=Sonnenauf_untergang)
Unterprogramm_Solarkreis=threading.Thread(target=Solarkreis)
Unterprogramm_Zirkulation=threading.Thread(target=Zirkulation)
Unterprogramm_Datenbankmessungen=threading.Thread(target=Datenbankmessungen)
Unterprogramm_Heizungsunterstuetzung=threading.Thread(target=Heizungsunterstuetzung)
try:
GPIOs_setzen()
Unterprogramm_Sonnenauf_untergang.start() # Unterprogramm für Sonnenaufgang und Untergang starten
Unterprogramm_Zirkulation.start() # Unterprogramm für Zirkulationspumpe starten
Unterprogramm_Solarkreis.start() # Unterprogramm für Solarkreis starten
Unterprogramm_Mengenmessungen.start() # Unterprogramm für Mengenmessungen starten
Unterprogramm_Log.start() # Unterprogramm für Log file starten
Unterprogramm_Datenbankmessungen.start() # Unterprogramm für Datenbankmessungen starten
Unterprogramm_Heizungsunterstuetzung.start() # Unterprogramm für Heizungsunterstuetzung starten
while OK:
..........
except KeyboardInterrupt:
GPIO.cleanup()
jetzt = time.strftime("%d.%m.%Y - %H:%M:%S Uhr")
file_Ausgabe = open(Ausgabe_file,"a")
file_Ausgabe.write(jetzt + " Programm beendet. Grund: Abbruch durch User\n")
#sys.stdout = save_stdout # Ausgabe zurück auf Bilschirm
sys.stderr = save_stderr
fh.close()
OK = False
print " Abbruch"
except:
GPIO.cleanup(); time.sleep(1); GPIOs_setzen()
jetzt = time.strftime("%d.%m.%Y - %H:%M:%S Uhr")
file_Ausgabe = open(Ausgabe_file,"a")
file_Ausgabe.write(jetzt + " Programm beendet. Grund: Fehler - reboote..\n")
sys.stdout = save_stdout # Ausgabe zurück auf Bilschirm
sys.stderr = save_stderr
fh.close()
os.system("reboot")
finally:
OK=False
GPIO.setmode(GPIO.BOARD)
GPIO.cleanup()
time.sleep(5)
sys.exit(1)
GPIO.cleanup(); time.sleep(1); GPIOs_setzen() # this ensures a clean exit
jetzt = time.strftime("%d.%m.%Y - %H:%M:%S Uhr")
file_Ausgabe = open(Ausgabe_file,"a")
file_Ausgabe.write(jetzt + " Programm beendet. Grund: fertig\n")
sys.stdout = save_stdout # Ausgabe zurück auf Bilschirm
sys.stderr = save_stderr
fh.close()Versuch das mal über die Kommandozeile zu starten. Ggf mit disableten debugger.
Super, klappt!
Und es ist auch ein schlechtes Vorgehen, threads einfach auf Modulebene zu starten. Mach das sauber in einer Funktion, und ruf die in main auf.
Hm, ich bin nicht genug Pytonianer, um zu verstehen was du meinst. Mein Hauptprogramm besteht aus
Try: hier werden all Threads gestartet und auch Flask
Except: Keyboard Interrupts, ... abzufangen
Finally: Um Gpios, Filehandler, ... zurückzusetzten
Mit den Sachen ___main___ usw. kenne ich mich gar nicht aus. Ist das was mit objektorientierter Programmierung? (kenne ich nur als Schlagwort)
Und zu guter letzt: du machst garantiert einen Fehler, wenn du so viele threads laufen lassen willst. Maximal einer. Der muss dann ggf mehrere Aufgaben erledigen, aber ich verspreche dir, mit so vielen Threads verhedderst du dich.
Die Treats laufen alle autark. Einzige Schnittmenge is das loggen.
statt das "OK" auf oberster Ebene zu nutzen solltest du threading.Event benutzen, um den Thread etwas "mitzuteilen". Der ist der besserer und sauberer Weg.
Die OK Methode hat mich auch schon immer gestört, kannte bisher keine Alternative. Dasmit dem threading.Event schaue ich mir mal genauer an.
In der finalen Version werden 8 Threads mit unterschiedlichen Aufgaben laufen – aber jeder Thread darf natürlich nur einmal existieren; nicht zweimal.
Die gezeigte Version ist zu Demonstrationzwecken.
Thread_1 startet zweimal und läuft auch zweimal. Dasselbe gilt für Thread_2
E sieht so aus, dass der zweite Start der Threats nach der Flaskausgabe „Restarting with stat“ erfolgt.
An die Python Gemeinde,
Im Beitrag Kann man den Inhalt einer Python variable nach PHP übergeben? habe ich erste Schritte mit Flask gemacht. Das funktioniert auch soweit.
Nun bei der Umsetzung des gelernten habe ich das Problem, dass meine dazu gebauten Threads zweimal gestartet werden.
Hier ein vereinfachter Code zur Demonstration und die dazugehörige Konsolenausgabe.
Meine Frage: Woran liegt das? – in der Hoffnung einige Codezeilen zur Lösungsfindung zu bekommen.
#!/usr/bin/python
# -*- coding: utf-8 -*-
from flask import Flask, jsonify
import time
import threading
import datetime
def Thread_1():
print time.strftime("%d.%m.%Y - %H:%M:%S Uhr") + ' Starte Thread_1'
while OK:
time.sleep(30)
print time.strftime("%d.%m.%Y - %H:%M:%S Uhr") + ' Thread_1 - ping/30s'
def Thread_2():
print time.strftime("%d.%m.%Y - %H:%M:%S Uhr") + ' Starte Thread_2'
while OK:
time.sleep(30)
print time.strftime("%d.%m.%Y - %H:%M:%S Uhr") + ' Thread_2 - ping/30s'
OK= True
Unterprogramm_Thread_1=threading.Thread(target=Thread_1)
Unterprogramm_Thread_2=threading.Thread(target=Thread_2)
Unterprogramm_Thread_1.start()
Unterprogramm_Thread_2.start()
app = Flask( __name__ )
@app.route( "/uhrzeit" )
def uhrzeit():
now = datetime.datetime.now()
timeString = now.strftime("%Y-%m-%d %H:%M:%S")
response = jsonify( {"uhrzeit": timeString} )
response.headers.add( "Access-Control-Allow-Origin", "*" )
return response
if __name__ == "__main__":
app.run(host='0.0.0.0', port=9000, debug=True) Konsolenausgabe:
root@RP1-Solarthermie:/home/pi# python forum.py
01.03.2020 - 16:51:08 Uhr Starte Thread_1
01.03.2020 - 16:51:08 Uhr Starte Thread_2
* Serving Flask app "forum" (lazy loading)
* Environment: production
WARNING: This is a development server. Do not use it in a production deployment.
Use a production WSGI server instead.
* Debug mode: on
* Running on http://0.0.0.0:9000/ (Press CTRL+C to quit)
* Restarting with stat
01.03.2020 - 16:51:13 Uhr Starte Thread_1
01.03.2020 - 16:51:13 Uhr Starte Thread_2
* Debugger is active!
* Debugger PIN: 734-062-809
01.03.2020 - 16:51:38 Uhr Thread_1 - ping/30s
01.03.2020 - 16:51:38 Uhr Thread_2 - ping/30s
01.03.2020 - 16:51:43 Uhr Thread_1 - ping/30s
01.03.2020 - 16:51:43 Uhr Thread_2 - ping/30s
01.03.2020 - 16:52:08 Uhr Thread_1 - ping/30s
01.03.2020 - 16:52:08 Uhr Thread_2 - ping/30s
01.03.2020 - 16:52:13 Uhr Thread_1 - ping/30s
01.03.2020 - 16:52:13 Uhr Thread_2 - ping/30s
01.03.2020 - 16:52:38 Uhr Thread_1 - ping/30s
01.03.2020 - 16:52:38 Uhr Thread_2 - ping/30s
01.03.2020 - 16:52:43 Uhr Thread_1 - ping/30s
01.03.2020 - 16:52:43 Uhr Thread_2 - ping/30s
01.03.2020 - 16:53:08 Uhr Thread_1 - ping/30s
01.03.2020 - 16:53:08 Uhr Thread_2 - ping/30s
01.03.2020 - 16:53:13 Uhr Thread_1 - ping/30s
01.03.2020 - 16:53:13 Uhr Thread_2 - ping/30s
01.03.2020 - 16:53:38 Uhr Thread_1 - ping/30s
01.03.2020 - 16:53:38 Uhr Thread_2 - ping/30s
01.03.2020 - 16:53:43 Uhr Thread_1 - ping/30s
01.03.2020 - 16:53:43 Uhr Thread_2 - ping/30sEs funktioniert!
Ich hatte an der ganz falschen Stelle gebstelt, da CORS scheinbar eine Sache zwischen Browser und Apache ist.
Ein dickes Dankeschön and Tell und Hofei für die Unterstützung!
Ein (sehr kleines) Stück weiter.
Habe auf meiner Raspberry2 mit Stretch nun auch die CORS Anbindung installiert (sudo pip install -U flask-cors).
Jetzt kommt die Anfrage von index.html bei Flask an:
root@RP1-Solarthermie:/home/pi# python server.py
* Serving Flask app "server" (lazy loading)
* Environment: production
WARNING: This is a development server. Do not use it in a production deployment.
Use a production WSGI server instead.
* Debug mode: on
* Running on http://0.0.0.0:9000/ (Press CTRL+C to quit)
* Restarting with stat
* Debugger is active!
* Debugger PIN: 230-414-328
192.168.178.99 - - [23/Feb/2020 22:05:26] "GET /uhrzeit HTTP/1.1" 200 -
192.168.178.99 - - [23/Feb/2020 22:05:36] "GET /uhrzeit HTTP/1.1" 200 -
192.168.178.99 - - [23/Feb/2020 22:05:46] "GET /uhrzeit HTTP/1.1" 200 -
192.168.178.99 - - [23/Feb/2020 22:05:56] "GET /uhrzeit HTTP/1.1" 200 -Aber auf der Webseite kommt noch nichts an.
Fehlermeldung:
Quellübergreifende (Cross-Origin) Anfrage blockiert: Die Gleiche-Quelle-Regel verbietet das Lesen der externen Ressource auf http://192.168.178.17:9000/uhrzeit. (Grund: CORS-Kopfzeile 'Access-Control-Allow-Origin' fehlt).Den Header einsetzeten war jedoch nicht erfolgreich (https://enable-cors.org/server_apache.html)
Weder mit Header set Access-Control-Allow-Origin "*" noch mit konkreter url.
Probiert habe ich es in allen Bereichen wie im obigigen link angeben - ohne Erfolg.
Noch jemand eine Idee?
Habe die jQuery Quelle eingefügt (veränderte index.html anbei, da ich mich nicht sicher in der Materie bewege). Jedoch keine Veränderung.
Auch
habe ich, nach Tells Hinweis auf den "Browser Debugger gegoogelt. Ich wusste
bis eben nicht, dass ein solcher existiert. (so viel zu meinen Kenntnisstand
Meldung aus dem Debugger: „Fehler beim Laden der folgenden Adresse: Unknown source“
..heißt wohl, auf <IP>:9000/uhrzeit so zuzugreifen geht nicht…
Aber wie sonst?
<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<script src="https://code.jquery.com/jquery-latest.js"></script>
<title>AJAX und flask</title>
</head>
<body>
<h1>Demo für AJAX und flask</h1>
<p>Die aktuelle Uhzeit ist <span id="uhrzeit"></span></p>
<script type=text/javascript>
function updateUhrzeit()
{
$.getJSON("http://192.168.178.17:9000/uhrzeit",
function (data)
{
$("#uhrzeit").text(data.uhrzeit);
}
);
}
setInterval( updateUhrzeit, 1000 ) ;
</script>
</body>
</html>... müsste Apaches access.log nicht die url zeigen und bei jeden Schleifendurchgang erneut einen Eintrag machen?
Momentan gibt es nur einen Eintrag, wenn ich die index.html aufrufe.
Uhzeit liegt an der genannten url an. Der flask debugger meldet nichts zurück (kein Zugriff, aber auch kein Fehler). Apaches access.log:
192.168.178.99 - - [23/Feb/2020:17:41:55 +0100] "GET / HTTP/1.1" 200 710 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:73.0) Gecko/20100101 Firefox/73.0"Habe es probiert, bekomme es aber nicht hin. Mit dem beiliegenden Code funktionert es nicht.
<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>AJAX und flask</title>
</head>
<body>
<h1>Demo für AJAX und flask</h1>
<p>Die aktuelle Uhzeit ist <span id="uhrzeit"></span></p>
<script type=text/javascript>
function updateUhrzeit()
{
$.getJSON("http://192.168.178.17:9000/uhrzeit",
function (data)
{
$("#uhrzeit").text(data.uhrzeit);
}
);
}
setInterval( updateUhrzeit, 1000 ) ;
</script>
</body>
</html>/Guten Abend,
Die Daten per flask an einem Port bereitzustellen geht nun.
Zu Demonstrationszwecke habe ich am oben genannten Code etwas gebastelt.
Mit dem zusätzlichen WebServer, der nun auf Port 9000 läuft, geht das auch fein mit untiger index.html, die im Unterverzeichnis "static" abgelegt werden muss.
Aber leider bringt mir das nichts, da meine Webseite auf Apache mit Port 80 läuft.
Gibt es eine Möglichkeit mit meiner auf Apache / port 80 laufenden Seite die Variable "uhrzeit" die auf <IP>:9000\uhrzeit ja nun permanent vorliegt, abzufragen?
Wie müsste die xxxx.html dafür gestrickt sein?
der Python code:
from flask import Flask, jsonify
import datetime
app = Flask( __name__ )
@app.route( "/" )
def index():
return app.send_static_file( "index.html" )
@app.route( "/uhrzeit" )
def uhrzeit():
now = datetime.datetime.now()
timeString = now.strftime("%Y-%m-%d %H:%M:%S")
return jsonify( {"uhrzeit": timeString} )
if __name__ == "__main__":
app.run(host='0.0.0.0', port=9000, debug=True) und die index.html im Verzeichnis "static"
<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>AJAX und flask</title>
</head>
<body>
<h1>Demo für AJAX und flask</h1>
<p>Die aktuelle Uhzeit ist <span id="uhrzeit"></span></p>
<script>
function updateUhrzeit()
{
fetch( "/uhrzeit" )
.then( response => {
if( !response.ok )
throw new Error( "fetch failed" ) ;
return response.json() ;
} )
.then( json => document.querySelector("#uhrzeit").textContent = json.uhrzeit )
.catch( error => alert(error) ) ;
}
updateUhrzeit() ;
setInterval( updateUhrzeit, 1000 ) ;
</script>
</body>
</html>Vielen Dank für die Rückmeldungen.
„Echtzeit“ für die Wassermengen ist in der Tat „nice to have“, da die Animationen tatsächlich schon nahezu in Echtzeit laufen durch abfrage der GPIO Status im 1s Takt.
Anbei ein link, um zu zeigen, woran ich bastele. http://91.67.118.139/page_hydraulis…ischer_plan.php
Schöner als Abfragen (und wirklich Echtzeit) wäre es, wenn die Daten durch Python bereitgestellt würden.
Habe mir mal die You tube videos zu Flasks angeschaut – schon mächtig – nicht ganz so einfach – aber cool!
Ich glaube eine Bereitstellung der Daten aus Python mit Flaks auf einen Port zB 1234 im json Format bekäme ich nun hin.
Aber wie kann bekomme ich die Daten, die dann am Port 1234 anstehen in meine bestehende Webpage?
Guten Abend,
Ich betreibe 3 Impulsgeber in Wasserleitungen. Um diese Wassermengen zu bestimmen zählt mein Python Programm den lieben langen Tag die Pulse in einer Endlosschleife.
Zurzeit schreibe ich die Wassermengen alle 5 Minuten in eine Datenbank. Diese lese ich mit PHP aus, um sie auf meiner Webpage dargezustellen.
Nun möchte ich das Ganze aber in Echtzeit auf der Webseite darstellen, - ohne über die Datenbank zu gehen.
Bekomme ich irgendwie die Inhalte der variablen impulse_warmwasser, impulse_solarkreis und impulse_speicher in eine variable von PHP?
Falls ja, wie geht sowas?
Mein Python Code:
while OK:
GPIO.add_event_detect(22, GPIO.FALLING, callback = Interrupt_Warmwasser, bouncetime = 1)
GPIO.add_event_detect(16, GPIO.FALLING, callback = Interrupt_Solarkreis, bouncetime = 1)
GPIO.add_event_detect(18, GPIO.FALLING, callback = Interrupt_Speicher , bouncetime = 1)
……
def Interrupt_Warmwasser (channel):
global impulse_warmwasser
impulse_warmwasser+=1
def Interrupt_Solarkreis (channel):
global impulse_solarkreis
impulse_solarkreis+=1
def Interrupt_Speicher (channel):
global impulse_speicher
impulse_speicher+=1
Hallo theo100
Weiße Seite bei JPgraph hatte ich seinerzeit auch.
Einfach wie hier beschrieben die else Schleife entfernen...
https://www.forum-raspberrypi.de/Thread-jpgraph?pid=29224#pid29224
Gruß
Oelkanne
Hallo Mobby,
Mir ist klar, dass dies keine professionelle Programmierung ist, aber den Anspruch sollte es auch niemals haben. Ich habe vor 1/2 Jahr erstmalig was von Python und PHP gehört. Umso wichtiger sind für mich Foren, in denen meine Fragen ernstgenommen werden und ich konstruktive Unterstützung erhalte.
(Übrigens: Der Anfänger bin ich, nicht kobold254. Er ging lediglich auf meinen Kenntnistand ein und antwortete entsprechend.)
Als Hobbyhardwarebastler ist Software für mich eine Notwendigkeit.
Ich werde wohl nie professionell programmieren, lediglich funktionell. Aber das ist OK für mich.
Ich bin begeisterst, dass ich 3 Vorschläge zu meinem Problem erhalten habe und möchte euch allen dafür Danken.
Das Gesamtprojekt ist in Stufe 1, die Auswertung der Sensorergebnisse einer Solaranlage. (Steuerung ist zur Zeit diskret aufgebaut)
In Ausbaustufe 2 soll die Raspberry dann auch die Solar / Heizungsanlage steuern.
Habe noch zahlreiche weitere Baustellen mit Leitungslängen, Übersprechen, Prellen von Relaiskontakten, Drehzahlsteuerung, ... aber das ist eher meine Welt.
Wer möchte kann mal einen Blick darauf werfen.
http://rubanevkg.noip.me/index.php
Gruß
Oelkanne