👼🏾 👝 🔁 Serre intelligente dans Telegram 🎴 👏🏾 👹

Bon après-midi Sur notre site il y a une serre. Son principal problème est la surchauffe par temps chaud, car conçu principalement pour le printemps sibérien. La seule issue est d'ouvrir / fermer constamment les portes et les fenêtres pour maintenir la température. Mais ce n'est pas toujours possible. Et si cela n'est pas fait, la température monte à +50 degrés, ce qui n'est clairement pas bon. Et le soir, tout peut être congelé. Et c'est ainsi qu'a commencé son automatisation.

Tout d'abord, nous avons acheté un Raspberry Pi 2. Après l'avoir réglé, nous avons connecté le capteur DS18B20 pour cet article . Ensuite, deux fenêtres de voiture d'occasion ont été achetées. Comme tous les moteurs à courant continu, ils se déplacent en fonction de la polarité. Par conséquent, nous connectons deux relais à chaque moteur: un pour l'ouverture, l'autre pour la fermeture. Nous connectons déjà ces relais via des transistors aux ports GPIO eux-mêmes. Et nous alimentons le tout avec une batterie 12V. De plus, afin de ne pas brûler les moteurs, des interrupteurs de fin de course ont été installés dans les positions extrêmes de la fenêtre, et si la fenêtre s'ouvrait / se fermait, le réseau était complètement déchiré.

Et pour la communication, nous utilisons l'adaptateur WiFi TP-LINK avec l'antenne Double Square avancée pour une réception fiable du ~~WIFI voisin~~routeur WIFI à domicile, qui est situé à une distance de 40 mètres.

Nous écrivons maintenant un programme pour contrôler ces disques. Python a été choisi, car il prend en charge normalement les ports Raspberry Pi et spécifiquement GPIO. Pour ouvrir la fenêtre, nous devons appliquer + 3,3 V au transistor, ce qui active le relais, puis il commencera à ouvrir la fenêtre. Pour le fermer, nous faisons de même, seulement dans ce cas notre relais est connecté en face du variateur. Mais sur Raspberry, nous appliquons simplement le courant à un port ou à l'autre. Nous avons décidé que si la température est supérieure à 26, nous ouvrons la fenêtre pendant 1 seconde. Ensuite, nous attendons 3 minutes. S'il fait à nouveau chaud, ouvrez la seconde fenêtre en une seconde. Nous attendons encore 3 minutes et recommençons. La même chose avec la fermeture, seulement ici, la température doit être inférieure à 24 degrés. Et voici le 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)

, .

Après avoir installé Apache sur la distribution Raspbian, nous n'avons pas pu accéder à la page depuis Internet pendant un mois. Ce qui n'a tout simplement pas fonctionné. Configurez les ports, ouvrez-les, rien n'y fait. De plus, tout fonctionnait sur le réseau local. Puis nous avons appris la triste vérité: nous sommes derrière NAT. Et notre opérateur ne fournit pas de services IP dédiés (Bonjour aux employés de la région Telecom). Trié par de nombreuses solutions de contournement, mais rien n'en est sorti. J'ai essayé de faire une interface web sur l'hébergement, mais j'ai également besoin d'IP pour synchroniser la base de données. Le courtier IPv6 avait déjà fermé à ce moment-là. Et faire un VPN coûte cher, car vous voulez tout gratuitement. Et puis ils ont décidé d'utiliser le bot Telegram. En fait, il a deux modes: l'interrogation constante du serveur et l'envoi direct de messages à nous. La première option était appropriée, car ne nécessite pas d'adresse IP. En fouillant sur Internet, j'ai trouvé une bibliothèque:pytelegrambotapi. Et commencer à écrire du code. Certes, il y avait des problèmes. La bibliothèque MySQL à peine trouvée a refusé d'écrire dans la base de données, mais a tout lu normalement. J'ai dû faire une béquille: transférer des données vers un fichier stocké dans la RAM, puis exécuter un script bash qui lit les données et les stocke dans la base de données.

Nous créons le fichier config.ini, nous le jetons là:

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

N'oubliez pas de remplacer les données par les vôtres.

Créez un fichier python_mysql_dbconfig.py avec le contenu suivant:

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

Nous devons également créer le fichier python_mysql_connect2.py, avec ce contenu:

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()

Nous avons maintenant tout préparé pour travailler avec la base de données.

Écartons un peu de la base de données et passons directement à la communication avec le bot. Eh bien, comme d'habitude, écrivez @BotFather et prenez-lui un jeton. Créez le fichier config.py et écrivez-y deux lignes:

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

J'ai décidé d'implémenter trois fonctions dans le bot:

Obtenir la température
Prendre des instantanés
Gestion des fenêtres

Avec le premier, tout est simple, sur demande nous lisons le fichier de température, et l'envoyons à l'utilisateur.

Avec des photos plus difficiles. J'utilise l'utilitaire Motion. Dans ses paramètres, demandez à mettre des images dans un dossier en RAM, eh bien, disons toutes les 30 secondes. Et nous créons des fichiers avec des noms identiques, et ils se remplacent simplement les uns les autres. Et puis, sur demande, nous envoyons le fichier à l'utilisateur.

Eh bien, le troisième module, le plus complexe: la gestion des fenêtres. Ma tâche principale: pour que l'automatisation fonctionne, mais si nécessaire, nous pouvons la désactiver. Je l'ai fait comme ça. Créé un autre fichier dans la RAM. Lorsque nous envoyons une demande pour ouvrir / fermer, ouvrir légèrement, fermer la fenêtre ou activer / désactiver l'automatisation, le bot écrit le numéro de commande dans ce fichier. Toutes les cinq secondes, le programme de gestion des fenêtres lit ce fichier et s’il reconnaît la commande, l’exécute. Après exécution, il écrit dans le même fichier que tout s'est bien passé. Le bot relit le fichier et nous informe que la commande est terminée.

Eh bien, maintenant le code source. Tout d'abord, le même programme d'ouverture de fenêtres, refait uniquement pour un bot (temp.py):

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

Mais maintenant, parlons du bot lui-même. Comme je l'ai dit, j'utilise la bibliothèque PyTelegramBotApi. Si vous consultez la documentation sur GitHub , vous pouvez comprendre que le bot utilise des gestionnaires pour traiter les commandes. Le gestionnaire est un événement de notre programme qui définit une action. Dans notre cas, il s'agit d'une phrase spécifique dans le message. Et l'action est tout ce que nous pouvons faire en python. Dans ce cas, nous enverrons des informations à l'utilisateur ou nous écrirons des commandes pour Windows dans un fichier. Fondamentalement, notre programme se compose de ces mêmes gestionnaires et de la commande d'interrogation du serveur.

Mais j'ai également écrit et ajouté une autre chose intéressante: le bloc d'autorisation. Eh bien, comme son nom l'indique, il est fait pour protéger notre serre contre tout accès non autorisé. Cela fonctionne simplement. La première fois que vous vous connectez au bot, il nous demande un mot de passe. Si nous le saisissons correctement, le bot nous ajoute à la base de données et lors des prochaines connexions, nous n'avons plus besoin de nous connecter. Le bot nous reconnaît en utilisant chat-id. Nous stockons le chat-id du dernier utilisateur dans une variable afin de ne pas tirer la base de données tout le temps.

Créez maintenant le fichier daba.py et écrivez ceci:

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()

Aussi, faisons tout de suite quelques scripts d'aide. Créez un fichier newuser.sh et écrivez-y:

#!/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

Et créez deux scripts pour lancer le bot et le programme Windows:

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

Et encore un:

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

"Pourquoi faisons-nous cela?" demandez-vous. Et ici, le fait est que parfois en raison d'une connexion Internet instable ou d'une erreur sur le serveur Telegram, le programme peut se bloquer. Et le script le conduit dans un cycle éternel: il a volé - il a recommencé après 5 secondes. Et pour les fenêtres, je l'ai fait pour chaque pompier: soudain aussi, à cause d'un dysfonctionnement, le programme va planter, mais nous ne sommes pas dans la serre, nous reviendrons et nous aurons de la soupe de tomate ou de la glace à la tomate.

Eh bien et maintenant la chose la plus importante est le script du bot lui-même:

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()

N'oubliez pas d'indiquer ici l'ID du capteur, le chat-id et le chemin d'accès à la section en RAM. Maintenant, nous avons presque tout prêt. Nous téléchargeons ce vidage , remplissons la base de données sur notre serveur, et n'oubliez pas de monter la partition en RAM, je pense que 10 Mo suffisent au cou. Nous lançons deux de nos scripts de démarrage et nous nous réjouissons. Le mot de passe par défaut est telbot. Modifiez-le dans la table tkey de la base de données.

Information par SMS

Il en a été de même pour les SMS en cas de surchauffe. Créez le fichier 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)

Nous nous inscrivons sur sms.ru et y prenons la clé API dans la section pour les programmeurs. N'oubliez pas non plus d'indiquer votre numéro de téléphone dans le script.

Dans le programme de gestion des fenêtres, nous déclarons une variable:

Vr=0

Insérez ensuite ce code dans la boucle perpétuelle:

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')

Pour le moment, la température seuil est de 32, un SMS sera envoyé en cas de température élevée une fois par heure, jusqu'à ce qu'elle baisse.

PS prévoit pour l'avenir d'installer un chauffage contrôlé et d'arroser automatiquement.

Merci à tous ceux qui ont lu jusqu'au bout.

Serre intelligente dans Telegram

Information par SMS

More articles: