# Copyright (c) 2014 Adafruit Industries # Author: Tony DiCola # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import logging import paho.mqtt.client as mqtt import sys from .errors import MQTTError, RequestError # How long to wait before sending a keep alive (paho-mqtt configuration). KEEP_ALIVE_SEC = 60 # One minute logger = logging.getLogger(__name__) class MQTTClient(object): """Interface for publishing and subscribing to feed changes on Adafruit IO using the MQTT protocol. """ def __init__(self, username, key, service_host='io.adafruit.com', secure=True): """Create instance of MQTT client. :param username: Adafruit.IO Username for your account. :param key: Adafruit IO access key (AIO Key) for your account. :param secure: (optional, boolean) Switches secure/insecure connections """ self._username = username self._service_host = service_host if secure: self._service_port = 8883 elif not secure: self._service_port = 1883 # Initialize event callbacks to be None so they don't fire. self.on_connect = None self.on_disconnect = None self.on_message = None self.on_subscribe = None # Initialize MQTT client. self._client = mqtt.Client() if secure: self._client.tls_set_context() self._secure = True elif not secure: print('**THIS CONNECTION IS INSECURE** SSL/TLS not supported for this platform') self._secure = False self._client.username_pw_set(username, key) self._client.on_connect = self._mqtt_connect self._client.on_disconnect = self._mqtt_disconnect self._client.on_message = self._mqtt_message self._connected = False def _mqtt_connect(self, client, userdata, flags, rc): logger.debug('Client on_connect called.') # Check if the result code is success (0) or some error (non-zero) and # raise an exception if failed. if rc == 0: #raise RequestError(rc) self._connected = True print('Connected to Adafruit IO!') else: # handle RC errors within MQTTError class raise MQTTError(rc) # Call the on_connect callback if available. if self.on_connect is not None: self.on_connect(self) def _mqtt_disconnect(self, client, userdata, rc): logger.debug('Client on_disconnect called.') self._connected = False # If this was an unexpected disconnect (non-zero result code) then just # log the RC as an error. Continue on to call any disconnect handler # so clients can potentially recover gracefully. if rc != 0: print("Unexpected disconnection.") raise MQTTError(rc) print('Disconnected from Adafruit IO!') # Call the on_disconnect callback if available. if self.on_disconnect is not None: self.on_disconnect(self) def _mqtt_message(self, client, userdata, msg): logger.debug('Client on_message called.') # Parse out the feed id and call on_message callback. # Assumes topic looks like "username/feeds/id" parsed_topic = msg.topic.split('/') if self.on_message is not None: feed = parsed_topic[2] payload = '' if msg.payload is None else msg.payload.decode('utf-8') elif self.on_message is not None and parsed_topic[0] == 'time': feed = parsed_topic[0] payload = msg.payload.decode('utf-8') self.on_message(self, feed, payload) def _mqtt_subscribe(client, userdata, mid, granted_qos): """Called when broker responds to a subscribe request.""" def connect(self, **kwargs): """Connect to the Adafruit.IO service. Must be called before any loop or publish operations are called. Will raise an exception if a connection cannot be made. Optional keyword arguments will be passed to paho-mqtt client connect function. """ # Skip calling connect if already connected. if self._connected: return # If given, use user-provided keepalive, otherwise default to KEEP_ALIVE_SEC keepalive = kwargs.pop('keepalive', KEEP_ALIVE_SEC) # Connect to the Adafruit IO MQTT service. self._client.connect(self._service_host, port=self._service_port, keepalive=keepalive, **kwargs) def is_connected(self): """Returns True if connected to Adafruit.IO and False if not connected. """ return self._connected def disconnect(self): """Disconnect MQTT client if connected.""" if self._connected: self._client.disconnect() def loop_background(self, stop=None): """Starts a background thread to listen for messages from Adafruit.IO and call the appropriate callbacks when feed events occur. Will return immediately and will not block execution. Should only be called once. Params: - stop: boolean, stops the execution of the background loop. """ if stop: self._client.loop_stop() self._client.loop_start() def loop_blocking(self): """Listen for messages from Adafruit.IO and call the appropriate callbacks when feed events occur. This call will block execution of your program and will not return until disconnect is explicitly called. This is useful if your program doesn't need to do anything else except listen and respond to Adafruit.IO feed events. If you need to do other processing, consider using the loop_background function to run a loop in the background. """ self._client.loop_forever() def loop(self, timeout_sec=1.0): """Manually process messages from Adafruit.IO. This is meant to be used inside your own main loop, where you periodically call this function to make sure messages are being processed to and from Adafruit_IO. The optional timeout_sec parameter specifies at most how long to block execution waiting for messages when this function is called. The default is one second. """ self._client.loop(timeout=timeout_sec) def subscribe(self, feed_id, feed_user=None): """Subscribe to changes on the specified feed. When the feed is updated the on_message function will be called with the feed_id and new value. Params: - feed_id: The id of the feed to update. - feed_user (optional): The user id of the feed. Used for feed sharing. """ if feed_user is not None: (res, mid) = self._client.subscribe('{0}/feeds/{1}'.format(feed_user, feed_id)) else: (res, mid) = self._client.subscribe('{0}/feeds/{1}'.format(self._username, feed_id)) return res, mid def subscribe_time(self, time): """Subscribe to changes on the Adafruit IO time feeds. When the feed is updated, the on_message function will be called and publish a new value: time feeds: millis: milliseconds seconds: seconds iso: ISO-8601 (https://en.wikipedia.org/wiki/ISO_8601) """ if time == 'millis' or time == 'seconds': self._client.subscribe('time/{0}'.format(time)) elif time == 'iso': self._client.subscribe('time/ISO-8601') else: raise TypeError('Invalid Time Feed Specified.') return def unsubscribe(self, feed_id): """Unsubscribes from a specified MQTT feed. Note: this does not prevent publishing to a feed, it will unsubscribe from receiving messages via on_message. """ (res, mid) = self._client.unsubscribe('{0}/feeds/{1}'.format(self._username, feed_id)) def publish(self, feed_id, value=None, feed_user=None): """Publish a value to a specified feed. Params: - feed_id: The id of the feed to update. - feed_user (optional): The user id of the feed. Used for feed sharing. - value: The new value to publish to the feed. """ if feed_user is not None: (res, self._pub_mid) = self._client.publish('{0}/feeds/{1}'.format(feed_user, feed_id), payload=value) else: (res, self._pub_mid) = self._client.publish('{0}/feeds/{1}'.format(self._username, feed_id), payload=value)