initial commit

Author: bloft

README.md

@@ -1,2 +1,29 @@
 # EasyMqtt
-Easy setup of Mqtt on the esp8266
+Easy handling of Mqtt on esp6288
+
+This library is currentlly under heavy development.
+And shoud not be used at the moment.
+
+## Examble usage EasyMqtt
+```C++
+#include <EasyMqtt.h>
+
+EasyMqtt mqtt;
+
+void setup() {
+	Serial.begin(115200);
+	Serial.println();
+
+	// Setup wifi
+	mqtt.wifi("ssid", "password");
+	mqtt.mqtt("host", 1883, "user", "pass");
+
+
+	mqtt["wifi"]["rssi"] << [](){ return String(WiFi.RSSI()); };
+}
+
+void loop() {
+	mqtt.loop();
+}
+
+```

keywords.txt

@@ -0,0 +1,18 @@
+#######################################
+# Syntax Coloring Map For PubSubClient
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+EasyMqtt	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+
+#######################################
+# Constants (LITERAL1)
+#######################################

library.json

@@ -0,0 +1,16 @@
+{
+    "name": "EasyMqtt",
+    "keywords": "ethernet, mqtt, m2m, iot",
+    "description": "Makes it easier to get up and runnging with mqtt on the esp8266",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/bloft/EasyMqtt.git"
+    },
+    "version": "2.6",
+    "exclude": "tests",
+    "examples": "examples/*/*.ino",
+    "frameworks": "arduino",
+    "platforms": [
+        "espressif"
+    ]
+}

library.properties

@@ -0,0 +1,9 @@
+name=EasyMqtt
+version=0.1
+author=Bjarne Loft <[email protected]>
+maintainer=Bjarne Loft <[email protected]>
+sentence=A wrapper library for using mqtt on the ESP8266
+paragraph=Makes it easyer to get up and running with Mqtt on the esp8266
+category=Communication
+url=...
+architectures=*

src/EasyMqtt.h

@@ -0,0 +1,95 @@
+#ifndef EasyMqtt_h
+#define EasyMqtt_h 
+
+#include <ESP8266WiFi.h>
+#include <PubSubClient.h>
+#include "MqttMap.h"
+
+class EasyMqtt : public MqttMap {
+	private:
+		WiFiClient wifiClient;
+		PubSubClient mqttClient;
+	
+		String deviceId = "EasyMqtt";	
+		const char* mqtt_username = "N/A";
+		const char* mqtt_password = "N/A";
+
+	protected:
+		virtual String getTopic() {
+			return String("easyMqtt/") + deviceId;
+		}
+
+		MqttMap & getDiag() {
+			return operator[]("diag");
+		}
+
+		/**
+		 * Handle connections to mqtt
+		 */
+		void mqttReconnect() {
+			while (!mqttClient.connected()) {
+				if (mqttClient.connect(deviceId.c_str(), mqtt_username, mqtt_password)) {
+					Serial.println("MQTT connected");
+					subscribe(mqttClient);
+				} else {
+					Serial.print("failed, rc=");
+					Serial.print(mqttClient.state());
+					Serial.println(" try again in 5 seconds");
+					delay(5000);
+				}
+			}
+		}
+
+	public:
+		EasyMqtt() : MqttMap("easyMqtt") {
+			deviceId = String(ESP.getChipId());
+
+      getDiag().setInterval(30l);
+      getDiag()["mem"]["heap"] << [](){ return String(ESP.getFreeHeap()); };
+		}
+
+		/**
+		 * Setup connection to wifi
+		 */
+		void wifi(const char* ssid, const char* password) {
+      WiFi.mode(WIFI_STA);
+      WiFi.begin(ssid, password);
+
+      while (WiFi.status() != WL_CONNECTED) {
+        delay(500);
+        Serial.print(".");
+      }
+      Serial.println("WiFi connected");  
+      Serial.println("IP address: ");
+      Serial.println(WiFi.localIP());
+
+      Serial.print("Chip ID : ");
+      Serial.println(ESP.getChipId());
+
+			// Setup wifi diag
+			getDiag()["wifi"]["rssi"] << [](){ return String(WiFi.RSSI()); };
+      getDiag()["wifi"]["ssid"] << [](){ return WiFi.SSID(); };
+		}
+
+		/**
+		 * Setup connection to mqtt
+		 */
+		void mqtt(const char* host, int port, const char* username, const char* password) {
+			mqttClient.setClient(wifiClient);
+			mqttClient.setCallback([&](const char* topic, uint8_t* payload, unsigned int length) { callback(topic, payload, length); });
+			mqttClient.setServer(host, port);
+			mqtt_username = username;
+			mqtt_password = password;
+		}
+
+		/**
+		 * Handle the normal loop
+		 */
+		void loop() {
+			mqttReconnect();
+			mqttClient.loop();
+			MqttMap::loop(mqttClient);
+		}
+};
+
+#endif

src/MqttMap.h

@@ -0,0 +1,131 @@
+#ifndef MqttMap_h
+#define MqttMap_h 
+
+#include <Arduino.h>
+#include <PubSubClient.h>
+
+class MqttMap {
+	private:
+		void (*outFunction)(String payload) = NULL;
+		String (*inFunction)() = NULL;
+
+		const char* name = "N/A";
+    int interval = 0;
+    unsigned long nextUpdate = 0; // Last read of data
+
+    MqttMap* parent = NULL;
+    MqttMap* next = NULL;
+    MqttMap* children = NULL;
+
+	protected:
+    MqttMap(const char* _name, MqttMap& _parent) {
+      name = _name;
+      parent = &_parent;
+      interval = 0;
+    }
+
+    virtual String getTopic() {
+      if(parent) {
+        return parent->getTopic() + "/" + name;
+      } else {
+        return String(name);
+      }
+    }
+    
+	public:
+		MqttMap(const char* _name) {
+			name = _name;
+      interval = 5;
+		}
+
+		int getInterval() {
+      if(interval == 0) {
+        return parent->getInterval();
+      }
+      return interval;
+    }
+
+		void setInterval(int _interval) {
+			interval = _interval;
+		}
+
+		void callback(const char* _topic, uint8_t* payload, unsigned int length) {
+      if(strcmp(getTopic().c_str(), _topic) == 0) {
+        if(outFunction != NULL) {
+          char _payload[length];
+          for (int i=0;i<length;i++) {
+            _payload[i] = (char)payload[i];
+          }
+          printf("Found callback, %s: %s\n", _topic, _payload);
+          outFunction(String(_payload));
+        }
+      } else {
+        MqttMap* child = children;
+        while(child != NULL) {
+          child->callback(_topic, payload, length);
+          child = child->next;
+        }
+      } 
+		}
+
+		void subscribe(PubSubClient& client) {
+      if(outFunction != NULL) {
+        String topic = getTopic();
+        printf("Subscribe: %s\n", topic.c_str());
+        client.subscribe(topic.c_str());
+      }
+      MqttMap* child = children;
+      while(child != NULL) {
+        child->subscribe(client);
+        child = child->next;
+      }
+		}
+
+		void loop(PubSubClient& client) {
+      if(inFunction != NULL) {
+        unsigned long time = millis();
+        if(time >= nextUpdate) {
+          nextUpdate = time + (getInterval() * 1000);
+          String topic = getTopic();
+          String value = inFunction();
+          printf("Value(%s): %s\n", topic.c_str(), value.c_str());
+          client.publish(topic.c_str(), value.c_str());
+        }
+      }
+      MqttMap* child = children;
+        while(child != NULL) {
+          child->loop(client);;
+          child = child->next;
+        }
+		}
+
+		MqttMap & operator[](const char* name) {
+			MqttMap * child = children;
+        while(child != NULL) {
+          if(strcmp(child->name, name) == 0) {
+            return *child;
+          }
+          child = child->next;
+        }
+        MqttMap * oldChild = children;
+        children = new MqttMap(name, *this);
+        children->next = oldChild;
+        return *children;
+		}
+
+      /**
+     * Read data from function and send it to mqtt
+     */
+    void operator<<(String (*inFunction)()) {
+      MqttMap::inFunction = inFunction;
+    }
+
+    /**
+     * Handle data comming from mqtt
+     */
+    void operator>>(void (*outFunction)(String payload)) {
+      MqttMap::outFunction = outFunction;
+    }
+};
+
+#endif