🏂🏽 👩🏽‍🎓 👧🏿 Intelligentes Gewächshaus im Telegramm 👨🏿‍🎨 🐷 🕙

Guten Tag. Auf unserer Website befindet sich ein Gewächshaus. Das Hauptproblem ist die Überhitzung bei heißem Wetter in erster Linie für den sibirischen Frühling konzipiert. Der einzige Ausweg besteht darin, Türen und Fenster ständig zu öffnen / schließen, um die Temperatur aufrechtzuerhalten. Dies ist jedoch nicht immer möglich. Und wenn dies nicht getan wird, steigt die Temperatur auf +50 Grad, was eindeutig nicht gut ist. Und abends kann alles eingefroren werden. Und so begann seine Automatisierung.

Zuerst haben wir einen Raspberry Pi 2 gekauft. Nachdem wir uns damit befasst haben, haben wir den DS18B20-Sensor für diesen Artikel angeschlossen . Dann wurden zwei Gebrauchtwagenfenster gekauft. Wie alle Gleichstrommotoren bewegen sie sich entsprechend der Polarität. Deshalb schließen wir zwei Relais an jeden Motor an: eines zum Öffnen, das andere zum Schließen. Wir verbinden diese Relais bereits über Transistoren mit den GPIO-Ports selbst. Und wir speisen das Ganze mit einer 12V Batterie. Um die Motoren nicht zu verbrennen, wurden an den äußersten Positionen des Fensters Endschalter installiert, und wenn das Fenster geöffnet / geschlossen wurde, wurde das Netzwerk vollständig zerrissen.

Für die Kommunikation verwenden wir den TP-LINK WiFi-Adapter mit der fortschrittlichen Double Square-Antenne für den zuverlässigen Empfang von ~~WIFI-Nachbarn~~Heim-WIFI-Router, der sich in einer Entfernung von 40 Metern befindet.

Jetzt schreiben wir ein Programm zur Steuerung dieser Laufwerke. Python wurde ausgewählt, da es Raspberry Pi und speziell GPIO-Ports normal unterstützt. Um das Fenster zu öffnen, müssen wir +3,3 V an den Transistor anlegen, der das Relais aktiviert, und dann beginnt er, das Fenster zu öffnen. Um es zu schließen, machen wir dasselbe, nur in diesem Fall ist unser Relais gegenüber dem Antrieb angeschlossen. Aber bei Raspberry legen wir einfach Strom an den einen oder anderen Port an. Wir haben beschlossen, dass wir bei einer Temperatur von mehr als 26 ° C das Fenster für 1 Sekunde öffnen. Dann warten wir 3 Minuten. Wenn es wieder heiß ist, öffnen Sie das zweite Fenster innerhalb einer Sekunde. Wir warten wieder 3 Minuten und machen es noch einmal. Das gleiche gilt für das Schließen, nur hier sollte die Temperatur unter 24 Grad liegen. Und hier ist der Code:

temp.py.

import RPi.GPIO as GPIO
import time
import os
import datetime

GPIO.setmode(GPIO.BOARD)
GPIO.cleanup()
GPIO.setup(31, GPIO.OUT)
GPIO.setup(33, GPIO.OUT)
GPIO.setup(35, GPIO.OUT)
GPIO.setup(37, GPIO.OUT)

# 
def gettemp():
  if os.path.isdir("id "): #  ,   
    tfile2=open("/sys/bus/w1/devices/id ")
    ttext2=tfile2.read()
    tfile2.close()
    temp2=ttext2.split("\n")[1].split(" ")[9]
    t2=float(temp2[2:])/1000
    print t2
  else: # ,   
    print ('File not found')
    t2==24
  return t2

t2=24 #    
while True:  
t2=gettemp()
  if    t2<24: #   24,      
 
        GPIO.output(37, 1)
        print ("close1")
        time.sleep(1)
        GPIO.output(37, 0)

  elif  t2>26: #  26,      
        GPIO.output(35, 1)
        print ("open1")
        time.sleep(2)
        GPIO.output(35, 0)
        
  else: #   
        print ("none1")
  time.sleep(180)# 3 

#  
t2=gettemp()

#   ,    .
  if    t2<24:
        GPIO.output(33, 1)
        print ("close2")
        time.sleep(1)
        GPIO.output(33, 0)

  elif  t2>26:
  
        GPIO.output(31, 1)
        print ("open2")
        time.sleep(1)
        GPIO.output(31, 0)
     

  else:
        print ("none2")


#  3 
  time.sleep(180)

, .

Nachdem wir Apache auf der Raspbian-Distribution installiert hatten, konnten wir die Seite einen Monat lang nicht über das Internet erreichen. Was einfach nicht. Ports einrichten, öffnen, nichts half. Darüber hinaus funktionierte alles im lokalen Netzwerk. Dann haben wir die traurige Wahrheit erfahren: Wir stehen hinter NAT. Und unser Betreiber bietet keine dedizierten IP-Dienste an (Mitarbeiter von Hello to Telecom Region). Durch viele Problemumgehungen sortiert, aber es wurde nichts daraus. Ich habe versucht, eine Webschnittstelle auf dem Hosting zu erstellen, benötige aber auch IP, um die Datenbank zu synchronisieren. Der IPv6-Broker war zu diesem Zeitpunkt bereits geschlossen. Und ein VPN zu machen ist teuer, weil Sie alles kostenlos wollen. Und dann entschieden sie sich für den Telegramm-Bot. Wie sich herausstellte, gibt es zwei Modi: ständige Serverabfrage und direktes Senden von Nachrichten an uns. Die erste Option war geeignet, weil benötigt uns keine IP-Adresse. Beim Stöbern im Internet fand ich eine Bibliothek:pytelegrambotapi. Und machen Sie sich daran, Code zu schreiben. Es stimmte, es gab Probleme. Die kaum gefundene MySQL-Bibliothek weigerte sich, in die Datenbank zu schreiben, las aber alles normal daraus. Ich musste eine Krücke bauen: Daten in eine im RAM gespeicherte Datei übertragen, dann ein Bash-Skript ausführen, das die Daten liest und in der Datenbank speichert.

Wir machen die Datei config.ini, wir werfen sie dort hin:

[mysql]
host = localhost
database = telegram
user = root
password = secret

Vergessen Sie nicht, die Daten durch Ihre eigenen zu ersetzen.

Erstellen Sie eine python_mysql_dbconfig.py-Datei mit den folgenden Inhalten:

from configparser import ConfigParser
 
def read_db_config(filename='config.ini', section='mysql'):
    """ Read database configuration file and return a dictionary object
    :param filename: name of the configuration file
    :param section: section of database configuration
    :return: a dictionary of database parameters
    """
    # create parser and read ini configuration file
    parser = ConfigParser()
    parser.read(filename)
 
    # get section, default to mysql
    db = {}
    if parser.has_section(section):
        items = parser.items(section)
        for item in items:
            db[item[0]] = item[1]
    else:
        raise Exception('{0} not found in the {1} file'.format(section, filename))
 
    return db

Wir müssen auch die Datei python_mysql_connect2.py mit folgendem Inhalt erstellen:

from mysql.connector import MySQLConnection, Error
from python_mysql_dbconfig import read_db_config

def connect():
    """ Connect to MySQL database """

    db_config = read_db_config()

    try:
        print('Connecting to MySQL database...')
        conn = MySQLConnection(**db_config)

        if conn.is_connected():
            print('connection established.')
        else:
            print('connection failed.')

    except Error as error:
        print(error)

    finally:
        conn.close()
        print('Connection closed.')

if __name__ == '__main__':
    connect()

Jetzt haben wir alles für die Arbeit mit der Datenbank vorbereitet.

Lassen Sie uns ein wenig von der Datenbank abschweifen und direkt mit der Kommunikation mit dem Bot fortfahren. Nun, wie immer, schreibe @BotFather und nimm ihm ein Zeichen. Erstellen Sie die Datei config.py und schreiben Sie zwei Zeilen hinein:

# -*- coding: utf-8 -*-
token = ' '

Ich habe beschlossen, drei Funktionen im Bot zu implementieren:

Temperatur bekommen
Schnappschüsse machen
Fensterverwaltung

Mit dem ersten ist alles einfach, auf Anfrage lesen wir die Temperaturdatei und senden sie an den Benutzer.

Mit Bildern schwieriger. Ich verwende das Motion-Dienstprogramm. Bitten Sie in seinen Parametern darum, Bilder in einem Ordner im RAM abzulegen. Nehmen wir an, alle 30 Sekunden. Und wir machen Dateien mit identischen Namen, und sie ersetzen sich einfach gegenseitig. Und dann senden wir auf Anfrage die Datei an den Benutzer.

Nun, das dritte, komplexeste Modul: Fensterverwaltung. Meine Hauptaufgabe: Damit die Automatisierung funktioniert, können wir sie bei Bedarf ausschalten. Ich habe es so gemacht. Erstellt eine weitere Datei im RAM. Wenn wir eine Anfrage zum Öffnen / Schließen, leichten Öffnen, Schließen des Fensters oder Ein- / Ausschalten der Automatisierung senden, schreibt der Bot die Befehlsnummer in diese Datei. Alle fünf Sekunden liest das Fensterverwaltungsprogramm diese Datei und führt sie aus, wenn sie den Befehl erkennt. Nach der Ausführung wird in dieselbe Datei geschrieben, dass alles gut gelaufen ist. Der Bot liest die Datei erneut und benachrichtigt uns, dass der Befehl ausgeführt wurde.

Nun, jetzt der Quellcode. Erstens das gleiche Programm zum Öffnen von Fenstern, das nur für einen Bot (temp.py) wiederholt wurde:

temp.py.

import RPi.GPIO as GPIO
import time
import os
import datetime

GPIO.setmode(GPIO.BOARD)
GPIO.cleanup()
GPIO.setup(31, GPIO.OUT)
GPIO.setup(33, GPIO.OUT)
GPIO.setup(35, GPIO.OUT)
GPIO.setup(37, GPIO.OUT)

#  ,    
f = open('/mnt/raw/wind', 'w')
f.write('OK')
f.close()

#,   
f = open('/mnt/raw/pos', 'w')
f.write('1')
f.close()

# 
def gettemp():
  if os.path.isdir("/sys/bus/w1/devices/id "): #  ,   
    tfile2=open("/sys/bus/w1/devices/id /w1_slave")
    ttext2=tfile2.read()
    tfile2.close()
    temp2=ttext2.split("\n")[1].split(" ")[9]
    t2=float(temp2[2:])/1000
    print t2
  else: # ,   
    print ('File not found')
    t2==24
  return t2

#   
i=1
# 
t2=24

#   
def info():
    f = open('/mnt/raw/wind')
    com = f.read()
    f.close()
    return com

# ,   
def ans():
    f = open('/mnt/raw/wind', 'w')
    f.write('OK')
    f.close()
    print ("OK")

# 
def rob():
    c = info()
    if c=="10":
        GPIO.output(37, 1)
        print ("close1")
        time.sleep(3)
        GPIO.output(37, 0)
        ans()
    elif c=="11":
        GPIO.output(35, 1)
        print ("open1")
        time.sleep(2)
        GPIO.output(35, 0)
        ans()
    elif c=="12":
        GPIO.output(37, 1)
        print ("close1")
        time.sleep(3)
        GPIO.output(37, 0)
        ans()
    elif c=="13":
        GPIO.output(35, 1)
        print ("open1")
        time.sleep(1)
        GPIO.output(35, 0)
        ans()
    elif c=="20":
        GPIO.output(33, 1)
        print ("close2")
        time.sleep(3)
        GPIO.output(33, 0)
        ans()
    elif c=="21":
        GPIO.output(31, 1)
        print ("open2")
        time.sleep(3)
        GPIO.output(31, 0)
        ans()
    elif c=="22":
        GPIO.output(33, 1)
        print ("close2")
        time.sleep(1)
        GPIO.output(33, 0)
        ans()
    elif c=="23":
        GPIO.output(31, 1)
        print ("open2")
        time.sleep(1)
        GPIO.output(31, 0)
        ans()
    elif c=="30":
        global i
        i=0
        ans()
        f = open('/mnt/raw/pos', 'w')
        f.write('0')
        f.close()
        print('30')
        global i
        i=0
        ans()
    elif c=="31":
        f = open('/mnt/raw/pos', 'w')
        f.write('1')
        f.close()
        print('31')
        global i
        i=1
        ans()
        
while True:

#   
 rob()

#,   
 if i==1:

  gettemp()

  if    t2<24:
 
        GPIO.output(37, 1)
        print ("close1")
        time.sleep(1)
        GPIO.output(37, 0)

  elif  t2>26:

        GPIO.output(35, 1)
        print ("open1")
        time.sleep(2)
        GPIO.output(35, 0)

  else:
        print ("none1")
       
  # 3 ,       
  j=0
  while(j<36):
      rob()
      time.sleep(5)
      j=j+1
      if i==0:
          break
  gettemp()

  if    t2<24:
        GPIO.output(33, 1)
        print ("close2")
        time.sleep(1)
        GPIO.output(33, 0)
       
  elif  t2>26:
  
        GPIO.output(31, 1)
        print ("open2")
        time.sleep(1)
        GPIO.output(31, 0)

  else:

        print ("none2")

  j=0
  while(j<36):
      rob()
      time.sleep(5)
      j=j+1
      if i==0:
          break

Aber jetzt reden wir über den Bot selbst. Wie gesagt, ich benutze die PyTelegramBotApi-Bibliothek. Wenn Sie sich der Dokumentation auf GitHub zuwenden , können Sie verstehen, dass der Bot Handler verwendet, um Befehle zu verarbeiten. Handler ist ein Ereignis in unserem Programm, das eine Aktion definiert. In unserem Fall ist dies eine bestimmte Phrase in der Nachricht. Und Action ist alles, was wir in Python tun können. In diesem Fall senden wir dem Benutzer einige Informationen an den Benutzer oder schreiben Befehle für Windows in eine Datei. Grundsätzlich besteht unser Programm aus diesen Handlern und dem Server Polling-Befehl.

Aber ich habe auch eine weitere interessante Sache geschrieben und hinzugefügt: den Autorisierungsblock. Nun, wie der Name schon sagt, soll es unser Gewächshaus vor unbefugtem Zugriff schützen. Es funktioniert einfach. Wenn Sie sich zum ersten Mal mit dem Bot verbinden, werden Sie nach einem Passwort gefragt. Wenn wir es richtig eingeben, fügt uns der Bot der Datenbank hinzu und bei den nächsten Verbindungen müssen wir uns nicht mehr anmelden. Der Bot erkennt uns anhand der Chat-ID. Wir speichern die Chat-ID des letzten Benutzers in einer Variablen, um die Datenbank nicht ständig abzurufen.

Erstellen Sie nun die Datei daba.py und schreiben Sie Folgendes:

daba.py.

from mysql.connector import MySQLConnection, Error
from python_mysql_dbconfig import read_db_config
import time

def getkey(): #   
    try:
        dbconfig = read_db_config()
        conn = MySQLConnection(**dbconfig)
        cursor = conn.cursor()
        cursor.execute("SELECT key2 FROM tkey where id=0")

        row = cursor.fetchone()

        return row
        print(row)
  

    except Error as e:
        print(e)

    finally:
        cursor.close()
        conn.close()
def sendup(): #    ( )
    stime=time.time()
    query = "INSERT INTO uptime(datetime, also) " \
    "VALUES(now(), 20)"
    args=(stime)
    try:
        dbconfig = read_db_config()
        conn = MySQLConnection(**dbconfig)
        cursor = conn.cursor()
        cursor.execute(query)

        row = cursor.fetchone()

        return(row)
        print(row)
  

    except Error as e:
        print(e)

    finally:
        cursor.close()
        conn.close()
def getid(idi): #   id   
    query="SELECT accecpt FROM users WHERE chatid ='"+str(idi)+"'"
    try:
        dbconfig = read_db_config()
        conn = MySQLConnection(**dbconfig)
        cursor = conn.cursor()
        cursor.execute(query)

        row = cursor.fetchone()
        #print (str(row))
        if str(row)=="None":
            return 0;
            print (0)
        else:
            return 20;

  

    except Error as e:
        print(e)

    #finally:
        #cursor.close()
        #conn.close()
def newuser(idi): #    
    query = ("INSERT INTO users SET `chatid`='12345'")
    try:
        dbconfig = read_db_config()
        conn = MySQLConnection(**dbconfig)
        cursor = conn.cursor()
        cursor.execute(query)

        row = cursor.fetchone()

        print(row)
  

    except Error as e:
        print(e)
        return(e)

    finally:
        cursor.close()
        conn.close()

if __name__ == '__main__':
    query_with_fetchone()

Lassen Sie uns auch gleich einige weitere Hilfsskripte erstellen. Erstellen Sie eine newuser.sh-Datei und schreiben Sie darauf:

#!/bin/bash
a=`cat /mnt/raw/user`
cat /dev/null > /mnt/raw/user

mysql -u root -pkoshak << EOF
use telegram;
INSERT INTO users(chatid) VALUES('$a');
EOF

Erstellen Sie zwei Skripte zum Starten des Bots und des Windows-Programms:

#!/bin/bash
i=0
while [ $i = 0 ]
do
echo New python
sleep 5
python3 bot.py
done

Und noch eins:

#!/bin/bash
i=0
while [ $i = 0 ]
do
echo New python
sleep 5
python3 temp.py
done

"Warum machen wir das?" du fragst. Und hier ist die Tatsache, dass das Programm manchmal aufgrund einer instabilen Internetverbindung oder eines Fehlers auf dem Telegrammserver abstürzen kann. Und das Skript treibt es in einem ewigen Zyklus an: Es flog heraus - es startete nach 5 Sekunden wieder. Und für Fenster habe ich es für jeden Feuerwehrmann getan: Plötzlich stürzt das Programm aufgrund einer Fehlfunktion ab, aber wir sind nicht im Gewächshaus, wir kehren zurück und wir werden Tomatensuppe oder Tomateneis haben.

Nun und das Wichtigste ist das Bot-Skript selbst:

bot.py

# -*- coding: utf-8 -*-
import config
import telebot
import subprocess
import time
from telebot import types
import datetime
import os
from daba import getkey
from daba import sendup
from daba import getid
#from daba import newuser
#from temp import tep
import os

# 
f = open('/mnt/raw/user', 'tw', encoding='utf-8')
f.close()

global par
par=0

#   
global a
a="  .    /auth []"

#  
def get_temp():
  if os.path.isdir("/sys/bus/w1/devices/id "):

    tfile2=open("/sys/bus/w1/devices/id /w1_slave")
    ttext2=tfile2.read()
    tfile2.close()
    temp2=ttext2.split("\n")[1].split(" ")[9]
    t2=float(temp2[2:])/1000
    return t2

  else:
    print ('File not found')
  
#
keyword=str(getkey())[2:-3]

# 
bot = telebot.TeleBot(config.token)
print (sendup())
#  

######################### ##########################################
markup2 = types.ReplyKeyboardMarkup(row_width=1, resize_keyboard=True) #, ,     
markdown = types.ReplyKeyboardHide() #
itembtn5 = types.KeyboardButton(' ') #  5
markup2.add(itembtn5) #   
######################### ##########################################


#########################  ##########################################
markup = types.ReplyKeyboardMarkup(row_width=3, resize_keyboard=True) #, ,     
itembtn1 = types.KeyboardButton('  ') #  1
itembtn4 = types.KeyboardButton('  ')
itembtn2 = types.KeyboardButton('  ') #  2
markup.add(itembtn1, itembtn4, itembtn2) #   
#########################  ##########################################


######################### ##########################################

markup3 = types.ReplyKeyboardMarkup(row_width=2, resize_keyboard=True) #, ,     
itembtn10 = types.KeyboardButton('   ') #  10
itembtn11 = types.KeyboardButton('️  ')
itembtn12 = types.KeyboardButton(' ')
markup3.add(itembtn10, itembtn11, itembtn12) #   

markup4 = types.ReplyKeyboardMarkup(row_width=2, resize_keyboard=True) #, ,     
itembtn13 = types.KeyboardButton('   ') #  13
markup4.add(itembtn13, itembtn11, itembtn12) #   

markup5 = types.ReplyKeyboardMarkup(row_width=2, resize_keyboard=True) #, ,     
itembtn14 = types.KeyboardButton('  ') #  14
itembtn15 = types.KeyboardButton('  ') #  15
itembtn16 = types.KeyboardButton('️ ') #  16
markup5.add(itembtn14, itembtn15, itembtn16) #   

markup6 = types.ReplyKeyboardMarkup(row_width=2, resize_keyboard=True) #, ,     
itembtn17 = types.KeyboardButton('️   ') #  17
itembtn18 = types.KeyboardButton('️   ') #  18
itembtn19 = types.KeyboardButton('   ') #  19
itembtn20 = types.KeyboardButton('   ') # 20
itembtn21 = types.KeyboardButton('️ ') #  21
markup6.add(itembtn17, itembtn18, itembtn19, itembtn20, itembtn21) #   

markup7 = types.ReplyKeyboardMarkup(row_width=2, resize_keyboard=True) #, ,     
itembtn22 = types.KeyboardButton('️   ') #  22
itembtn23 = types.KeyboardButton('️   ') #  23
itembtn24 = types.KeyboardButton('   ') # 24
itembtn25 = types.KeyboardButton('   ') # 25
markup7.add(itembtn22, itembtn23, itembtn24, itembtn25, itembtn21) #   
######################### ##########################################
bot.send_message(45215125, "")#   chat-id


    
#   
def pos():
    f = open('/mnt/raw/pos')
    com = f.read()
    f.close()
    return com

#
def avtor(idi):
    global par#      
    if par==idi:
            return 0
    else:#    ,    ,  0
            if getid(str(idi))==20:
                par=idi#   
                return 0
            else:#     
                bot.send_message(idi, "  .    /auth []", reply_markup=markup2)
                return 1    
        


@bot.message_handler(regexp=" ")
def auth(message):
    bot.send_message(message.chat.id, " /auth []")

# 
@bot.message_handler(commands=['auth'])
def start2(message):
    if message.text[6:]==keyword:#   
      if getid(str(message.chat.id))==20:#    ,         20
        bot.send_message(message.chat.id, "  ")
      else:
        global par
        bot.send_message(message.chat.id, "", reply_markup=markup)
        par=message.chat.id
        # chat-id   
        f = open('/mnt/raw/user', 'w')
        f.write(str(message.chat.id))
        f.close()
        os.system('newuser.sh')
        print (message.chat.id)
        print (par)
    else:
        bot.send_message(message.chat.id, "")
        print (keyword)
        print (message.text[6:])
        print (message.chat.id)


#  /start
@bot.message_handler(commands=['start'])
def start(message):
     global par
     if avtor(message.chat.id)!=0:
         print (par)
         bot.send_message(message.chat.id, "   .    /auth []", reply_markup=markup2)
     else:
	     bot.send_message(message.chat.id, "   .  /help,  ,    .")



#   - /help
@bot.message_handler(commands=['help'])
def help(message):
  if avtor(message.chat.id)==0:
     mas='       . \n    ,    :  \n   - /help \n       :)'
     bot.send_message(message.chat.id, mas, reply_markup=markup)
     print (message.chat.id, message.text)

	
 
#     
@bot.message_handler(commands=['show'])
def show(message):
  if avtor(message.chat.id)==0:
     mas=' '
     bot.send_message(message.chat.id, mas, reply_markup=markup)
     print (message.chat.id, message.text)



# 
@bot.message_handler(regexp="  ")
def temp(message):
  if avtor(message.chat.id)==0:
     tp=get_temp()
     mas='    : '+str(tp)+'°C'
     bot.send_message(message.chat.id, mas)
     print (message.chat.id, message.text)
    

# 
@bot.message_handler(regexp="  ")
def photo(message): 
     if avtor(message.chat.id)==0: 
         path='/mnt/raw/photo/foto.jpg' #    
         try:
             f = open(path, 'rb') #  - 
             bot.send_photo(message.chat.id, f) # 
             print (message.chat.id, message.text)
         except:
             bot.send_message(message.chat.id, "  :(")


#   
@bot.message_handler(regexp="  ")
def windows(message):
   if avtor(message.chat.id)==0:
       print ("window")
       print (pos())
       if str(pos())[0]=='1':
           bot.send_message(message.chat.id, "", reply_markup=markup3)#  ,      « »
       else: 
           bot.send_message(message.chat.id, "", reply_markup=markup4)#     

# 
@bot.message_handler(regexp=" ")
def windows(message):
   if avtor(message.chat.id)==0:
       bot.send_message(message.chat.id, "",  reply_markup=markup)

# 
@bot.message_handler(regexp="   ")
def windows(message):
   if avtor(message.chat.id)==0:
       f = open('/mnt/raw/wind', 'w')# 
       f.write('30')#   ,     30
       f.close()# 
       k="No"#  
       while k[0:2]!="OK":#  
           time.sleep(5)# 5 
           f = open('/mnt/raw/wind')# 
           k = f.read()# 
           f.close()#
           print(k[0:2])
       bot.send_message(message.chat.id, "",  reply_markup=markup4)

@bot.message_handler(regexp="   ")
def windows(message):
   if avtor(message.chat.id)==0:
       f = open('/mnt/raw/wind', 'w')
       f.write('31')
       f.close()
       k="No"
       while k[0:2]!="OK":
           time.sleep(5)           
           f = open('/mnt/raw/wind')
           k = f.read()
           f.close()
           print(k[0:2])
       bot.send_message(message.chat.id, "",  reply_markup=markup3)

@bot.message_handler(regexp="️  ")
def windows(message):
   if avtor(message.chat.id)==0:
       bot.send_message(message.chat.id, "",  reply_markup=markup5)

@bot.message_handler(regexp="️ ")
def windows(message):
   if avtor(message.chat.id)==0:
       if str(pos())[0]=='1':
           bot.send_message(message.chat.id, "", reply_markup=markup3)
       else: 
           bot.send_message(message.chat.id, "", reply_markup=markup4)

@bot.message_handler(regexp="️ ")
def windows(message):
   if avtor(message.chat.id)==0:
       bot.send_message(message.chat.id, "",  reply_markup=markup5)

#  
@bot.message_handler(regexp="  ")
def windows(message):
   if avtor(message.chat.id)==0:
       bot.send_message(message.chat.id, "",  reply_markup=markup6)
@bot.message_handler(regexp="  ")
def windows(message):
   if avtor(message.chat.id)==0:
       bot.send_message(message.chat.id, "",  reply_markup=markup7)

@bot.message_handler(regexp="️   ")
def windows(message):
   if avtor(message.chat.id)==0:
       f = open('/mnt/raw/wind', 'w')
       f.write('11')
       f.close()
       k="No"
       while k[0:2]!="OK":
           time.sleep(5)           
           f = open('/mnt/raw/wind')
           k = f.read()
           f.close()
           print(k[0:2])
       bot.send_message(message.chat.id, "",  reply_markup=markup6)

@bot.message_handler(regexp="️   ")
def windows(message):
   if avtor(message.chat.id)==0:
       f = open('/mnt/raw/wind', 'w')
       f.write('10')
       f.close()
       k="No"
       while k[0:2]!="OK":
           time.sleep(5)           
           f = open('/mnt/raw/wind')
           k = f.read()
           f.close()
           print(k[0:2])
       bot.send_message(message.chat.id, "",  reply_markup=markup6)

@bot.message_handler(regexp="   ")
def windows(message):
   if avtor(message.chat.id)==0:
       f = open('/mnt/raw/wind', 'w')
       f.write('13')
       f.close()
       k="No"
       while k[0:2]!="OK":
           time.sleep(5)           
           f = open('/mnt/raw/wind')
           k = f.read()
           f.close()
           print(k[0:2])
       bot.send_message(message.chat.id, "",  reply_markup=markup6)

@bot.message_handler(regexp="   ")
def windows(message):
   if avtor(message.chat.id)==0:
       f = open('/mnt/raw/wind', 'w')
       f.write('12')
       f.close()
       k="No"
       while k[0:2]!="OK":
           time.sleep(5)           
           f = open('/mnt/raw/wind')
           k = f.read()
           f.close()
           print(k[0:2])
       bot.send_message(message.chat.id, "",  reply_markup=markup6)

@bot.message_handler(regexp="️   ")
def windows(message):
   if avtor(message.chat.id)==0:
       f = open('/mnt/raw/wind', 'w')
       f.write('21')
       f.close()
       k="No"
       while k[0:2]!="OK":
           time.sleep(5)           
           f = open('/mnt/raw/wind')
           k = f.read()
           f.close()
           print(k[0:2])
       bot.send_message(message.chat.id, "",  reply_markup=markup7)

@bot.message_handler(regexp="️   ")
def windows(message):
   if avtor(message.chat.id)==0:
       f = open('/mnt/raw/wind', 'w')
       f.write('20')
       f.close()
       k="No"
       while k[0:2]!="OK":
           time.sleep(5)           
           f = open('/mnt/raw/wind')
           k = f.read()
           f.close()
           print(k[0:2])
       bot.send_message(message.chat.id, "",  reply_markup=markup7)

@bot.message_handler(regexp="   ")
def windows(message):
   if avtor(message.chat.id)==0:
       f = open('/mnt/raw/wind', 'w')
       f.write('23')
       f.close()
       k="No"
       while k[0:2]!="OK":
           time.sleep(5)           
           f = open('/mnt/raw/wind')
           k = f.read()
           f.close()
           print(k[0:2])
       bot.send_message(message.chat.id, "",  reply_markup=markup7)

@bot.message_handler(regexp="   ")
def windows(message):
   if avtor(message.chat.id)==0:
       f = open('/mnt/raw/wind', 'w')
       f.write('22')
       f.close()
       k="No"
       while k[0:2]!="OK":
           time.sleep(5)           
           f = open('/mnt/raw/wind')
           k = f.read()
           f.close()
           print(k[0:2])
       bot.send_message(message.chat.id, "",  reply_markup=markup7)

#  ,   
@bot.message_handler(content_types=["text"])
def repeat_all_messages(message):
   if avtor(message.chat.id)==0:
         bot.send_message(message.chat.id, "    .  /help,    ")
         print (message.chat.id, message.text)

#     
if __name__ == '__main__':
        bot.polling()

Vergessen Sie nicht, hier die Sensor-ID, die Chat-ID und den Pfad zum Abschnitt im RAM anzugeben. Jetzt haben wir fast alles fertig. Herunterladen diese Dump und eine Datenbank auf dem Server füllen, und vergessen Sie nicht die Partition in dem RAM zu montieren, denkt 10MB genug von ihrer Kehle. Wir starten zwei unserer Starter-Skripte und freuen uns. Das Standardkennwort lautet telbot. Ändern Sie es in der Datenbank-Schlüsseltabelle.

SMS informieren

Ebenso SMS-Informationen bei Überhitzung. Erstellen Sie die Datei sms.py:

sms.py

#!/usr/bin/env python
# -*- coding: utf8 -*-
 
"""   .. t_aleksandr_v@inbox.ru 17.02.2015 """
 
"""        sms.ru """
"""   :"""
 
""" -i  --idsender - id   sms.ru"""
""" -t  --to -      79219996660"""
""" -s  --subject -    """
 
 
from urllib2 import urlopen
from optparse import OptionParser
 
 
def sendsms(idsender,subject,to):
 
    subject = subject.replace(" ","+")
    url="http://sms.ru/sms/send?api_id=%s&text=%s&to=%s" %(idsender,subject,to)
    res=urlopen(url)
 
if __name__ == '__main__':
 
    parser = OptionParser()
 
    parser.add_option("-i", "-- ", dest="idsender", default=" ", help="ID user on sms.ru", metavar="IDSENDER")
    parser.add_option("-t", "-- ", dest="to", default=" ", help="to telephone number", metavar="TO")
    parser.add_option("-s", "--temperatyra 32", dest="subject", default="Jara tut, otkroy okno", help="Name of subject", metavar="SUBJECT")
 
    (options, args) = parser.parse_args()
 
    sendsms(options.idsender,options.subject,options.to)

Wir registrieren uns auf sms.ru und nehmen dort den API-Schlüssel im Abschnitt für Programmierer. Vergessen Sie auch nicht, Ihre Telefonnummer im Skript anzugeben.

Im Programm zur Verwaltung von Fenstern deklarieren wir eine Variable:

Vr=0

Fügen Sie dann diesen Code in die Perpetual-Schleife ein:

d = datetime.today()
V = d.strftime('%H')
V = int(V)
 if    (t2>32 and Vr!=V): 
        print (V)
        Vr=V
        os.system('/home/samba/sms.py')

Im Moment ist die Schwellentemperatur 32, bei hohen Temperaturen wird einmal pro Stunde eine SMS gesendet, bis sie abfällt.

PS Pläne für die Zukunft, eine geregelte Heizung zu installieren und automatisch zu gießen.

Vielen Dank an alle, die bis zum Ende gelesen haben.

Intelligentes Gewächshaus im Telegramm

SMS informieren

More articles: