DHT22V5.py

#!/usr/bin/env python

import time
import atexit
import pigpio
import DHT22
import ipgetter
import socket
import paho.mqtt.publish as publish
import datetime
import subprocess
import pigpio

class sensor:
    """
    A class to read relative humidity and temperature from the
    DHT22 sensor.  The sensor is also known as the AM2302.

    The sensor can be powered from the Pi 3V3 or the Pi 5V rail.

    Powering from the 3V3 rail is simpler and safer.  You may need
    to power from 5V if the sensor is connected via a long cable.

    For 3V3 operation connect pin 1 to 3V3 and pin 4 to ground.

    Connect pin 2 to a gpio.

    For 5V operation connect pin 1 to 5V and pin 4 to ground.

    The following pin 2 connection works for me.  Use at YOUR OWN RISK.

    5V--5K_resistor--+--10K_resistor--Ground
                |
    DHT22 pin 2 -----+
                |
    gpio ------------+
    """

    def __init__(self, pi, gpio, power=None):
    """
    Instantiate with the Pi and gpio to which the DHT22 output
    pin is connected.

    Optionally a gpio used to power the sensor may be specified.
    This gpio will be set high to power the sensor.  If the sensor
    locks it will be power cycled to restart the readings.

    Taking readings more often than about once every two seconds will
    eventually cause the DHT22 to hang.  A 3 second interval seems OK.
    """

        self.pi = pi
        self.gpio = 4
        self.power = power

        if power is not None:
            pi.write(power, 1) # Switch sensor on.
            time.sleep(1)

        self.powered = True

        self.cb = None

        atexit.register(self.cancel)

        self.bad_CS = 0 # Bad checksum count.
        self.bad_SM = 0 # Short message count.
        self.bad_MM = 0 # Missing message count.
        self.bad_SR = 0 # Sensor reset count.

        # Power cycle if timeout > MAX_TIMEOUTS.
        self.no_response = 0
        self.MAX_NO_RESPONSE = 2

        self.rhum = -999
        self.temp = -999

        self.tov = None

        self.high_tick = 0
        self.bit = 40

        pi.set_pull_up_down(gpio, pigpio.PUD_OFF)

        pi.set_watchdog(gpio, 0) # Kill any watchdogs.

        self.cb = pi.callback(gpio, pigpio.EITHER_EDGE, self._cb)

    def _cb(self, gpio, level, tick):
    """
    Accumulate the 40 data bits.  Format into 5 bytes, humidity high,
    humidity low, temperature high, temperature low, checksum.
    """
        diff = pigpio.tickDiff(self.high_tick, tick)

        if level == 0:
         # Edge length determines if bit is 1 or 0.
            if diff >= 50:
                val = 1
            if diff >= 200: # Bad bit?
               self.CS = 256 # Force bad checksum.
        else:
            val = 0

        if self.bit >= 40: # Message complete.
            self.bit = 40

        elif self.bit >= 32: # In checksum byte.
            self.CS  = (self.CS<<1)  + val

        if self.bit == 39:
               # 40th bit received.

            self.pi.set_watchdog(self.gpio, 0)

            self.no_response = 0

            total = self.hH + self.hL + self.tH + self.tL

            if (total & 255) == self.CS: # Is checksum ok?
                self.rhum = ((self.hH<<8) + self.hL) * 0.1

                    if self.tH & 128: # Negative temperature.
                        mult = -0.1
                        self.tH = self.tH & 127
                    else:
                        mult = 0.1
                        
                self.temp = ((self.tH<<8) + self.tL) * mult
                self.tov = time.time()

            elif self.bit >=24: # in temp low byte
                self.tL = (self.tL<<1) + val

            elif self.bit >=16: # in temp high byte
                self.tH = (self.tH<<1) + val

            elif self.bit >= 8: # in humidity low byte
                self.hL = (self.hL<<1) + val

            elif self.bit >= 0: # in humidity high byte
                self.hH = (self.hH<<1) + val

            else:               # header bits
                pass

        self.bit += 1

        elif level == 1:
            self.high_tick = tick
        if diff > 250000:
            self.bit = -2
            self.hH = 0
            self.hL = 0
            self.tH = 0
            self.tL = 0
            self.CS = 0

        else: # level == pigpio.TIMEOUT:
            self.pi.set_watchdog(self.gpio, 0)
        if self.bit < 8:       # Too few data bits received.
            self.bad_MM += 1    # Bump missing message count.
            self.no_response += 1
            if self.no_response > self.MAX_NO_RESPONSE:
               self.no_response = 0
               self.bad_SR += 1 # Bump sensor reset count.
               if self.power is not None:
                  self.powered = False
                  self.pi.write(self.power, 0)
                  time.sleep(2)
                  self.pi.write(self.power, 1)
                  time.sleep(2)
                  self.powered = True
         elif self.bit < 39:    # Short message receieved.
            self.bad_SM += 1    # Bump short message count.
            self.no_response = 0

         else:                  # Full message received.
            self.no_response = 0

    def temperature(self):
    """Return current temperature."""
        return self.temp

    def humidity(self):
    """Return current relative humidity."""
        return self.rhum

    def sensor_resets(self):
    """Return count of power cycles because of sensor hangs."""
        return self.bad_SR

    def trigger(self):
    """Trigger a new relative humidity and temperature reading."""
        if self.powered:
            if self.LED is not None:
                self.pi.write(self.LED, 1)

                self.pi.write(self.gpio, pigpio.LOW)
                time.sleep(0.017) # 17 ms
                self.pi.set_mode(self.gpio, pigpio.INPUT)
                self.pi.set_watchdog(self.gpio, 200)

    def cancel(self):
    """Cancel the DHT22 sensor."""

        self.pi.set_watchdog(self.gpio, 0)

        if self.cb != None:
            self.cb.cancel()
            self.cb = None

   
    '''
    publishing a single (encrypted) message to the broker.
    '''
    def pubIp():
    encPayload = encryptMessage(getAddress())
    publish.single("babykeeper/Rasp_Ip",encPayload, hostname="broker.mqttdashboard.com")

    '''
    getting my local and global ip address.
    '''
    def getAddress():
           
        # global ip address of device
        globalIp = ipgetter.myip()

        # local ip address of device
        localIp = socket.gethostbyname(socket.gethostname())

        output = 'Global_IP:'+globalIp+'//'+'Local_Ip:'+localIp
        return output

    '''
    encrypting a message by Cesar Cipher method with a uniqe key.
    '''
    def encryptMessage(message):
        
        now = datetime.datetime.now()
        day = now.day
       message = message
       key = day
       letters = "8&YC9ZvMaxP@wOz|%*sf3QN0G/cp+U5$>gDorLmhE1l#eJ,*yWbdB_2KV(n=i?HSuX^{TI4;jq}'FA[:).t!<kR]67"
       letterslen = len(letters)
       translated = ""
       for m in message:
               if m in letters:
                       myval = letters.find(m)
                       myval = myval+key
               
                       if myval >= letterslen:
                               myval = myval-letterslen
                       elif myval < 0:
                               myval = myval+letterslen
                       translated +=  letters[myval]
               else:
                       translated +=  m	
       return translated

    '''
    publish a temperature reading if it is changed. (first reading is 0)
    '''
    def pubChangedTemperature():
      if s.temperature() != currTemperature :
          publish.single("babykeeper/temperature",s.temperature(),0,False,
                     hostname="broker.mqttdashboard.com", port=1883)
          currTemperature=s.temperature()
          
    '''
    publish a humidity reading if it is changed. (first reading is 0)
    '''
    def pubChangedHumidity():
      if s.humidity() != currHumidity :
          publish.single("babykeeper/humidity",s.humidity(),0,False,
                     hostname="broker.mqttdashboard.com", port=1883)
          currHumidity = s.humidity()

        
    def Main():

        currTemperature=0
        currHumidity=0

        #os.system("sudo pigpio")

        #subprocess.call(['sudo','pigpiod'],shell=True)

        # Intervals of about 2 seconds or less will eventually hang the DHT22.
        #INTERVAL=3

        pi = pigpio.pi()

        s = DHT22.sensor(pi, 4)
        
        pubIp()
        curr=getAddress()

        while True:

            s.trigger()

            time.sleep(0.2)

            '''
            print("{} {} {}".format(
             r, s.humidity(), s.temperature()))
            '''

            if curr != getAddress():
                pub()
                curr=getAddress()

            pubChangedTemperature()
            pubChangedHumidity()

            time.sleep(1) # Overall INTERVAL second polling.

        s.cancel()

        pi.stop()


if __name__ == "__main__":
    Main()