Exemplo n.º 1
0
class MoistureMonitor():
    def __init__(self, led=None):
        self.led = led
        self.t = machine.Timer(0)
        self.a = machine.ADC(0)

        gc.collect()
        loops = 0
        self.m = MQTTClient(config.mqtt.id, config.mqtt.host, **config.mqtt["auth"])
        while True:
            try:
                self.m.connect()
            except (IndexError, OSError) as err:
                print("Retrying connect because of a {}...".format(str(err)))
                if loops > 10:
                    print("Resetting the board")
                    machine.reset()
            except MemoryError:
                print("Got a memory error. Resetting the board in 2 seconds")
                time.sleep(2)
                machine.reset()
            except:
                raise
            else:
                break
            loops += 1
            time.sleep(1)

    def start(self):
        self.m.publish(b'nodes', 'hi there')
        self.t.init(period=5000, mode=machine.Timer.PERIODIC, callback=lambda t: self.update())

    def stop(self):
        self.t.deinit()

    def update(self):
        now = time.localtime()
        tstamp = "{:04d}-{:02d}-{:02d} {:02d}:{:02d}:{:02d}".format(*now[0:6])

        val = { "m": self.a.read() / 1024, "t": tstamp }
        print("Updating moisture, new value is {}".format(val))

        self.m.publish(b"moisture", json.dumps(val).encode('utf-8'), retain=True)

        if self.led is not None:
            self.led(0)
            time.sleep(0.1)
            self.led(1)
Exemplo n.º 2
0
# publish free heap statistics to Adafruit IO using MQTT
# subscribe to the same feed
#
# format of feed name:  
#   "ADAFRUIT_USERNAME/feeds/ADAFRUIT_IO_FEEDNAME"
mqtt_feedname = bytes('{:s}/feeds/{:s}'.format(ADAFRUIT_USERNAME, ADAFRUIT_IO_FEEDNAME), 'utf-8')
client.set_callback(cb)      
client.subscribe(mqtt_feedname)  
PUBLISH_PERIOD_IN_SEC = 10 
SUBSCRIBE_CHECK_PERIOD_IN_SEC = 0.5 
accum_time = 0
while True:
    try:
        # Publish
        if accum_time >= PUBLISH_PERIOD_IN_SEC:
            free_heap_in_bytes = gc.mem_free()
            print('Publish:  freeHeap = {}'.format(free_heap_in_bytes))
            client.publish(mqtt_feedname,    
                           bytes(str(free_heap_in_bytes), 'utf-8'), 
                           qos=0) 
            accum_time = 0                
        
        # Subscribe.  Non-blocking check for a new message.  
        client.check_msg()

        time.sleep(SUBSCRIBE_CHECK_PERIOD_IN_SEC)
        accum_time += SUBSCRIBE_CHECK_PERIOD_IN_SEC
    except KeyboardInterrupt:
        print('Ctrl-C pressed...exiting')
        client.disconnect()
        sys.exit()
Exemplo n.º 3
0
from umqtt.robust import MQTTClient
Exemplo n.º 4
0
class MQTTHandler:
    def __init__(self, name, server):
        self.mqtt = MQTTClient(hexlify(machine.unique_id()), server)
        self.name = name
        self.actions = {}
        self.publishers = {}
        self.connect()
        self.mqtt.set_callback(self.handle_mqtt_msgs)
        self.publish_all_after_msg = True

    def connect(self):
        print('.connect() Check if MQTT is already connected')
        if self.isconnected():
            self.mqtt.disconnect()
        try:
            print('.connect() Not connected, so lets connect')
            self.mqtt.connect()
        except OSError:
            print(".connect() MQTT could not connect")
            return False

        time.sleep(3)
        if self.isconnected():
            self.resubscribe_all()
            return True
        else:
            # Some delay to avoid system getting blocked in a endless loop in case of
            # connection problems, unstable wifi etc.
            time.sleep(5)
            return False

    def isconnected(self):
        try:
            self.mqtt.ping()
        except OSError:
            print(".isconnected() MQTT not connected - Ping not successfull")
            return False
        except AttributeError:
            print(".isconnected() MQTT not connected - Ping not available")
            return False

        return True

    def publish_generic(self, name, value):
        print(".publish_generic() Publish: {0} = {1}".format(name, value))
        self.mqtt.publish(name, str(value))

    def handle_mqtt_msgs(self, topic, msg):
        print(".handle_mqtt_msgs() Received MQTT message: {0}:{1}".format(
            topic, msg))
        if topic in self.actions:
            print(".handle_mqtt_msgs() Found registered function {0}".format(
                self.actions[topic]))
            self.actions[topic](msg)
            if self.publish_all_after_msg:
                self.publish_all()

    def register_action(self, topicname, cbfunction):
        topic = self.name + b'/' + bytes(topicname, 'ascii')
        print(".register_action() Get topic {0} for {1}".format(
            topic, cbfunction))
        if self.isconnected():
            print('.register_action() MQTT connected, try to register')
            self.mqtt.subscribe(topic)
        self.actions[topic] = cbfunction

    def register_publisher(self, topicname, function):
        topic = self.name + b'/' + bytes(topicname, 'ascii')
        print(".register_publisher() Get topic {0} for {1}".format(
            topic, function))
        self.publishers[topic] = function

    def publish_all(self):
        for topic in self.publishers:
            self.publish_generic(topic, self.publishers[topic]())

    def resubscribe_all(self):
        for topic in self.actions:
            self.mqtt.subscribe(topic)
Exemplo n.º 5
0
class SonOff():
    led = Pin(13, Pin.OUT, value=1)
    relay = Pin(12, Pin.OUT, value = 0)
    button = Pin(0, Pin.IN, Pin.PULL_UP)
    device_status = "OFF"

    def __init__(self):
        if config.POWER_ON_STATE:
            self.relay_control(1)
            self.led_control(0)
            self.device_status = "ON"
        self.mqtt_client = MQTTClient(client_id=config.DEVICE_NAME, server=config.MQTT_SERVER,
                        port=config.MQTT_PORT, user=config.MQTT_USER, passwd=config.MQTT_PASSWD,
                        keepalive=60)
        self.mqtt_client.set_callback(self.sub_callback)
        self.mqtt_client.set_last_will(config.AVAILABILITY_TOPIC, "offline")
        self.ping_mqtt = 0
        self.ping_fail = 0
        self.button_interrupt = 0

    def relay_control(self, value):
        self.relay.value(value)
        return self.relay.value()

    def led_control(self, value):
        self.led.value(value)
        return self.led.value()

    def mqtt_connect(self):
        try:
            self.mqtt_client.connect()
            for topic in [config.SET_TOPIC, config.POS_SET_TOPIC, config.MQTT_CHECK]:
                self.mqtt_client.subscribe(topic)
            self.publish_device_status()
            self.publish_pos_status("ON" if config.POWER_ON_STATE else "OFF")
            self.mqtt_client.publish(config.AVAILABILITY_TOPIC, "online")
        except:
            self.ping_fail += 1

    def sub_callback(self, topic, msg):
        topic = topic.decode('utf-8')
        msg = msg.decode('utf-8')
        if topic == config.SET_TOPIC:
            if msg == "ON":
                self.relay_control(1)
                self.led_control(0)
                self.device_status = "ON"
            else:
                self.relay_control(0)
                self.led_control(1)
                self.device_status = "OFF"
            self.publish_device_status()
        elif topic == config.POS_SET_TOPIC:
            if msg == "ON":
                self.change_config({"POWER_ON_STATE": 1})
            else:
                self.change_config({"POWER_ON_STATE": 0})
            self.publish_pos_status(msg)
        elif topic == config.MQTT_CHECK:
            if int(msg) == self.ping_mqtt:
                self.ping_fail = 0

    def publish_device_status(self):
        if self.ping_fail == 0:
            self.mqtt_client.publish(config.STATE_TOPIC, self.device_status)

    def publish_pos_status(self, value):
        if self.ping_fail == 0:
            self.mqtt_client.publish(config.POS_STATE_TOPIC, value)

    def button_action(self, pin):
        self.button_interrupt = 1

    def change_config(self, config_data):
        with open('config.py', 'r') as rf:
            config_list = rf.readlines()
        for config_name, config_value in config_data.items():
            if config_name in config_map:
                if isinstance(config_value, int):
                    config_list[config_map[config_name]] = "{} = {}\n".format(config_name, config_value)
                elif config_value.isdigit():
                    config_list[config_map[config_name]] = "{} = {}\n".format(config_name, int(config_value))
                else:
                    config_list[config_map[config_name]] = '{} = "{}"\n'.format(config_name, config_value)
        with open('config.py', 'w') as wf:
            for conf in config_list:
                wf.write(conf)

    async def check_message(self):
        while True:
            await asyncio.sleep(0.2)
            try:
                self.mqtt_client.check_msg()
            except:
                self.mqtt_connect()

    async def check_mqtt(self):
        while True:
            await asyncio.sleep(10)
            self.ping_mqtt = time.time()
            self.mqtt_client.publish(config.MQTT_CHECK, str(self.ping_mqtt))
            self.ping_fail += 1

            if self.ping_fail > 10:
                pass
            if self.ping_fail > 3:
                self.mqtt_client.disconnect()
                self.mqtt_connect()

    async def check_button(self):
        while True:
            await asyncio.sleep(0.4)
            if self.button_interrupt > 0:
                self.button_interrupt = 0
                if self.device_status == "ON":
                    self.relay_control(0)
                    self.led_control(1)
                    self.device_status = "OFF"
                else:
                    self.relay_control(1)
                    self.led_control(0)
                    self.device_status = "ON"
                self.publish_device_status()

    def run(self):
        self.button.irq(trigger=Pin.IRQ_FALLING, handler=self.button_action)
        self.mqtt_connect()
        loop = asyncio.get_event_loop()
        loop.create_task(self.check_message())
        loop.create_task(self.check_mqtt())
        loop.create_task(self.check_button())
        try:
            loop.run_forever()
        except:
            pass
                    server=ADAFRUIT_IO_URL,
                    user=ADAFRUIT_USERNAME,
                    password=ADAFRUIT_IO_KEY,
                    ssl=False)

try:
    client.connect()
except Exception as e:
    print('could not connect to MQTT server {}{}'.format(type(e).__name__, e))
    sys.exit()

mqtt_feedname = bytes(
    '{:s}/feeds/{:s}'.format(ADAFRUIT_USERNAME, ADAFRUIT_IO_FEEDNAME), 'utf-8')
client.set_callback(cb)
client.subscribe(mqtt_feedname)

# following two lines is an Adafruit-specific implementation of the Publish "retain" feature
# which allows a Subscription to immediately receive the last Published value for a feed,
# even if that value was Published two hours ago.
# Described in the Adafruit IO blog, April 22, 2018:  https://io.adafruit.com/blog/
mqtt_feedname_get = bytes('{:s}/get'.format(mqtt_feedname), 'utf-8')
client.publish(mqtt_feedname_get, '\0')

# wait until data has been Published to the Adafruit IO feed
while True:
    try:
        client.wait_msg()
    except KeyboardInterrupt:
        print('Ctrl-C pressed...exiting')
        client.disconnect()
        sys.exit()
Exemplo n.º 7
0
def broker_connect(t_pub, tc_water):
    # create a random MQTT clientID
    random_num = int.from_bytes(os.urandom(3), 'little')
    mqtt_client_id = bytes('client_' + str(random_num), 'utf-8')

    # connect to Adafruit IO MQTT broker using unsecure TCP (port 1883)
    #
    # To use a secure connection (encrypted) with TLS:
    #   set MQTTClient initializer parameter to "ssl=True"
    #   Caveat: a secure connection uses about 9k bytes of the heap
    #         (about 1/4 of the micropython heap on the ESP8266 platform)
    ADAFRUIT_IO_URL = b'io.adafruit.com'
    ADAFRUIT_USERNAME = b'stormin'
    ADAFRUIT_IO_KEY = b'4a8287af16f346d6be64bb6be020d3e3'
    ADAIO_PubFD_1 = b'GC_FreeMemory'
    ADAIO_PubFD_2 = b'Water Temp Deg C'
    ADAIO_PubFD_3 = b'Outdoor Temp Deg C'
    ADAIO_PubFD_4 = b'Outdoor Relative Humidity'
    ADAIO_SubFD_1 = b'blue-led-control'

    client = MQTTClient(client_id=mqtt_client_id,
                        server=ADAFRUIT_IO_URL,
                        user=ADAFRUIT_USERNAME,
                        password=ADAFRUIT_IO_KEY,
                        ssl=False)

    try:
        client.connect()
    except Exception as e:
        print('Could not connect to MQTT server {}{}'.format(
            type(e).__name__, e))
        print('Going to Deep Sleep mode')
        prph.deepsleep(60)
        sys.exit()

    # publish free heap statistics to Adafruit IO using MQTT
    # subscribe to the same feed
    #
    # format of feed name:
    #   "ADAFRUIT_USERNAME/feeds/ADAFRUIT_IO_FEEDNAME"
    mqtt_PubFD1 = bytes(
        '{:s}/feeds/{:s}'.format(ADAFRUIT_USERNAME, ADAIO_PubFD_1), 'utf-8')
    mqtt_PubFD2 = bytes(
        '{:s}/feeds/{:s}'.format(ADAFRUIT_USERNAME, ADAIO_PubFD_2), 'utf-8')
    mqtt_PubFD3 = bytes(
        '{:s}/feeds/{:s}'.format(ADAFRUIT_USERNAME, ADAIO_PubFD_3), 'utf-8')
    mqtt_PubFD4 = bytes(
        '{:s}/feeds/{:s}'.format(ADAFRUIT_USERNAME, ADAIO_PubFD_4), 'utf-8')
    mqtt_SubFD1 = bytes(
        '{:s}/feeds/{:s}'.format(ADAFRUIT_USERNAME, ADAIO_SubFD_1), 'utf-8')
    client.set_callback(cb)
    client.subscribe(mqtt_SubFD1)
    PUBLISH_PERIOD_IN_SEC = t_pub
    SUBSCRIBE_CHECK_PERIOD_IN_SEC = 0.5
    accum_time = 0
    while True:
        try:
            # Publish
            if accum_time >= PUBLISH_PERIOD_IN_SEC:
                # Publish free heap memory from GC (Garbage Collection)
                free_heap_in_bytes = gc.mem_free() / 1000
                print('Publish:  GC FreeMem = {} k'.format(free_heap_in_bytes))
                client.publish(mqtt_PubFD1,
                               bytes(str(free_heap_in_bytes), 'utf-8'),
                               qos=0)
                # Publish water temperature in C or F
                # tc, tf = prph.tmp36()
                print('Publish:  Water Temp = {} c'.format(tc_water))
                client.publish(mqtt_PubFD2,
                               bytes(str(tc_water), 'utf-8'),
                               qos=0)
                # Publish outdoor temperature in C
                t2320, h2320 = prph.am2320(4)
                print('Publish:  Outdoor Temp = {} c'.format(t2320))
                client.publish(mqtt_PubFD3, bytes(str(t2320), 'utf-8'), qos=0)
                # Publish outdoor humidity in %
                print('Publish:  Outdoor Humidity = {} %'.format(h2320))
                client.publish(mqtt_PubFD4, bytes(str(h2320), 'utf-8'), qos=0)
                accum_time = 0

            # Subscribe.  Non-blocking check for a new message.
            client.check_msg()

            time.sleep(SUBSCRIBE_CHECK_PERIOD_IN_SEC)
            accum_time += SUBSCRIBE_CHECK_PERIOD_IN_SEC
            # print('Accumulated Time = {}'.format(accum_time))
        except KeyboardInterrupt:
            print('Ctrl-C pressed...exiting')
            client.disconnect()
            sys.exit()
Exemplo n.º 8
0
            msg = rakp2p.recv()
            utime.sleep_ms(80)
            # message not OK
            if msg == "NOK":
                continue
            # delete message prefix (msg=)
            msg = msg[4:]
            if DEBUG:
                print(msg)
            # convert json string to object
            js = ujson.loads(msg)
            # example message :
            # {"id":"000","DHT11_humidity":"46.8","DHT11_temperature":"23.0","bat":"5.661562","datasetId":"254"}
            # one of the 6 nodes contains new data
            if js["datasetId"] != prev[js["id"]]:
                mqtt_cl.publish(js["id"] + "/temp", js["DHT11_temperature"])
                utime.sleep_ms(50)
                mqtt_cl.publish(js["id"] + "/hum", js["DHT11_humidity"])
                utime.sleep_ms(50)
                # save datasetId in dictionary
                prev[js["id"]] = js["datasetId"]
                if DEBUG:
                    print(prev)

        except Exception as E:
            print("Problem with message - %s" % E)
            if DEBUG:
                print(msg)

finally:
    rakp2p.stop()
Exemplo n.º 9
0
from umqtt.robust import MQTTClient
import time
import network
from sht30 import SHT30

client_id = "wemos"
server = "pi.lan"
port = 1883
user = "******"
password = "******"
topic = "{}/{}".format(client_id, "sensor")
sensor = SHT30()
# Connect to ADC pin (A0)
adc = ADC(0)

# Wait for network up before proceeding
wlan = network.WLAN(network.STA_IF)
while not wlan.isconnected():
    time.sleep_ms(10)

client = MQTTClient(client_id, server, port=port, user=user, password=password)
client.connect(clean_session=False)

temp, humidity = sensor.measure()
client.publish("{}/{}".format(topic, "temperature"), str(temp), qos=1)
client.publish("{}/{}".format(topic, "humidity"), str(humidity), qos=1)
client.publish("{}/{}".format(topic, "moisture"), str(adc.read()), qos=0)

# Uncomment this if wrapped by timeout.py
#deepsleep()
Exemplo n.º 10
0
        np.fill((0, 0, 0))
        np[i] = (led_colour)
        np.write()
        # Bei der vorletzten LED lassen wir die Temperatur 'vorbereiten'
        if i == 23:
            # Konvertiere die Temperatur!
            ds.convert_temp()
        else:
            # ansonsten warte 50 Milisekunden, wegen der Animation
            time.sleep_ms(20)
        # hier schauen wir nach, ob es eine neue LED Farbe für uns gibt
        c.check_msg()
    # für alle Temperatursensoren, sende Daten zum MQTT Broker
    print("Count:", j, end=' ')
    j = j + 1
    for rom in roms:
        TEMP = str(ds.read_temp(rom))
        print("Temperature: ", TEMP, "°C ")
        c.publish(ARBEITSPLATZ + "/temperatur", TEMP)

#Snippet10####
# Programmende
##############
c.disconnect()
print("Disconnected!")
sys.exit()

###################################
# END                             #
###################################
Exemplo n.º 11
0
# Main Function
do_connect()
ca = CryptAes()

client = MQTTClient(client_id=client_id,
                    server=mqtt_server,
                    port=port,
                    user=username,
                    password=password)
client.set_callback(sub_cb)
client.connect()
client.subscribe(b'Sensor_Data')
print("Connected to MQTT Broker")

#hard_timer1.init(period=1000, mode=machine.Timer.PERIODIC, callback=hard_handleInterrupt1)
client.publish(b'SessionID', ca.sessionID)
print("published message")
ticks_1 = utime.ticks_ms()

while True:
    new_message = client.check_msg()
    time.sleep_us(1000)
    if mail_flag == 1:
        mail_flag = 0
        result = ca.verify_hmac(json_message)
        ticks_2 = utime.ticks_ms()
        print(utime.ticks_diff(ticks_2, ticks_1))

        if result:
            client.publish(b'Acknowledge', b'Successful Decryption')
            print("Authentication Passed. Decrypting")
Exemplo n.º 12
0
 def Emit(self):
     emi = MQTTClient('emiter', "192.168.110.51")
     emi.connect()
     emi.publish("test/msg", "from nodeMCU !")
     emi.disconnect()
Exemplo n.º 13
0
from umqtt.robust import MQTTClient
import time
import network

#conexion a la red wifi
sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)
sta_if.connect("SSID", "PASS")
time.sleep(2)

ubidotsToken = "TOKEN"
clientID = "CLIENTID"
topic = b"/v1.6/devices/{devicelabel}"  #el topic define a que device en especifico es que se va a subir datos
#b"/v1.6/devices/{NOMBRE_DISPOSITIVO}" en el que NOMBRE_DISPOSITIVO es quien
#define entre los devices creados al cual se quiere subir el dato

client = MQTTClient(clientID,
                    "industrial.api.ubidots.com",
                    1883,
                    user=ubidotsToken,
                    password=ubidotsToken)  #creacion de objeto
client.connect()  #conexion a ubidots

while True:
    time.sleep(2)
    msg = '20|30|200'
    R, G, B = msg.split('|')
    msg = b'{"R":%s, "G":%s, "B":%s}' % (int(R), int(G), int(B))
    print(msg)
    client.publish(topic, msg)
Exemplo n.º 14
0
def send_state():
    client = MQTTClient('state', SERVER)
    client.connect()
    client.set_callback(on_message)
    client.publish(state, '2')
Exemplo n.º 15
0
class MQTT:
    def __init__(self, ssid, pswd):
        self.WIFI_SSID = ssid
        self.WIFI_PSWD = pswd

        self.subLoopRunning = False

        # create a random MQTT clientID
        random_num = int.from_bytes(os.urandom(3), 'little')
        self.mqtt_client_id = bytes('client_' + str(random_num), 'utf-8')
        #email = [email protected] password db4password
        self.ADAFRUIT_IO_URL = b'io.adafruit.com'
        self.ADAFRUIT_USERNAME = b'db4g5'
        self.ADAFRUIT_IO_KEY = Key()

        self.connect()

    def __del__(self):
        self.subLoopRunning = False

    def connect(self):
        # turn off the WiFi Access Point
        ap_if = network.WLAN(network.AP_IF)
        ap_if.active(False)

        # connect the device to the WiFi network
        wifi = network.WLAN(network.STA_IF)
        wifi.active(True)
        wifi.connect(self.WIFI_SSID, self.WIFI_PSWD)

        attempt_count = 0
        while not wifi.isconnected() and attempt_count < 20:
            attempt_count += 1
            time.sleep(1)

        if attempt_count == 20:
            print('could not connect to the WiFi network')
            sys.exit()

        self.client = MQTTClient(client_id=self.mqtt_client_id,
                                 server=self.ADAFRUIT_IO_URL,
                                 user=self.ADAFRUIT_USERNAME,
                                 password=self.ADAFRUIT_IO_KEY,
                                 ssl=False)

        try:
            self.client.connect()
        except Exception as e:
            print('could not connect to MQTT server {}{}'.format(
                type(e).__name__, e))
            sys.exit()

    # used to publish new data to a certain topic
    def publish(self, topic, value):
        mqtt_feedname = bytes(
            '{:s}/feeds/{:s}'.format(self.ADAFRUIT_USERNAME, topic), 'utf-8')
        try:
            self.client.publish(mqtt_feedname,
                                bytes(str(value), 'utf-8'),
                                qos=0)
        except Exception:
            self.connect()

    # used to poll client subscriptions
    def __sub_loop(self):
        while self.subLoopRunning:
            try:
                self.client.check_msg()
                time.sleep(2)
            except Exception:
                self.connect()

    # run only once with custom function func(topic, msg)
    def setCallback(self, cb):
        self.client.set_callback(cb)

    # add a subscription
    def subscribe(self, topic):
        mqtt_feedname = bytes(
            '{:s}/feeds/{:s}'.format(self.ADAFRUIT_USERNAME, topic), 'utf-8')
        self.client.subscribe(mqtt_feedname)
        if self.subLoopRunning == False:
            self.subLoopRunning = True
            _thread.start_new_thread(self.__sub_loop, ())
Exemplo n.º 16
0
        leds[0].value(1)
        leds[1].value(0)
        leds[2].value(0)
        if t > TEMP_ALARM:
            m = 'Temp alarm'
            leds[0].value(0)
            leds[1].value(0)
            leds[2].value(1)
        elif t > TEMP_WARNING:
            m = 'Temp warning'
            leds[0].value(0)
            leds[1].value(1)
            leds[2].value(0)
        # waarden tonen in console
        print("Temperature {0:2}C - Humidity  {1:2}% - {2} ".format(t,h,m))
        # waarden publishen naar mqtt server
        mqtt_cl.publish(TOPIC_TEMP, str(t))
        mqtt_cl.publish(TOPIC_HUM, str(h))
        mqtt_cl.publish(TOPIC_TEMP_MESSAGE, m)
        # 5 seconden wachten
        time.sleep(5)

except Exception as e:
    print('Problemen met MQTT - %s'%e)
    
finally:
    if mqtt_cl != None:
        mqtt_cl.disconnect()
    myWifi.close()
  
Exemplo n.º 17
0
        temperature, pressure, humidity = bme.values
        temperature = temperature.replace("C", "")
        pressure = pressure.replace("hPa", "")
        humidity = humidity.replace("%", "")
        print("Temperature, pressure, humidity:", temperature, pressure, humidity)
    except Exception as e:
        print("BME280 reading failed with: {}".format(e))

    try:
        illuminance = str(round(max44009.illuminance_lux, 2))
        print("Illuminance:", illuminance)
    except Exception as e:
        print("MAX44009 reading failed with: {}".format(e))

    try:
        mqtt_client.publish(config.TOPIC_TEMPERATURE, temperature)
        mqtt_client.publish(config.TOPIC_PRESSURE, pressure)
        mqtt_client.publish(config.TOPIC_HUMIDITY, humidity)
        mqtt_client.publish(config.TOPIC_ILLUMINANCE, illuminance)
    except Exception as e:
        print("Transferring data failed with: {}".format(e))

    mqtt_client.disconnect()

    # Temperature displayed in orange. Set here before erasing the measurements area
    screen.set_color(ili934.color565(255, 165, 0), ili934.color565(255, 255, 255))

    # Fill a rectangle only on the measurements area. This is equivalent to
    # screen.erase(), but we only erase the measurements area of the screen.
    screen.fill_rectangle(90, 0, config.SCREEN_H - 90, config.SCREEN_W)
Exemplo n.º 18
0
#client.subscribe(mqtt_feedname_02)
client.subscribe(mqtt_feedname_03)
  
PUBLISH_PERIOD_IN_SEC = 3 
SUBSCRIBE_CHECK_PERIOD_IN_SEC = 0.5 
accum_time = 0

while True:
    
    try:
        # Publish
        if accum_time >= PUBLISH_PERIOD_IN_SEC:
            free_heap_in_bytes = gc.mem_free()
            print('Publish:  rawPot = {}'.format(adc.read()))
            client.publish(mqtt_feedname_02,    
                           bytes(str(adc.read()), 'utf-8'), 
                           qos=0)
			#client.publish(mqtt_feedname_03, f(y))    
            #               bytes(str(free_heap_in_bytes), 'utf-8'), 
            #               qos=0)
            accum_time = 0                
        

        # Subscribe.  Non-blocking check for a new message.  
        client.check_msg()

        time.sleep(SUBSCRIBE_CHECK_PERIOD_IN_SEC)
        accum_time += SUBSCRIBE_CHECK_PERIOD_IN_SEC
    
    except KeyboardInterrupt:
        print('Ctrl-C pressed...exiting')
from umqtt.robust import MQTTClient
import time

t = 30
h = 40

myMqttClient = bytes("client_" + str(10), 'utf-8')

THINGSPEAK_URL = b"mqtt.thingspeak.com"
THINGSPEAK_USER_ID = b'user id '
THINGSPEAK_MQTT_API_KEY = b'mqtt apk'
client = MQTTClient(client_id=myMqttClient,
                    server=THINGSPEAK_URL,
                    user=THINGSPEAK_USER_ID,
                    password=THINGSPEAK_MQTT_API_KEY,
                    ssl=False)

client.connect()

THINGSPEAK_CHANNEL_ID = 'channel id'
THINGSPEAK_CHANNEL_WRITE_API_KEY = 'write api key'

while True:

    topic = bytes(("channels/" + THINGSPEAK_CHANNEL_ID + "/publish/" +
                   THINGSPEAK_CHANNEL_WRITE_API_KEY), 'utf-8')
    payload = bytes("field1=" + str(t) + "&field2=" + str(h), 'utf-8')
    client.publish(topic, payload)
    print(topic, payload)
    time.sleep(10)
Exemplo n.º 20
0
class domoticz_mqtt_protocol:
    processcnt = 1

    def __init__(self):
        self._log = core._log
        self._log.debug("Protocol: domoticz mqtt contruction")
        self._lock = Event()
        # release lock, ready for next loop
        self._lock.clear()

    def init(self, protocol):
        self._log.debug("Protocol " + name + ": Init")
        self._client_id = protocol['client_id']
        self._server = protocol['hostname']
        self._port = protocol['port']
        self._user = protocol['user']
        self._password = protocol['password']
        self._queue_out = protocol['publish']
        self._queue_in = protocol['subscribe']
        self._mq = MQTTClient(self._client_id, self._server, self._port,
                              self._user, self._password)
        # Print diagnostic messages when retries/reconnects happens
        #self._mq.DEBUG = True
        self._queue = queues.Queue(maxsize=100)
        return self._queue

    def connect(self):
        self._log.debug("Protocol " + name + ": connect")
        return self._mq.reconnect()

    def disconnect(self):
        self._log.debug("Protocol " + name + ": disconnect")
        self._mq.disconnect()

    def check(self):
        self._log.debug("Protocol " + name + ": check")
        self._mq.check_msg()

    def status(self):
        self._log.debug("Protocol " + name + ": status")
        self._mq.ping()

    def recieve(self):
        self._log.debug("Protocol " + name + ": recieve")
        self._mq.subscribe(self.queue_in)

    def send(self, devicedata):
        self._log.debug("Protocol " + name + ": send " + devicedata["stype"])
        # connect or reconnect to mqtt server
        self.connect()
        mqttdata = None
        # case
        while True:
            mqttdata = None

            # case SENSOR_TYPE_SINGLE
            if devicedata["stype"] == core.SENSOR_TYPE_SINGLE:
                self._log.debug("Protocol " + name + ": SENSOR_TYPE_SINGLE")
                # Get plugin values
                try:
                    devicedata['valueV1'] = self._queue.get_nowait()
                    devicedata['valueN1'] = self._queue.get_nowait()
                except Exception as e:
                    self._log.debug("Protocol " + name +
                                    " SENSOR_TYPE_SINGLE exception: " +
                                    repr(e))
                    break

                # Assemble mqtt message
                mqttdata = {}
                mqttdata["idx"] = devicedata["serverid"]
                mqttdata["nvalue"] = 0
                mqttdata["svalue"] = str(devicedata["valueV1"])
                message = ujson.dumps(mqttdata)
                break

            # case SENSOR_TYPE_LONG
            if devicedata["stype"] == core.SENSOR_TYPE_LONG:
                self._log.debug("Protocol " + name + ": SENSOR_TYPE_LONG")
                break

            # case SENSOR_TYPE_DUAL
            if devicedata["stype"] == core.SENSOR_TYPE_DUAL:
                self._log.debug("Protocol " + name + ": SENSOR_TYPE_DUAL")
                break

            # case SENSOR_TYPE_TEMP_HUM
            if devicedata["stype"] == core.SENSOR_TYPE_TEMP_HUM:
                self._log.debug("Protocol " + name + ": SENSOR_TYPE_TEMP_HUM")
                # Get plugin values
                try:
                    devicedata['valueV1'] = self._queue.get_nowait()
                    devicedata['valueN1'] = self._queue.get_nowait()
                    devicedata['valueV2'] = self._queue.get_nowait()
                    devicedata['valueN2'] = self._queue.get_nowait()
                except Exception as e:
                    self._log.debug("Protocol " + self._name +
                                    " SENSOR_TYPE_TEMP_HUM Exception: " +
                                    repr(e))
                    break
                # Assemble mqtt message
                mqttdata = {}
                mqttdata["idx"] = devicedata["serverid"]
                mqttdata["nvalue"] = 0
                mqttdata["svalue"] = str(devicedata["valueV1"]) + ";" + str(
                    devicedata["valueV2"]) + ";0"
                message = ujson.dumps(mqttdata)
                break

            # case SENSOR_TYPE_TEMP_BARO
            if devicedata["stype"] == core.SENSOR_TYPE_TEMP_BARO:
                self._log.debug("Protocol " + name + ": SENSOR_TYPE_TEMP_BARO")
                break

            # case SENSOR_TYPE_TEMP_HUM_BARO
            if devicedata["stype"] == core.SENSOR_TYPE_TEMP_HUM_BARO:
                self._log.debug("Protocol " + name +
                                ": SENSOR_TYPE_TEMP_HUM_BARO")
                # Get plugin values
                try:
                    devicedata['valueV1'] = self._queue.get_nowait()
                    devicedata['valueN1'] = self._queue.get_nowait()
                    devicedata['valueV2'] = self._queue.get_nowait()
                    devicedata['valueN2'] = self._queue.get_nowait()
                    devicedata['valueV3'] = self._queue.get_nowait()
                    devicedata['valueN3'] = self._queue.get_nowait()
                except Exception as e:
                    self._log.debug("Protocol " + self._name +
                                    " SENSOR_TYPE_TEMP_HUM_BARO Exception: " +
                                    repr(e))
                    break
                # Assemble mqtt message
                mqttdata = {}
                mqttdata["idx"] = devicedata["serverid"]
                mqttdata["nvalue"] = 0
                mqttdata["svalue"] = str(devicedata["valueV1"]) + ";" + str(
                    devicedata["valueV2"]) + ";0;" + str(
                        devicedata["valueV3"]) + ";0"
                message = ujson.dumps(mqttdata)
                break

            # case SENSOR_TYPE_SWITCH
            if devicedata["stype"] == core.SENSOR_TYPE_SWITCH:
                self._log.debug("Protocol " + name + ": SENSOR_TYPE_SWITCH")
                # Get plugin values
                try:
                    devicedata['valueV1'] = self._queue.get_nowait()
                    devicedata['valueN1'] = self._queue.get_nowait()
                except Exception as e:
                    self._log.debug("Protocol " + self._name +
                                    " SENSOR_TYPE_SWITCH Exception: " +
                                    repr(e))
                    break

                # Switches can have many values, domoticz only two: on or off
                switch_on = ['closed', 'press', 'double', 'long']
                switch_off = ['open', 'release']

                if devicedata["valueV1"] in switch_on:
                    devicedata["valueV1"] = 'On'
                elif devicedata["valueV1"] in switch_off:
                    devicedata["valueV1"] = 'Off'
                else:
                    break

                # Assemble mqtt message
                mqttdata = {}
                mqttdata["command"] = "switchlight"
                mqttdata["idx"] = devicedata["serverid"]
                mqttdata["switchcmd"] = devicedata["valueV1"]
                message = ujson.dumps(mqttdata)
                break

            # case SENSOR_TYPE_DIMMER
            if devicedata["stype"] == core.SENSOR_TYPE_DIMMER:
                self._log.debug("Protocol " + name + ": SENSOR_TYPE_DIMMER")
                break

            # case SENSOR_TYPE_WIND
            if devicedata["stype"] == core.SENSOR_TYPE_WIND:
                self._log.debug("Protocol " + name + ": SENSOR_TYPE_WIND")
                break

            # else UNKNOWN
            self._log.debug("Protocol " + name + ": Unknown sensor type!")
            break

        if mqttdata != None:
            self._log.debug("Protocol " + name + ": Message: " + message)
            self._mq.publish(self._queue_out, message)

    def process(self):
        # processing todo for protocol
        self._log.debug("Protocol " + name + " Processing...")
        devicedata = {}
        try:
            while True:
                message = self._queue.get_nowait()
                if message == core.QUEUE_MESSAGE_START:
                    break
            devicedata['stype'] = self._queue.get_nowait()
            devicedata['serverid'] = self._queue.get_nowait()
            devicedata['unitname'] = self._queue.get_nowait()
            devicedata['devicename'] = self._queue.get_nowait()
            self.send(devicedata)
        except Exception as e:
            self._log.debug("Protocol " + name + " process Exception: " +
                            repr(e))

        # release lock, ready for next processing
        self._lock.clear()
Exemplo n.º 21
0
    user=CHT_USERNAME,  # 帳戶名稱
    password=CHT_IO_KEY)  # 金鑰

client.connect()  # 連線至mqtt伺服器

sensor = dht.DHT11(Pin(5))
data = 0

while True:
    for i in range(5):
        try:
            sleep(5)
            sensor.measure()
            temp = sensor.temperature()
            data = data + temp
            print('.', end='')
        except OSError as e:
            print('Failed to read sensor.')

    data = data / 5
    print(data)
    payload = [{"id": "DHT11", "value": [str(data)]}]
    # 傳送資料到IoT平台
    client.publish(
        b'/iot/v1/device/25641843256/rawdata',
        str(payload).encode()  # 傳送的資料改為bytes物件
    )
    print("上傳完畢")

    data = 0
    time.sleep(5)  # 暫停60秒
Exemplo n.º 22
0
import network
from umqtt.robust import MQTTClient
import secrets

wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.connect(secrets.wifi_network, secrets.wifi_password)

while not wifi.isconnected():
    pass

# Define some identifying information for our sensor node
DEVICE_ID = 'sensor1'

# Connect to the MQTT broker
print("Connecting to Mqtt...")
mqtt_client = MQTTClient(client_id=DEVICE_ID,
                         server=secrets.mqtt_server,
                         user=secrets.mqtt_user,
                         password=secrets.mqtt_password,
                         ssl=False)
mqtt_client.connect()

mqtt_client.publish('sensors/hello', 'Hello MQTT!')
Exemplo n.º 23
0
# Define a namespace for all messages
MQTT_Topic_Status = 'JorgePe/Status'
MQTT_Topic_Motor = 'JorgePe/Motor'


# callback message to process any new message appearing at the subscribed
# topics
def getmessages(topic, msg):
    if topic == MQTT_Topic_Status.encode():
        brick.display.text(str(msg.decode()))
    elif topic == MQTT_Topic_Motor.encode():
        brick.display.text(str(msg.decode()))
        motor.run_target(180, int(msg.decode()))


motor.reset_angle(0)

client = MQTTClient(MQTT_ClientID, MQTT_Broker)
client.connect()

client.publish(MQTT_Topic_Status, MQTT_ClientID + ' Started')
client.set_callback(getmessages)
client.subscribe(MQTT_Topic_Status)
client.subscribe(MQTT_Topic_Motor)
client.publish(MQTT_Topic_Status, MQTT_ClientID + ' Listening')

while True:
    client.check_msg()
    time.sleep(0.1)
Exemplo n.º 24
0
class CatFeeder(object):
    def __init__(self):
        """"""
        self._client = None
        self._button = Pin(5, mode=Pin.IN, pull=Pin.PULL_UP)
        self._done_payload = 'Done feeding!'

        self._servo_buzz = Feeder(
            pin_servo=0,
            trigger=14,
            echo=2,
        )

        self._servo_tuxedo = Feeder(
            pin_servo=4,
            trigger=12,
            echo=13,
        )

        print('Instancing button and servos.')
        self._button.irq(handler=self.button_pressed, trigger=Pin.IRQ_RISING)
        print('Setting IRQ.')

    def mqtt_connect(self):
        """"""
        print("Connecting to MQTT server...")

        self._client = MQTTClient(
            CLIENT_ID,
            MQTT_SERVER,
            user=MQTT_USERNAME,
            password=MQTT_PASSWORD,
        )

        self._client.set_callback(self.on_message)

        print("Connecting MQTT")

        self._client.set_last_will(STATUS_TOPIC, "Offline", retain=True)

        self._client.connect()

        self._client.subscribe(TOPIC)

        print("Connected to %s, subscribed to %s topic" % (MQTT_SERVER, TOPIC))

        self._client.publish(STATUS_TOPIC, "Connected", retain=True)

        while True:
            self._client.wait_msg()

    def button_pressed(self, pin):
        if pin.value():
            time.sleep_ms(300)
            print('#' * 80)
            self._client.publish(MANUAL_FEEDING, "")

    def on_message(self, topic, message):
        """"""
        print(topic, message)

        msg = message.strip().decode('utf-8')

        self._client.publish(LAST_FED_TOPIC, "Feeding...")
        self.feed()

    def feed(self):
        """"""
        time.sleep(0.2)
        self._servo_buzz.feed()
        print('fed buzz')
        time.sleep(1)
        print('pause 1 sec')
        self._servo_tuxedo.feed()
        print('fed tuxedo')

        self.done_feeding()

    def done_feeding(self):
        """"""
        time.sleep(0.2)
        self._client.publish(DONE_TOPIC, self._done_payload)
        time.sleep(0.2)
        self._client.publish(QTY_BUZZ_TOPIC,
                             self._servo_buzz.remaining_quantity)
        time.sleep(0.2)
        self._client.publish(QTY_TUXEDO_TOPIC,
                             self._servo_tuxedo.remaining_quantity)

        print("Done feeding!\n\n")
        print('/' * 80)
        print('Waiting for message...')
        while True:
            self._client.wait_msg()

    def run(self):
        self.mqtt_connect()

    def open_close_test(self, open_=48, pause=1):
        """"""
        self._servo_buzz.open_position = open_
        self._servo_tuxedo.open_position = open_
        self._servo_buzz.pause_open = pause
        self._servo_tuxedo.pause_open = pause

        self._servo_buzz.feed()
        print('fed buzz')
        time.sleep(1)
        print('pause 1 sec')
        self._servo_tuxedo.feed()

        while True:
            self._client.wait_msg()
Exemplo n.º 25
0
temp = sensor3.temperature
press = sensor3.pressure
altitude = sensor3.altitude

# toon waarden
print("Temperature: {0:.1f} C".format(temp))
print("Pressure: {0:.0f} mbar".format(press/100))
print("Altitude: {0:.0f} m".format(altitude))

# MQTT client initialiseren
mqtt_server = '192.168.1.22'
# mqtt_server = '172.24.0.118'
mqtt_client = MQTTClient('52dc166c-2de7-43c1-88ff-f80211c7a8f6', mqtt_server)
mqtt_client.connect()

while True:
  # bmp180 uitlezen
  t = sensor3.temperature   # 閹虹煰
  p = sensor3.pressure        # Pa
  a = sensor3.altitude          # m
  # waarden tonen in console
  print("Temperature {0:.1f} C - Pressure {1:.0f} mbar - Altitude {2:.0f} m".format(t,p/100,a))
  # waarden publishen naar mqtt server
  mqtt_client.publish('house/sensor3/temperature', str(t))
  mqtt_client.publish('house/sensor3/pressure', str(p))
  mqtt_client.publish('house/sensor3/altitude', str(a))
  
  # 5 seconden wachten
  time.sleep(5)

Exemplo n.º 26
0
class Web:
    def __init__(self, wifiName, wifiPassword, ADAFRUIT_IO_URL,
                 ADAFRUIT_USERNAME, ADAFRUIT_IO_KEY):
        self.wifiName = wifiName
        self.wifiPassword = wifiPassword
        self.ADAFRUIT_IO_URL = ADAFRUIT_IO_URL
        self.ADAFRUIT_USERNAME = ADAFRUIT_USERNAME
        self.ADAFRUIT_IO_KEY = ADAFRUIT_IO_KEY
        self.Connected = "F"
        # create a random MQTT clientID
        random_num = int.from_bytes(os.urandom(3), 'little')
        self.mqtt_client_id = bytes('client_' + str(random_num), 'utf-8')

        # connect to Adafruit IO MQTT broker using unsecure TCP (port 1883)
        #
        # To use a secure connection (encrypted) with TLS:
        #   set MQTTClient initializer parameter to "ssl=True"
        #   Caveat: a secure connection uses about 9k bytes of the heap
        #         (about 1/4 of the micropython heap on the ESP8266 platform)
        self.client = MQTTClient(client_id=self.mqtt_client_id,
                                 server=ADAFRUIT_IO_URL,
                                 user=ADAFRUIT_USERNAME,
                                 password=ADAFRUIT_IO_KEY,
                                 ssl=False)

        self.values = {}

    def getConnected(self):
        return self.Connected

    def connectToWifi(self):
        # WiFi connection information
        WIFI_SSID = self.wifiName
        WIFI_PASSWORD = self.wifiPassword

        # turn off the WiFi Access Point
        ap_if = network.WLAN(network.AP_IF)
        ap_if.active(False)

        # connect the device to the WiFi network
        wifi = network.WLAN(network.STA_IF)
        wifi.active(True)
        wifi.connect(WIFI_SSID, WIFI_PASSWORD)

        # wait until the device is connected to the WiFi network
        MAX_ATTEMPTS = 20
        attempt_count = 0
        while not wifi.isconnected() and attempt_count < MAX_ATTEMPTS:
            attempt_count += 1
            time.sleep(1)

        if attempt_count == MAX_ATTEMPTS:
            print('could not connect to the WiFi network')
            self.Connected = "F"
            wifi.active(False)
            return Offline.Offline("Offline_Data.txt")

        self.Connected = "T"
        return self

    def connectToMQTT(self):
        try:
            self.client.connect()
            return 0
        except Exception:
            return -1

    def cb(self, topic, msg):
        tp = str(topic, 'utf-8')
        tp = (tp.split('/'))[-1]
        ms = float(str(msg, 'utf-8'))
        self.values[tp] = ms

    def _subscribe(self, feedname):
        mqtt_feedname = bytes(
            '{:s}/feeds/{:s}'.format(self.ADAFRUIT_USERNAME, feedname),
            'utf-8')
        self.client.set_callback(self.cb)
        self.client.subscribe(mqtt_feedname)

        mqtt_feedname_get = bytes(
            '{:s}/feeds/{:s}/get'.format(self.ADAFRUIT_USERNAME, feedname),
            'utf-8')
        self.client.publish(mqtt_feedname_get, '\0')

        self.client.wait_msg()

    def publish(self, feedname, stringToPublish):
        mqtt_feedname = bytes(
            '{:s}/feeds/{:s}'.format(self.ADAFRUIT_USERNAME, feedname),
            'utf-8')

        self.client.publish(mqtt_feedname,
                            bytes(stringToPublish, 'utf-8'),
                            qos=0)

    def subscribe_to_keys(self, listOfKeys):
        for s in listOfKeys:
            bs = str(s, 'utf-8')
            self.values[s] = -9999
            self._subscribe(bs)

    def get_latest_value(self, key):
        return self.values[key]

    def update_values(self):
        self.client.check_msg()
Exemplo n.º 27
0
c = MQTTClient(client_id=CLIENT_ID,
               server=config['mqtt']['server'],
               user=config['mqtt']['user'],
               password=config['mqtt']['password'],
               port=config['mqtt']['port'],
               ssl=config['mqtt']['ssl'])

led = machine.Pin(5, machine.Pin.OUT)
button = machine.Pin(14, machine.Pin.IN, machine.Pin.PULL_UP)


def beep(dur=60):
    led.value(1)
    time.sleep_ms(dur)
    led.value(0)


while True:
    if not button.value():
        c.connect(clean_session=False)
        c.publish("hackeriet/labradoor", "open")
        c.disconnect()

        d = 500
        while d >= 0:
            beep()
            time.sleep_ms(d)
            d = d - 20
        beep(2000)