[PYTHON] Erstellen Sie mit Raspberry Pi + DHT11 ganz einfach einen TweetBot, der Sie über Temperatur und Luftfeuchtigkeit informiert.

Entwicklungsumgebung

_ * Wenn es kein Problem gibt, funktionieren die neuesten Raspberry Pi2,3 und OS mit Jessie, sodass Sie sich nicht zu viele Sorgen machen müssen. _

Gebrauchte Ausrüstung

Wir empfehlen den Kauf bei Akizuki oder Marutsu Parts. _

installieren

• Hier werden wir mit der Diskussion fortfahren, bevor das Betriebssystem bereits auf dem Raspberry Pi installiert wurde.

Git installieren.

Installieren Sie es, um dht11.py herunterzuladen, das später veröffentlicht wird.

sudo apt-get install git

Installieren Sie RPi.GPIO.

RPi.GPIO ist ein Modul, das GPIO-Pins von Raspberry Pi mit Python steuern kann. Es ist wichtig für den Betrieb von RaspberryPi und elektronischen Geräten wie LEDs und Sensorgeräten. Selbst wenn es einen GPIO-Pin gibt, handelt es sich um eine hochwertige Box, die 5 (v) und 3,3 (v) Spannungen liefern kann.

Darüber hinaus scheint es standardmäßig ab der Veröffentlichung von Jessi installiert zu sein. Es scheint also, dass Sie es sofort verwenden können, indem Sie dieses Paket zu Beginn des Python-Programms importieren.

Offizielle Website 26. Kontroll-GPIO von Raspberry Pi (Python)

Da es hier jedoch eine große Sache ist, werde ich die Installationsmethode für diejenigen beschreiben, die noch nicht zu Jessi gezogen sind (wie ich).

Für pip
sudo pip install rpi.gpio

apt-Für bekommen
sudo apt-get install python-rpi.gpio

Wenn Sie es hier vorstellen können, machen Sie bitte L Chika auf jeden Fall, während Sie sich die GPIO-Pin-Korrespondenztabelle von Raspberry Pi als Übung ansehen. Dies ist der erste Schritt, da sich L-Chika wie ein sogenannter "Hallo Wold" verhält.

L-Chika mit Pythons RPi.GPIO auf Raspberry Pi

Installieren Sie twython.

sudo apt-get install python-setuptools
sudo easy_install pip
sudo pip install twython

twython ist ein in Python geschriebenes Twitter-Bibliotheksprogramm. Wenn es darum geht, was Sie konkret tun können, sagt der Beamte dies.

Twython is the premier Python library providing an easy (and up-to-date) way to access Twitter data. Actively maintained and featuring support for Python 2.6+ and Python 3. It's been battle tested by companies, educational institutions and individuals alike. Try it today!

Twython ist die beste Python-Bibliothek, die eine einfache (und aktuelle) Möglichkeit bietet, auf Twitter-Daten zuzugreifen! Insbesondere werden hauptsächlich Python 2.6+ und Python3 unterstützt. Twython wird auch von Unternehmen, Bildungseinrichtungen und Einzelpersonen aktiv getestet. Versuch es bitte!

Wenn Sie einen TwitterBot erstellen, erledigt dieser Twython normalerweise die harte Arbeit hinter den Kulissen, sodass wir problemlos einen TwiiterBot in Python mit einem Twitter-API-Schlüssel schreiben können. Praktisch.

Wenn Sie die Rückseite und die detaillierte Verwendung kennen möchten, empfehle ich Ihnen, den offiziellen Quellcode zu lesen.

Offiziell: https://github.com/ryanmcgrath/twython

TwitterBot twittert die CPU-Temperatur von Raspberry Pi Einführung und Testen von Twython

Damit ist die grobe Einrichtung abgeschlossen. Geben Sie dann die Hardware-Schaltungsverbindung ein.

Verbinden Sie Raspberry Pi und DHT11.

Das Anschlussdiagramm sieht so aus.

Die Entsprechungstabelle zwischen DHT11- und GPIO-Pins ist wie folgt.

• DATEN können GPIO14 oder GPIO17 sein. Ich habe hier GPIO4 als Übung gewählt.

Je nach Produkt ist der Widerstand bereits angeschlossen (this), aber die Grundlagen sind wie folgt. Da die Entsprechungstabelle mit GPIO-Pins je nach Rasperry Pi unterschiedlich ist, stellen Sie bitte eine Verbindung her, während Sie sich die Entsprechungstabelle mit GPIO-Pins ansehen.

Damit ist die Verbindung auf der Hardwareseite abgeschlossen. Als nächstes messen wir tatsächlich die Raumtemperatur und die Temperatur vom angeschlossenen DHT11 und überprüfen den Betrieb.

Steuern Sie DHT11 mit Python.

Da der Code zur Steuerung von DHT11 bereits in Python geschrieben wurde, führen wir "git clone" aus und danken dem Ersteller.

https://github.com/szazo/DHT11_Python

cd
git clone https://github.com/szazo/DHT11_Python.git

Gehen Sie zu dem Verzeichnis, in dem Sie "git clone" haben, und überprüfen Sie die Dateien. Beachten Sie die beiden darin enthaltenen Dateien "dht11.py" und "dht11_examle.py".

dht11.py

import time
import RPi


class DHT11Result:
    'DHT11 sensor result returned by DHT11.read() method'

    ERR_NO_ERROR = 0
    ERR_MISSING_DATA = 1
    ERR_CRC = 2

    error_code = ERR_NO_ERROR
    temperature = -1
    humidity = -1

    def __init__(self, error_code, temperature, humidity):
        self.error_code = error_code
        self.temperature = temperature
        self.humidity = humidity

    def is_valid(self):
        return self.error_code == DHT11Result.ERR_NO_ERROR


class DHT11:
    'DHT11 sensor reader class for Raspberry'

    __pin = 0

    def __init__(self, pin):
        self.__pin = pin

    def read(self):
        RPi.GPIO.setup(self.__pin, RPi.GPIO.OUT)

        # send initial high
        self.__send_and_sleep(RPi.GPIO.HIGH, 0.05)

        # pull down to low
        self.__send_and_sleep(RPi.GPIO.LOW, 0.02)

        # change to input using pull up
        RPi.GPIO.setup(self.__pin, RPi.GPIO.IN, RPi.GPIO.PUD_UP)

        # collect data into an array
        data = self.__collect_input()

        # parse lengths of all data pull up periods
        pull_up_lengths = self.__parse_data_pull_up_lengths(data)

        # if bit count mismatch, return error (4 byte data + 1 byte checksum)
        if len(pull_up_lengths) != 40:
            return DHT11Result(DHT11Result.ERR_MISSING_DATA, 0, 0)

        # calculate bits from lengths of the pull up periods
        bits = self.__calculate_bits(pull_up_lengths)

        # we have the bits, calculate bytes
        the_bytes = self.__bits_to_bytes(bits)

        # calculate checksum and check
        checksum = self.__calculate_checksum(the_bytes)
        if the_bytes[4] != checksum:
            return DHT11Result(DHT11Result.ERR_CRC, 0, 0)

        # ok, we have valid data, return it
        return DHT11Result(DHT11Result.ERR_NO_ERROR, the_bytes[2], the_bytes[0])

    def __send_and_sleep(self, output, sleep):
        RPi.GPIO.output(self.__pin, output)
        time.sleep(sleep)

    def __collect_input(self):
        # collect the data while unchanged found
        unchanged_count = 0

        # this is used to determine where is the end of the data
        max_unchanged_count = 100

        last = -1
        data = []
        while True:
            current = RPi.GPIO.input(self.__pin)
            data.append(current)
            if last != current:
                unchanged_count = 0
                last = current
            else:
                unchanged_count += 1
                if unchanged_count > max_unchanged_count:
                    break

        return data

    def __parse_data_pull_up_lengths(self, data):
        STATE_INIT_PULL_DOWN = 1
        STATE_INIT_PULL_UP = 2
        STATE_DATA_FIRST_PULL_DOWN = 3
        STATE_DATA_PULL_UP = 4
        STATE_DATA_PULL_DOWN = 5

        state = STATE_INIT_PULL_DOWN

        lengths = [] # will contain the lengths of data pull up periods
        current_length = 0 # will contain the length of the previous period

        for i in range(len(data)):

            current = data[i]
            current_length += 1

            if state == STATE_INIT_PULL_DOWN:
                if current == RPi.GPIO.LOW:
                    # ok, we got the initial pull down
                    state = STATE_INIT_PULL_UP
                    continue
                else:
                    continue
            if state == STATE_INIT_PULL_UP:
                if current == RPi.GPIO.HIGH:
                    # ok, we got the initial pull up
                    state = STATE_DATA_FIRST_PULL_DOWN
                    continue
                else:
                    continue
            if state == STATE_DATA_FIRST_PULL_DOWN:
                if current == RPi.GPIO.LOW:
                    # we have the initial pull down, the next will be the data pull up
                    state = STATE_DATA_PULL_UP
                    continue
                else:
                    continue
            if state == STATE_DATA_PULL_UP:
                if current == RPi.GPIO.HIGH:
                    # data pulled up, the length of this pull up will determine whether it is 0 or 1
                    current_length = 0
                    state = STATE_DATA_PULL_DOWN
                    continue
                else:
                    continue
            if state == STATE_DATA_PULL_DOWN:
                if current == RPi.GPIO.LOW:
                    # pulled down, we store the length of the previous pull up period
                    lengths.append(current_length)
                    state = STATE_DATA_PULL_UP
                    continue
                else:
                    continue

        return lengths

    def __calculate_bits(self, pull_up_lengths):
        # find shortest and longest period
        shortest_pull_up = 1000
        longest_pull_up = 0

        for i in range(0, len(pull_up_lengths)):
            length = pull_up_lengths[i]
            if length < shortest_pull_up:
                shortest_pull_up = length
            if length > longest_pull_up:
                longest_pull_up = length

        # use the halfway to determine whether the period it is long or short
        halfway = shortest_pull_up + (longest_pull_up - shortest_pull_up) / 2
        bits = []

        for i in range(0, len(pull_up_lengths)):
            bit = False
            if pull_up_lengths[i] > halfway:
                bit = True
            bits.append(bit)

        return bits

    def __bits_to_bytes(self, bits):
        the_bytes = []
        byte = 0

        for i in range(0, len(bits)):
            byte = byte << 1
            if (bits[i]):
                byte = byte | 1
            else:
                byte = byte | 0
            if ((i + 1) % 8 == 0):
                the_bytes.append(byte)
                byte = 0

        return the_bytes

    def __calculate_checksum(self, the_bytes):
        return the_bytes[0] + the_bytes[1] + the_bytes[2] + the_bytes[3] & 255

Dieser Quellcode stammt hauptsächlich aus DHT11 und ist eine Klassendatei, die digitale Signale mit Python verarbeitet. Daher können Sie verstehen, dass Sie die gemessenen Werte für Luftfeuchtigkeit und Temperatur leicht ermitteln können, indem Sie das Objekt verwenden, das beim Erstellen der Klasse "dht11.py" erstellt wurde. Sehen wir uns ein Beispiel für die tatsächliche Verwendung einer Instanz an.

dht11_example.py(Vor der Korrektur)

import RPi.GPIO as GPIO
import dht11
import time
import datetime

# initialize GPIO
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.cleanup()

# read data using pin 14
instance = dht11.DHT11(pin=14)

while True:
    result = instance.read()
    if result.is_valid():
        print("Last valid input: " + str(datetime.datetime.now()))
        print("Temperature: %d C" % result.temperature)
        print("Humidity: %d %%" % result.humidity)

    time.sleep(1)

Bitte beachten Sie, dass "instance = dht11.DHT11 (pin = 14)" die Standardeinstellung ist. Wenn Sie bereits mit GPIO14 verbunden sind, müssen Sie hier nichts tun. Wenn Sie jedoch beim vorherigen Entwerfen der Schaltung "GPIO4" ausgewählt haben, korrigieren Sie dies bitte folgendermaßen.

import RPi.GPIO as GPIO
import dht11
import time
import datetime

# initialize GPIO
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.cleanup()

# read data using pin 14
-instance = dht11.DHT11(pin=14)
+instance = dht11.DHT11(pin=4)

while True:
    result = instance.read()
    if result.is_valid():
        print("Last valid input: " + str(datetime.datetime.now()))
        print("Temperature: %d C" % result.temperature)
        print("Humidity: %d %%" % result.humidity)

    time.sleep(1)

Damit ist der Code zur Messung von Temperatur und Luftfeuchtigkeit von DHT11 vervollständigt. Lassen Sie es uns als Operationsprüfung ausführen.

sudo python dht11_example.py

_ * Stellen Sie sicher, dass Sie mit Root-Rechten oder "sudo" ausführen! Andernfalls erhalten Sie einen Fehler. _

Hoffentlich zeigt die Befehlszeile die Temperatur und Luftfeuchtigkeit an. Wenn Sie dies bestätigen können, ist die Funktionsprüfung von DHT11 abgeschlossen. Ist Prost auf gute Arbeit.

Registrieren Sie sich bei der Twitter-API, um einen TweetBot zu erstellen.

Registrieren Sie sich bei der Twitter-API, um einen TweetBot zu erstellen.

Wechseln Sie von hier aus zur entsprechenden Seite und klicken Sie auf Neue App erstellen, um sich zu registrieren. https://apps.twitter.com/

[Achtung 1] Für die Registrierung der Twitter-API ist eine Telefonnummer erforderlich. Die Sprache sollte [Englisch] sein.

Für die Registrierung für die Twitter-API ist eine Telefonnummer erforderlich. Andernfalls werden Sie so wütend.

Also registriere ich meine Telefonnummer und gebe die Nummer ein, die ich von der Nachricht erhalten habe, um mein Telefon zu authentifizieren ... aber das funktioniert immer noch nicht.

Ob es sich um einen Fehler oder eine Verwendung handelt oder ob ein Twitter-Ingenieur nicht arbeitet ~~, ich kenne die Details nicht, aber ich werde die Twitter-Spracheinstellung von [Japanisch] auf [Englisch] ändern.

Da für die Verwendung der Twitter-API und der Apps eine Authentifizierung mit einem Mobiltelefon erforderlich ist, wird die Authentifizierung durchgeführt.

Wenn Sie in diesem Status erneut eine Telefonauthentifizierung durchführen, können Sie sicher zur Registrierungsseite der Twitter-API wechseln. Registrieren Sie daher die API.

[Achtung 2] Sie können nicht in kurzer Zeit denselben Beitrag veröffentlichen.

Es ist nicht möglich, denselben Beitrag nacheinander mit der Twitter-API zu twittern, wahrscheinlich aus Gründen der Spam-Prävention. Verwenden Sie daher Zeitstempel, damit Sie ähnliche Tweets in kurzer Zeit veröffentlichen können. Wenn Sie die Temperatur und die Raumtemperatur wie dieses Mal veröffentlichen, wird möglicherweise derselbe Tweet erstellt. Es wird daher empfohlen, absichtlich einen Zeitstempel dazwischen zu setzen.

Tweet von Raspberry Pi.

Nach der Registrierung bei der API benötigen Sie die folgenden vier API-Schlüssel.

• CONSUMER_KEY
• CONSUMER_SECRET
• ACCESS_KEY
• ACCESS_SECRET

Diese entsprechen den Zahlen nach den folgenden vier Elementen auf der Twitter-API-Seite.

Wenn Sie die obigen 4 Tasten bestätigen können, erstellen wir einen Twitter-Bot und überprüfen den Vorgang.

tweet.py

#!/usr/bin/env python
#coding:utf-8

import os
from twython import Twython

#Twiiter API 
CONSUMER_KEY ='API_key1'
CONSUMER_SECRET ='API_key2'
ACCESS_KEY ='API_key3'
ACCESS_SECRET ='API_key4'
api = Twython(CONSUMER_KEY,CONSUMER_SECRET,ACCESS_KEY,ACCESS_SECRET)

#time stamp
timestamp = 'date +%F_%H:%M:%S'
current_time=os.popen(timestamp).readline().strip()


api.update_status(status='[Test] Die aktuelle Zeit ist'+current_time+'ist!')

Selbst wenn ein Fehler auftritt, wird der Zeitstempel eingefügt, sodass Sie kontinuierlich posten und sofort debuggen können. Wenn der Beitrag erfolgreich ist, sollte die aktuelle Zeit in Ihre TL gebucht werden. Dies ist das Ende der Betriebsüberprüfung mit der Twitter-API.

Führen Sie dht11_tweet.py regelmäßig mit crontab aus.

An diesem Punkt können Sie sich vorstellen, dass Sie die Temperatur und Luftfeuchtigkeit auf Twitter veröffentlichen können, indem Sie die zuerst erstellte dht11_example.py und die gerade erstellte tweet.py kombinieren.

Zum Schluss beenden wir die gewünschte dht11_tweet.py mit zwei Quellcodes.

dht11_tweet.py

# -*- coding: utf-8 -*

import RPi.GPIO as GPIO
import dht11
import time
import datetime
import os
from twython import Twython

# initialize GPIO
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.cleanup()

instance = dht11.DHT11(pin=4)

#Twiiter API 
CONSUMER_KEY ='API_key1'
CONSUMER_SECRET ='API_key2'
ACCESS_KEY ='API_key3'
ACCESS_SECRET ='API_key4'
api = Twython(CONSUMER_KEY,CONSUMER_SECRET,ACCESS_KEY,ACCESS_SECRET)

#time stamp
timestamp = 'date +%F_%H:%M:%S'
current_time=os.popen(timestamp).readline().strip()

while True:
    result = instance.read()
    if result.is_valid():
        api.update_status(status = '[Informationen zu Temperatur und Luftfeuchtigkeit]'+'Aktuelle Uhrzeit'+current_time
            +'Temperatur:'+str(result.temperature)+'Es ist ℃.'+'Feuchtigkeit:'+str(result.humidity)
            +'%ist.')

        break

    time.sleep(1)

Wie Sie durch mehrmaliges Ausführen von dht11_example.py sehen können, ist DHT11 (Temperatur- und Feuchtigkeitssensor) nicht so genau. Daher wird der gemessene Wert bei der Ausführung nicht immer zurückgegeben und es kommt häufig vor, dass die Daten nicht gelesen werden können. In diesem Fall werden, da "Instanz" selbst nicht generiert wird, "result.temperature" und "result.humidity", die in "api.update_status" enthalten sind, nicht aufgerufen, sodass ein Fehler auftritt und der Beitrag fehlschlägt. .. Aus diesem Grund

while True:
    result = instance.read()

Wiederholen Sie diesen Vorgang bis = __ [Zustand, in dem Temperatur und Raumtemperatur gemessen werden können] __ wobei die Instanz durch die Anweisung "while" generiert wird. Da der Beitrag das erste Mal sein kann, wenn die Instanzgenerierung erfolgreich ist, setzen Sie außerdem "break" am Ende von "api.update_status". Auf diese Weise ist es möglich, nur einmal zu twittern und dabei Temperatur und Luftfeuchtigkeit zuverlässig zu messen.

Mit dem oben genannten ist der TweetBot, der die raue Temperatur und Luftfeuchtigkeit murmelt, fertig. Dies ist jedoch immer noch eine manuelle Methode, daher werde ich sie am Ende in "crontab" registrieren und regelmäßig murmeln, damit sie wie ein Bot aussieht.

Die Erklärung von "crontab" wird hier weggelassen, aber es geht darum, sie als Taskplaner zu betrachten. Ein Programm, das Befehle und Skripte zu bestimmten Zeiten ausführt.

[Zusammenfassung der Verwendung von Crontab. ](Http://bakunyo.hatenablog.com/entry/2013/06/20/crontab%E4%BD%BF%E3%81%84%E6%96%B9%E3%81%BE%E3%81% A8% E3% 82% 81% E3% 80% 82)

Geben Sie "crrontab -e" ein, um "crontab" zu öffnen. Das Überschreiben-Speichern ist übrigens "Ctr + o" und das Beenden "Ctr + x". Beachten Sie, dass diese beiden Befehle häufig verwendet werden.

Wenn Sie beispielsweise alle 15 Minuten von TweetBot aus posten möchten, schreiben Sie wie folgt.

*/15 * * * * sudo python /home/pi/(....)/dht11_tweet.py

Wenn dies nicht richtig funktioniert, debuggen Sie bitte, während Sie sich die folgende Site ansehen.

Drei Punkte, die überprüft werden müssen, wenn Crontab nicht funktioniert + α

Damit ist der TweetBot fertig, der alle 15 Minuten Temperatur und Luftfeuchtigkeit murmelt. Ist Prost auf gute Arbeit.

Da dieser Code vollständig in Python geschrieben ist, beispielsweise wenn Sie Graph anzeigen oder die angegebene Temperatur erreichen Ich denke, es wird möglich sein, den Summer zu ertönen. Wenn Sie interessiert sind, versuchen Sie es bitte.