[PYTHON] Simulieren Sie die Temperaturmessung mit Raspberry Pi + Flask + SQLite + Ajax

Einführung

Wenn Sie die Temperatur mit Raspberry Pi messen und den Sensorstatus mit GPIO abrufen, ist es praktisch, nur mit der Software debuggen zu können. Aus diesem Grund habe ich eine Debug-Umgebung erstellt, die die Erfassung des Sensorstatus durch Temperaturmessung und GPIO simuliert und auf der Website (erstellt mit Flask) anzeigt. Speichern Sie die simulierte Temperatur und den Sensorstatus in SQLite und aktualisieren Sie die Seite über Ajax. Da es aus den numerischen Werten von Temperatur und Sensorstatus schwer zu verstehen ist, sieht es so aus, als hätten sich die Temperatur des Wohnzimmers und des Sensors geändert.

In dieser Umgebung ist kein Steckbrett oder Kabel erforderlich. Es ist nicht für Temperaturmessungen und Sensorstatuserfassung geeignet, die Echtzeitleistung erfordern. Wir gehen von einer Umgebung aus, in der die Temperatur nur in Intervallen von 30 Sekunden bekannt sein muss.

Operationsbild

• Die Pfeile für Temperatur und Sensorstatus werden aktualisiert.

Umgebung

• Raspberry Pi3 B
• Python 3.7.2
• Flask
• SQLite3
• Sqlalchemy
• jQuery 3.4.1

Installation

Python-Umgebung

--Hier erstellen Sie einen Sensorordner und installieren Sie die Umgebung mit pipenv.

• Die Installation von pipenv und Webserver (Nginx, uWSGI usw.) entfällt.

$ mkdir Sensor
$ cd Sensor
$ pipenv install --python 3.7.2
$ pipenv install flask
$ pipenv install sqlalchemy
$ pipenv shell

Ordner- und Dateistruktur

--Erstellen Sie die folgenden Ordner und Dateien. --jQuery lädt die entsprechende Version von jQuery herunter.

• Laden Sie das Pfeilsymbol (Ein / Aus) von [Freies Symbol] Pfeil (oben / unten / links / rechts) herunter.
• Der Hintergrund wird von Cute Free Material Collection Irasutoya heruntergeladen.

└ Sensor/
  ├ server.py
  ├ app/
  │ ├ app.py
  │ └ static/
  │ │ ├ css/
  │ │ │ └ sample.css
  │ │ ├ img/
  │ │ │ ├ arrow_on.png        #Pfeil, wenn eingeschaltet
  │ │ │ ├ arrow_off.png       #Pfeil, wenn ausgeschaltet
  │ │ │ └ bg_house_living.jpg #Hintergrundbild
  │ │ ├ jquery/
  │ │ │ └ jquery-3.4.1-min.js
  │ │ └ js/
  │ │   └ sample.js
  │ └ templates/
  │   └ index.html
  ├ models/                   #SQLite3-Definition
  │ ├ __init__.py
  │ ├ database.py
  │ └ models.py
  └ output_log/               #Protokollordner für die Hintergrundausführung

Quellcode

Hauptverarbeitung des Servers

--Init_db () initialisiert die Datenbank. (Wird nur ausgeführt, wenn die * .db-Datei nicht vorhanden ist.)

server.py

# -*- coding: utf-8 -*-

from flask import Flask
from app.app import app
from models.database import init_db

if __name__ == "__main__":
    #Datenbankinitialisierung
    init_db()
    #Starten Sie die App(host=0,0,0,0 für alle Berechtigungen)
    app.run(host='0.0.0.0', debug=True)

Verarbeitung der Temperatur- und Sensorsimulation

• Temperatur und Sensor alle 3 Sekunden simulieren.
• Die Temperatur wird bei 25 Grad + α simuliert.
• Der Sensor simuliert mit 0 oder 1.

(Referenz) Ausführen in Python in regelmäßigen Abständen und Überprüfung

sensor.py

# -*- coding: utf-8 -*-

import time
import threading
import random
from models.models import SensorCurrent
from models.database import db_session
from datetime import datetime

#Periodische Ausführungsverarbeitung
def schedule():
    #Temperatursimulation(25 Grad+α)
    now = time.time()
    temp = 25 + now % 5 + (now / 10) % 10
    #Auf die zweite Ziffer abschneiden
    str = "{0:.2f}".format(temp)
    temp = float(str)
    
    #Sensorzustandssimulation(0 or 1)
    sensor = random.randint(0, 1)

    #Aktuelle Datenaktualisierung
    current = SensorCurrent.query.first()
    current.temp1 = temp
    current.sensor1 = sensor
    db_session.commit()
    db_session.close()

#Regelmäßige Verarbeitung der Ausführungseinstellungen
def scheduler(interval, f, wait = True):
    base_time = time.time()
    next_time = 0
    while True:
        t = threading.Thread(target = f)
        t.start()
        if wait:
            t.join()
        next_time = ((base_time - time.time()) % interval) or interval
        time.sleep(next_time)

if __name__ == "__main__":
    #Einstellung für die regelmäßige Ausführung(3 Sekunden Intervalle)
    scheduler(3, schedule, True)

App Hauptverarbeitung

• Beschreibt die Anzeige der Website und die Ajax-Verarbeitung.

/app/app.py

# -*- coding: utf-8 -*-

from flask import Flask,render_template,request, json, jsonify
from models.models import SensorCurrent

app = Flask(__name__)

#Verarbeitung der Website-Anzeige
@app.route("/")
def index():
    #Erhalten Sie aktuelle Temperatur- und Sensordaten von SQlite
    data = SensorCurrent.query.first()
    return render_template("index.html",sensor=data)

#Ajax-Verarbeitung
@app.route("/currdata", methods=['POST'])
def getCurrData():
    #Erhalten Sie aktuelle Temperatur- und Sensordaten von SQlite
    data = SensorCurrent.query.first()
    #In JSON konvertieren und das Ergebnis zurückgeben
    json_data = {
        'sensor1': data.sensor1,
        'temp1': data.temp1
    }
    return jsonify(Result=json.dumps(json_data))

if __name__ == "__main__":   
    app.run(debug=True)

Datenbankdefinition

• Definieren Sie die SQLite3-Datenbank (sensor.db).

models/database.py

# -*- coding: utf-8 -*-

from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session, sessionmaker
from sqlalchemy.ext.declarative import declarative_base
import os

#Einstellungen für Datenbankdateien
databese_file = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'sensor.db')
engine = create_engine('sqlite:///' + databese_file, convert_unicode=True)
db_session = scoped_session(sessionmaker(autocommit=False,autoflush=False,bind=engine))
Base = declarative_base()
Base.query = db_session.query_property()

#Datenbankinitialisierung
def init_db():
    import models.models
    Base.metadata.create_all(bind=engine)

Tabellendefinition

• Definieren Sie die Temperatur- und Stromdatentabelle (Currdata) des Sensors.

models/models.py

# -*- coding: utf-8 -*-

from sqlalchemy import Column, Integer, Float, String, Text, DateTime
from models.database import Base
from datetime import datetime

#Definition der aktuellen Datentabelle für Temperatur und Sensor
#Hier ist eine Temperaturdaten,Speichern Sie eine Sensordaten
#Bitte stellen Sie die Tabellendefinition entsprechend ein
class SensorCurrent(Base):
    __tablename__ = 'currdata'
    id = Column(Integer, primary_key=True)
    name = Column(String(128))
    temp1 = Column(Float)
    sensor1 = Column(Integer)
    date = Column(DateTime, default=datetime.now())

    def __init__(self, name=None, temp1=None, sensor1=None, date=None):
        self.name = name
        self.temp1 = temp1
        self.sensor1 = sensor1
        self.date = date

    def __repr__(self):
        return '<Name %r>' % (self.name)

Hauptseite mit Flask

• Die aktuellen Daten werden beim Start erfasst und angezeigt. (Der Standardpfeil ist Aus)
• Verwenden Sie Ajax, um alle 2 Sekunden die aktuellen Daten abzurufen und die Seite neu zu schreiben.

app/templates/index.html

<!DOCTYPE html>
<html lang="ja">
    <head>
        <meta charset="utf-8">
        <title>{{sensor.name}}</title>
        <meta name="viewport" content="width=device-width,initial-scale=1.0">
        <link rel="stylesheet" type="text/css" href="../static/css/sample.css">
        <script src="../static/jquery/jquery-3.4.1.min.js"></script>
        <script src="../static/js/sample.js"></script>
    </head>
    <body>
    <h1 id="h1_temp1">Temp : {{sensor.temp1}}</h1>
    <h1 id="h1_sensor1">Sensor : {{sensor.sensor1}}</h1>
    
    <div class="sample-box">
        <img class="sample-box-bg" src="../static/img/bg_house_living.jpg " alt="">
        <div class="sample-sensor">
            <img class="sample-sensor-img" id="sensor1" src="../static/img/arrow_off.png " alt="">
        </div>
        <div id="temp1" class="sample-tempareture">
        </div>
    </div>
    </body>
    <script>
        setInterval(function () {
           	getcurrdata();
        }, 2000);
    </script>
</html>

Aktueller Datenerfassungsprozess

• Holen Sie sich die aktuellen Daten mit Ajax.

app/static/js/sample.js

//Aktuelle Datenerfassung
function getcurrdata() {
    $.ajax({
        type: 'POST',
        url: '/currdata',
        data: '',
        contentType: 'application/json'
    })
    .done( (data) => {
        //Erfolgreiche Datenerfassung
        console.log("success");
        //Extrahieren Sie Daten aus JSON
        var json_data = JSON.parse(data.Result);
        const sensor1 = json_data.sensor1;
        const temp1 = json_data.temp1;

        //Temperatureinstellung im Hintergrundbild
        $("#temp1").html(temp1 + "℃");
        //Temperatureinstellung(Zur Bestätigung)
        $("#h1_temp1").html("Temp : " + temp1);

        //Sensorbildeinstellungen
        if (sensor1 == 0) {
            $("#sensor1").attr("src", "../static/img/arrow_off.png ");
        } else {
            $("#sensor1").attr("src", "../static/img/arrow_on.png ");
        }
        //Sensoreinstellungen(Zur Bestätigung)
        $("#h1_sensor1").html("Sensor : " + sensor1);
    })
    .fail( (data) => {
        //Datenerfassungsfehler
        console.log("error");
    });
}

Hauptseite CSS

――Es unterstützt problemlos Responsive Design.

app/static/css/sample.css

@charset "utf-8";

@media screen and (min-width: 481px) {
  .sample-box {
    position: relative;
    display:inline-block;
  }
  .sample-box-bg {
  }

  .sample-sensor {
    position: absolute;
    left: 60%;
    top: 5%;
  }
  .sample-sensor-img {
  }

  .sample-tempareture {
    position: absolute;
    top: 35%;
    left: 55%;
    color: RED;
    font-size: 36px;
  }
}

@media screen and (max-width: 480px) {
  .sample-box {
    position: relative;
    display:inline-block;
  }
  .sample-box-bg {
    width: 100%;
  }

  .sample-sensor {
    position: absolute;
    left: 60%;
    top: 5%;
  }
  .sample-sensor-img {
    width: 70%;
    height: 70%;
  }

  .sample-tempareture {
    position: absolute;
    top: 35%;
    left: 55%;
    color: RED;
    font-size: 22px;
  }
}

Funktionsweise

Lernen Sie von der Simulation von Temperatur und Sensoren bis zur Anzeige von Websites.

Stellen Sie die Temperatur und den Anfangswert des Sensors ein

• Anfangswerte von Temperatur und Sensor (nur einer) werden zur Currdata-Tabelle hinzugefügt. --Starten Sie Python im Ordner Sensor und führen Sie den folgenden Quellcode aus.
• Sie müssen es nur einmal ausführen.

$ python
from models.database import db_session
from models.models import SensorCurrent
data = SensorCurrent("Stichprobe",25.3, 0)
db_session.add(data)
db_session.commit()
exit()

Beginnen Sie mit der Simulation von Temperatur und Sensor

• Starten Sie aus dem Ordner Sensor eine App, die Temperatur und Sensoren im Hintergrund simuliert.
• Ich führe es im Hintergrund aus, weil ich es gleichzeitig mit der Server-App ausführen möchte.

#Führen Sie den folgenden Ordner aus
(Sensor) pi@raspberrypi:~/Sensor $

#Führen Sie den folgenden Befehl aus
nohup python sensor.py > ./output_log/out.log &

• Wenn Sie bereits mit der Simulation begonnen haben, beenden Sie den Vorgang, bevor Sie ihn starten.

#Suchen Sie den Prozess, auf dem Python ausgeführt wird
$ ps aux | grep python
pi       22965  0.7  2.0  32200 19176 pts/2    S    16:43   0:27 python sensor.py

# sensor.töte den py-Prozess
$ kill -9 (sensor.py Prozess-ID->22965 hier)

Starten Sie den Webserver

--Starten Sie den Server-Hauptprozess.

#Führen Sie den folgenden Ordner aus
(Sensor) pi@raspberrypi:~/Sensor $

#Führen Sie den folgenden Befehl aus
python server.py

Bestätigung anzeigen

• Starten Sie einen Browser und greifen Sie auf http://127.0.0.1:5000 zu.
• Sie können auch auf die lokale IP-Adresse des Webservers zugreifen. ――Wenn Sie von einem Smartphone aus zugreifen, wird das reaktionsschnelle Design meiner Meinung nach einfach angewendet.

abschließend

Wenn Sie IoT mit Raspberry Pi ausprobieren möchten, aber gleichzeitig Hardware entwickeln oder ein Steckbrett oder eine Verkabelung nicht vorbereiten können, können Sie dies einfach simulieren. Die Temperatur und die Anzahl der Sensoren können gemäß der Definition von SQLite frei festgelegt werden, daher werde ich sie von nun an verwenden.

Referenz

Ich habe auf die folgende Seite verwiesen. Unerfahrene Webanwendungsentwickler werden Flask, SQLite und Heroku verwenden, um den Dienst in einer Woche freizugeben Starten Sie einen Webserver mit Raspberry pi + Nginx + uWSGI und versuchen Sie, die Django-App Teil 1 bereitzustellen Ausführen in Python in regelmäßigen Abständen und Überprüfung Sparen Sie Zeit mit der Hintergrundausführung! !!