Créez facilement un TweetBot qui vous informe de la température et de l'humidité avec Raspberry Pi + DHT11.

Environnement de développement

_ * S'il n'y a pas de problème, les derniers Raspberry Pi2,3 et OS fonctionneront avec Jessie, vous n'avez donc pas à vous inquiéter trop. _

Matériel usagé

Nous vous recommandons d'acheter sur Akizuki ou Marutsu Parts. _

installer

• Ici, nous allons poursuivre la discussion avant que le système d'exploitation ne soit déjà installé sur le Raspberry Pi.

Installez git.

Installez-le pour télécharger dht11.py, qui sortira plus tard.

sudo apt-get install git

Installez RPi.GPIO.

RPi.GPIO est un module qui peut contrôler les broches GPIO de Raspberry Pi en utilisant Python. Il est essentiel au fonctionnement du RaspberryPi et des appareils électroniques tels que les LED et les capteurs. Sans cela, même s'il y a une broche GPIO, ce sera un boîtier haut de gamme capable de fournir des tensions 5 (v) et 3.3 (v), alors introduisons-le.

De plus, il semble qu'il soit installé par défaut à partir de la sortie de Jessi. Il semble donc que vous puissiez l'utiliser immédiatement en important ce package au début du programme Python.

Site officiel 26e GPIO de contrôle de Raspberry Pi (Python)

Cependant, comme c'est un gros problème ici, je vais décrire la méthode d'installation pour ceux qui n'ont pas encore déménagé chez Jessi (comme moi).

Pour pip
sudo pip install rpi.gpio

apt-Oublier
sudo apt-get install python-rpi.gpio

Si vous pouvez l'introduire ici, veuillez faire L Chika par tous les moyens en regardant Table de correspondance des broches GPIO de Raspberry Pi comme une pratique. C'est la première étape parce que L-Chika se comporte comme un soi-disant «Bonjour le monde».

L-Chika utilisant le RPi.GPIO de Python sur Raspberry Pi

Installez twython.

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

twython est un programme de bibliothèque Twitter écrit en Python. Quand il s'agit de ce que vous pouvez faire spécifiquement, le fonctionnaire le dit.

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 est la meilleure bibliothèque Python qui offre un moyen simple (et à jour) d'accéder aux données Twitter! En particulier, il prend principalement en charge Python 2.6+ et Python3. Twython est également activement testé par des entreprises, des établissements d'enseignement et des particuliers. Essayez-le!

Lors de la création d'un TwitterBot, ce Twython fait généralement le travail acharné dans les coulisses, nous pouvons donc facilement écrire un TwiiterBot en Python avec une clé API Twitter. Pratique.

Si vous voulez connaître le verso et l'utilisation détaillée, je vous recommande de lire le code source officiel.

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

TwitterBot tweetant la température du processeur du Raspberry Pi Introduction et test de twython

Ceci termine la configuration approximative. Entrez ensuite la connexion du circuit matériel.

Connectez Raspberry Pi et DHT11.

Le schéma de connexion ressemble à ceci.

La table de correspondance entre les broches DHT11 et GPIO est la suivante.

• Les données peuvent être GPIO14 ou GPIO17. J'ai choisi GPIO4 comme pratique ici.

Selon le produit, la résistance est déjà connectée (this), mais les bases sont comme ça. Étant donné que la table de correspondance avec les broches GPIO diffère selon chaque Rasperry Pi, veuillez vous connecter en regardant la table de correspondance avec les broches GPIO.

Ceci termine la connexion côté matériel. Ensuite, mesurons la température ambiante et la température du DHT11 connecté et vérifions le fonctionnement.

Contrôle DHT11 avec Python.

Puisque le code pour contrôler DHT11 a déjà été écrit en Python, exécutons git clone tout en remerciant le créateur.

https://github.com/szazo/DHT11_Python

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

Allez dans le répertoire où vous git clone et vérifiez les fichiers. Notez les deux fichiers qu'il contient, dht11.py et 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

Ce code source est principalement obtenu à partir de DHT11 et est un fichier de classe qui traite les signaux numériques avec Python. Par conséquent, vous pouvez comprendre que vous pouvez facilement obtenir les valeurs mesurées d'humidité et de température en utilisant l'objet créé lors de la création de la classe de dht11.py. Voyons un exemple d'utilisation réelle d'une instance.

dht11_example.py(Avant correction)

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)

Veuillez noter que ʻinstance = dht11.DHT11 (pin = 14) est la valeur par défaut. Si vous êtes déjà connecté avec GPIO14, vous n'avez rien à faire ici, mais si vous avez sélectionné GPIO4` lors de la conception du circuit plus tôt, veuillez le corriger comme ceci.

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)

Ceci complète le code de mesure de la température et de l'humidité à partir du DHT11. Exécutons-le comme un contrôle d'opération.

sudo python dht11_example.py

_ * Assurez-vous de l'exécuter avec les privilèges root ou sudo!. Sinon, vous obtiendrez une erreur. _

Espérons que la ligne de commande affichera la température et l'humidité. Si vous pouvez confirmer ce qui précède, le contrôle de fonctionnement du DHT11 est terminé. Vive le bon travail.

Inscrivez-vous avec l'API Twitter pour créer un TweetBot.

Inscrivez-vous avec l'API Twitter pour créer un TweetBot.

De là, accédez à la page dédiée et appuyez sur Créer une nouvelle application pour vous inscrire. https://apps.twitter.com/

[Attention 1] Un numéro de téléphone est nécessaire pour enregistrer l'API Twitter et la langue doit être [anglais].

Un numéro de téléphone est requis pour s'inscrire à l'API Twitter. Sinon, vous vous fâcherez comme ça.

J'enregistre donc mon numéro de téléphone et entre le numéro que j'ai reçu du message pour authentifier mon téléphone ... mais cela ne fonctionne toujours pas.

Que ce soit un bug ou une utilisation, ou si un ingénieur Twitter ne travaille pas ~~, je ne connais pas les détails, mais je changerai le paramètre de langue de Twitter de [japonais] à [anglais].

Étant donné que l'authentification avec un téléphone mobile est requise pour utiliser l'API et les applications Twitter, comment s'authentifier.

Si vous effectuez à nouveau l'authentification téléphonique dans cet état, vous pouvez accéder en toute sécurité à la page d'inscription de l'API Twitter, alors enregistrez l'API.

[Attention 2] Vous ne pouvez pas continuer à publier le même message dans un court laps de temps.

Il n'est pas possible de tweeter le même message à la suite en utilisant l'API Twitter, probablement à cause de la prévention du spam, alors utilisons les horodatages pour pouvoir publier des tweets similaires dans un court laps de temps. Lors de l'affichage de la température et de la température ambiante comme cette heure, le même tweet peut être émis, il est donc recommandé de mettre intentionnellement un horodatage entre les deux.

Tweet de Raspberry Pi.

Après vous être enregistré auprès de l'API, vous aurez besoin des quatre clés API suivantes.

• CONSUMER_KEY
• CONSUMER_SECRET
• ACCESS_KEY
• ACCESS_SECRET

Ceux-ci correspondent aux numéros suivant les quatre éléments suivants sur la page API Twitter.

Si vous pouvez confirmer les 4 clés ci-dessus, créons un bot Twitter et vérifions le fonctionnement.

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] L'heure actuelle est'+current_time+'est!')

Même si une erreur se produit, l'horodatage est inséré, vous pouvez donc publier en continu, afin que vous puissiez déboguer immédiatement. Si la publication réussit, l'heure actuelle doit être publiée sur votre TL. C'est la fin de la vérification des opérations avec l'API Twitter.

Exécutez dht11_tweet.py régulièrement avec crontab.

À ce stade, vous pouvez imaginer que vous pouvez publier la température et l'humidité sur Twitter en combinant le dht11_example.py que vous avez créé en premier et le tweet.py que vous venez de créer.

Enfin, terminons le dht11_tweet.py souhaité avec deux codes sources.

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 = '[Informations sur la température et l'humidité]'+'Heure actuelle'+current_time
            +'Température:'+str(result.temperature)+'C'est ℃.'+'Humidité:'+str(result.humidity)
            +'%est.')

        break

    time.sleep(1)

Comme vous pouvez le voir en exécutant plusieurs fois dht11_example.py, DHT11 (capteur de température et d'humidité) n'est pas aussi précis. Par conséquent, lors de l'exécution, la valeur mesurée n'est pas toujours renvoyée et il arrive souvent que les données ne puissent pas être lues. Dans ce cas, puisque «l'instance» elle-même n'est pas générée, «result.temperature» et «result.humidity» inclus dans «api.update_status» ne sont pas appelés, donc une erreur se produit et le message échoue. .. Pour cette raison

while True:
    result = instance.read()

Répétez jusqu'à ce que = __ [état où la température et la température ambiante peuvent être mesurées] __ où l'instance est générée par l'instruction while. De plus, comme la publication peut être la première fois que la génération de l'instance est réussie, mettez «break» à la fin de «api.update_status». En faisant cela, il est possible de tweeter une seule fois tout en mesurant de manière fiable la température et l'humidité.

Avec ce qui précède, le TweetBot qui marmonne la température et l'humidité approximatives est terminé. Cependant, c'est toujours une méthode manuelle, donc à la fin je l'enregistrerai dans crontab et marmonnerai régulièrement pour lui donner l'apparence d'un Bot.

L'explication de «crontab» est omise ici, mais le but est de le considérer comme un planificateur de tâches. Un programme qui exécute des commandes et des scripts à des moments précis.

[Résumé de l'utilisation de 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)

Tapez crrontab -e pour ouvrir crontab. Au fait, la sauvegarde d'écrasement est «Ctr + o» et la sortie est «Ctr + x». Gardez à l'esprit que ces deux commandes sont fréquemment utilisées.

Par exemple, si vous souhaitez publier depuis TweetBot toutes les 15 minutes, écrivez comme suit.

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

Si cela ne fonctionne pas correctement, veuillez déboguer en consultant le site suivant.

Trois points pour vérifier quand crontab ne fonctionne pas + α

Ceci complète le TweetBot, qui murmure la température et l'humidité toutes les 15 minutes. Vive le bon travail.

Puisque ce code est entièrement écrit en Python, par exemple, si vous affichez Graph ou atteignez la température spécifiée Je pense qu'il sera possible de faire retentir le buzzer, donc si vous êtes intéressé, essayez-le.