Merge pull request #3 in WAT/waterishos-revision3.0x from develop to master

* commit '9c557b1f8e66fa35a7483279f0b0f920ba07c0ad':
  Fix bugs
  add espcommander
  Preparing ESPCommander Intergration

.gitignore

@@ -0,0 +1,33 @@
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+private.h

README.md

@@ -1 +1,6 @@
+<<<<<<< HEAD
+# WaterishOS-Revision3.0x
+=======
 # WaterishOS-Revision2.0x
+    This is Waterish OS Revision 2 for Board v2 based on esp8266
+>>>>>>> 4ea1442f6cc3a60cf380eb9710072af0624eefff

WaterishOS-core3.0/WaterishOS-core3.0.ino

@@ -0,0 +1,160 @@
+#include <ArduinoJson.h>
+#include <LiquidCrystal_I2C.h>
+#include <PubSubClient.h>
+#include <MqttWildcard.h>
+#include <PubSubClientTools.h>
+#include <BearSSLHelpers.h>
+#include <CertStoreBearSSL.h>
+#include <ESP8266WiFi.h>
+#include <ESP8266WiFiAP.h>
+#include <ESP8266WiFiGeneric.h>
+#include <ESP8266WiFiMulti.h>
+#include <ESP8266WiFiScan.h>
+#include <ESP8266WiFiSTA.h>
+#include <ESP8266WiFiType.h>
+#include <WiFiClient.h>
+#include <WiFiClientSecure.h>
+#include <WiFiClientSecureAxTLS.h>
+#include <WiFiClientSecureBearSSL.h>
+#include <WiFiServer.h>
+#include <WiFiServerSecureAxTLS.h>
+#include <WiFiServerSecureBearSSL.h>
+#include <WiFiUdp.h>
+#include "private.h"
+#include <FlowMeter.h>
+#include <Wire.h>
+#include <Adafruit_MCP23017.h>
+#include <Thread.h>
+#include <ThreadController.h>
+Adafruit_MCP23017 mcp;
+long tslr = 0;
+WiFiClient espClient;
+PubSubClient client("siwatsystem.com", 1883, espClient);
+PubSubClientTools mqtt(client);
+ThreadController threadControl = ThreadController();
+Thread mqttupdater = Thread();
+Thread datacollector = Thread();
+Thread lcdmanager = Thread();
+boolean online = true;
+boolean sensorstate[12];
+boolean lastsensorstate[12];
+boolean firstrun = true;
+FlowMeter sensor1 = FlowMeter(12);
+FlowMeter sensor2 = FlowMeter(13);
+volatile boolean awakenByInterrupt = false;
+LiquidCrystal_I2C lcd(0x3F, 16, 2);
+int menu;
+void writelcd(String line1, String line2){
+  lcd.clear();
+  lcd.print(line1);
+  lcd.setCursor(0,1);
+  lcd.print(line2);
+}
+void updatelcd()
+{
+  writelcd("1: "+String((int)sensor1.getCurrentFlowrate())+"L/h "+String(sensor1.getTotalVolume())+"L","2:"+String((int)sensor2.getCurrentFlowrate())+"L/h "+String(sensor2.getTotalVolume())+"L");
+}
+void ICACHE_RAM_ATTR read1() {
+  sensor1.count();
+}
+void ICACHE_RAM_ATTR read2() {
+  sensor2.count();
+}
+void collectdata() {
+  sensor1.tick(1000);
+  sensor2.tick(1000);
+}
+void updatemqtt() {
+  mqtt.publish("/waterishos/node" + nodename + "/flowrate1", String(sensor1.getCurrentFlowrate()));
+  mqtt.publish("/waterishos/node" + nodename + "/volume1", String(sensor1.getTotalVolume()));
+  mqtt.publish("/waterishos/node" + nodename + "/flowrate2", String(sensor2.getCurrentFlowrate()));
+  mqtt.publish("/waterishos/node" + nodename + "/volume2", String(sensor2.getTotalVolume()));
+}
+// Copyright Siwat INC(tm) 2019
+// Created by Siwat Sirichai
+// ESPCommander EXTENDED v1.2
+// For Legal Distribution of this code, the comment must not be removed!
+void espcommander(String topic, String rawcommand)  {
+    StaticJsonDocument<200> doc;
+    DeserializationError error = deserializeJson(doc, rawcommand);
+    if (error) {
+      Serial.print(F("deserializeJson() failed: "));
+      Serial.println(error.c_str());
+    return;
+    }
+    const char* command = doc["command"];
+    const char* value = doc["value"];
+}
+//END OF ESPCOMMANDER CODE
+void setup() {
+  lcd.begin();
+  writelcd(" Siwat INC (tm) ","  Waterish OS");
+  delay(1000);
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+  int connectionattempt = 0;
+  while (WiFi.status() != WL_CONNECTED && online)
+  {
+    //wait for it ... (Wait for Wifi Connection)
+    writelcd("WiFi Connecting","   Attempt "+String(connectionattempt));
+    connectionattempt++;
+    delay(500);
+    if (connectionattempt >= 60) {
+      writelcd(" Cannot Connect"," Going Offline!");
+      online = false;
+    }
+  }
+  String wifiname(ssid);
+  if(online)writelcd(" WiFi Connected",wifiname);
+  delay(3000);
+  writelcd("Boot Sequence P3"," Loading Kernel");
+  Serial.begin(115200);
+  pinMode(14, INPUT_PULLUP);
+  pinMode(12, INPUT);
+  pinMode(13, INPUT);
+  attachInterrupt(digitalPinToInterrupt(12), read1, RISING);
+  attachInterrupt(digitalPinToInterrupt(13), read2, RISING);
+  delay(1000);
+  writelcd("Boot Sequence P3","Waking Processor");
+  delay(1000);
+  writelcd("   SETTINGS.H","co-processor:OFF");
+  delay(3000);
+  mcp.begin();
+  for (int i = 0; i <= 15; i++)
+  {
+    mcp.pinMode(i, INPUT);
+    mcp.pullUp(i, LOW);
+    mcp.setupInterruptPin(i, RISING);
+  }
+  delay(1000);
+  writelcd("Boot Sequence P3","    Success!");
+  delay(2000);
+  writelcd("Waterish OS a3.9","Reading  Sensors");
+  delay(1000);
+  writelcd(" Telemetry Node","siwatsystem.com");
+  if (client.connect("waterishos",telemetryuser,telemetrykey)) {
+    writelcd(" Telemetry Node","Connected");
+    mqtt.subscribe("/waterishos/node" + nodename + "command", espcommander);
+    delay(1000);
+  } else {
+    writelcd(" Telemetry Node"," Failed Offline");
+    online=false;
+    delay(3000);
+  }
+  datacollector.onRun(collectdata);
+  datacollector.setInterval(1000);
+  if(online)mqttupdater.onRun(updatemqtt);
+  if(online)mqttupdater.setInterval(1000);
+  lcdmanager.onRun(updatelcd);
+  lcdmanager.setInterval(250);
+  threadControl.add(&datacollector);
+  threadControl.add(&lcdmanager);
+  if(online)threadControl.add(&mqttupdater);
+  if(online)updatemqtt();
+  
+}
+
+void loop() {
+  if(online)client.loop();
+  threadControl.run();
+}

WaterishOS-core3.0/config.h

@@ -0,0 +1,11 @@
+const char ssid[] = "";
+const char password[] = "";
+const char* telemetryhost = "";
+const char* telemetrykey = "";
+const int telemetryport = 1883;
+const char* telemetryuser = "";
+const byte InteruptPinA=1;
+const byte InteruptPinB=3;
+const byte arduinoInterrupt=1;
+const byte buttonPin = 0;
+const String nodename="devkit";

WaterishOS-core3.0/lcdcontrol.h

@@ -0,0 +1,15 @@
+class disp {
+  public:
+    LiquidCrystal_I2C lcd(0x27, 16, 2);
+    int menu;
+    void setmenu(int mnp){
+      this->menu = mnp;
+    }
+    void drawmenu()
+    {
+      switch(this->menu)
+        case: '1':
+          this->lcd.print(" Waterish OS OK ");
+          
+    }
+};

WaterishOS-minimal2.0/WaterishOS-minimal2.0.ino

@@ -1,96 +0,0 @@
-#include <PubSubClient.h>
-#include <MqttWildcard.h>
-#include <PubSubClientTools.h>
-#include <BearSSLHelpers.h>
-#include <CertStoreBearSSL.h>
-#include <ESP8266WiFi.h>
-#include <ESP8266WiFiAP.h>
-#include <ESP8266WiFiGeneric.h>
-#include <ESP8266WiFiMulti.h>
-#include <ESP8266WiFiScan.h>
-#include <ESP8266WiFiSTA.h>
-#include <ESP8266WiFiType.h>
-#include <WiFiClient.h>
-#include <WiFiClientSecure.h>
-#include <WiFiClientSecureAxTLS.h>
-#include <WiFiClientSecureBearSSL.h>
-#include <WiFiServer.h>
-#include <WiFiServerSecureAxTLS.h>
-#include <WiFiServerSecureBearSSL.h>
-#include <WiFiUdp.h>
-#include "config.h"
-#include <FlowMeter.h>
-#include <Wire.h>
-#include <Adafruit_MCP23017.h>
-#include <Thread.h>
-#include <ThreadController.h>
-Adafruit_MCP23017 mcp;
-long tslr=0;
-WiFiClient espClient;
-PubSubClient client("siwatsystem.com", 1883, espClient);
-PubSubClientTools mqtt(client);
-ThreadController threadControl = ThreadController();
-Thread mqttupdater = Thread();
-Thread datacollector = Thread();
-boolean online=true;
-FlowMeter sensorA[6]= FlowMeter(1);
-FlowMeter sensorB[6]= FlowMeter(3);
-volatile boolean awakenByInterrupt = false;
-void readA(){
-  uint8_t pin=mcp.getLastInterruptPin();
-  uint8_t val=mcp.getLastInterruptPinValue();
-  for(int sid=0;sid<=5;sid++)sensorA[sid].count();
-}
-void readB(){
-  uint8_t pin=mcp.getLastInterruptPin();
-  uint8_t val=mcp.getLastInterruptPinValue();
-  for(int sid=8;sid<13;sid++)sensorB[sid-8].count();
-}
-void collectdata(){
-    for(int sid=0;sid<=5;sid++)sensorA[sid].tick(1000);
-    for(int sid=8;sid<13;sid++)sensorB[sid-8].tick(1000);
-}
-void updatemqtt(){
-    for(int counter;counter<=6;counter++)mqtt.publish("/waterishos/node"+nodename+"/flowrateA/"+counter,String(sensorA[counter].getCurrentFlowrate()));
-    for(int counter;counter<=6;counter++)mqtt.publish("/waterishos/node"+nodename+"/volumeA/"+counter,String(sensorA[counter].getTotalVolume()));
-    for(int counter;counter<=6;counter++)mqtt.publish("/waterishos/node"+nodename+"/flowrateB/"+counter,String(sensorB[counter].getCurrentFlowrate()));
-    for(int counter;counter<=6;counter++)mqtt.publish("/waterishos/node"+nodename+"/volumeB/"+counter,String(sensorB[counter].getTotalVolume()));}
-void setup(){
-  WiFi.mode(WIFI_STA);
-  WiFi.begin(ssid, password);
-  int connectionattempt=0;
-  while(WiFi.status() != WL_CONNECTED)
-  {
-    //wait for it ... (Wait for Wifi Connection)
-    connectionattempt++;
-    delay(500);
-    if(connectionattempt>=20){
-      online=false;
-      break;
-    }
-  }
-  attachInterrupt(digitalPinToInterrupt(1),readA,FALLING);
-  attachInterrupt(digitalPinToInterrupt(3),readB,FALLING);
-  pinMode(1, FUNCTION_3); 
-  pinMode(3, FUNCTION_3); 
-  pinMode(1,INPUT);
-  pinMode(3,INPUT);
-  mcp.begin();
-  mcp.setupInterrupts(true,false,LOW);
-  for(int i=0;i<=15;i++)
-  {
-    mcp.pinMode(i, INPUT);
-    mcp.setupInterruptPin(i,RISING);
-    }
-  datacollector.onRun(collectdata);
-  datacollector.setInterval(1000);
-  mqttupdater.onRun(updatemqtt);
-  mqttupdater.setInterval(1000);
-  threadControl.add(&datacollector);
-  threadControl.add(&mqttupdater);
-  }
-
-void loop(){
-   client.loop();
-   threadControl.run();
-}

WaterishOS-minimal2.0/config.h

@@ -1,6 +0,0 @@
-const String ssid = "";
-const String password = "";
-const byte InteruptPinA=1;
-const byte InteruptPinB=3;
-const byte arduinoInterrupt=1;
-const String nodename="devkit";

libraries/Arduino-LiquidCrystal-I2C-library-master/LiquidCrystal_I2C.cpp

@@ -0,0 +1,257 @@
+#include "LiquidCrystal_I2C.h"
+#include <inttypes.h>
+#include <Arduino.h>
+#include <Wire.h>
+
+// When the display powers up, it is configured as follows:
+//
+// 1. Display clear
+// 2. Function set:
+//    DL = 1; 8-bit interface data
+//    N = 0; 1-line display
+//    F = 0; 5x8 dot character font
+// 3. Display on/off control:
+//    D = 0; Display off
+//    C = 0; Cursor off
+//    B = 0; Blinking off
+// 4. Entry mode set:
+//    I/D = 1; Increment by 1
+//    S = 0; No shift
+//
+// Note, however, that resetting the Arduino doesn't reset the LCD, so we
+// can't assume that its in that state when a sketch starts (and the
+// LiquidCrystal constructor is called).
+
+LiquidCrystal_I2C::LiquidCrystal_I2C(uint8_t lcd_addr, uint8_t lcd_cols, uint8_t lcd_rows, uint8_t charsize)
+{
+	_addr = lcd_addr;
+	_cols = lcd_cols;
+	_rows = lcd_rows;
+	_charsize = charsize;
+	_backlightval = LCD_BACKLIGHT;
+}
+
+void LiquidCrystal_I2C::begin() {
+	Wire.begin();
+	_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
+
+	if (_rows > 1) {
+		_displayfunction |= LCD_2LINE;
+	}
+
+	// for some 1 line displays you can select a 10 pixel high font
+	if ((_charsize != 0) && (_rows == 1)) {
+		_displayfunction |= LCD_5x10DOTS;
+	}
+
+	// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
+	// according to datasheet, we need at least 40ms after power rises above 2.7V
+	// before sending commands. Arduino can turn on way befer 4.5V so we'll wait 50
+	delay(50);
+
+	// Now we pull both RS and R/W low to begin commands
+	expanderWrite(_backlightval);	// reset expanderand turn backlight off (Bit 8 =1)
+	delay(1000);
+
+	//put the LCD into 4 bit mode
+	// this is according to the hitachi HD44780 datasheet
+	// figure 24, pg 46
+
+	// we start in 8bit mode, try to set 4 bit mode
+	write4bits(0x03 << 4);
+	delayMicroseconds(4500); // wait min 4.1ms
+
+	// second try
+	write4bits(0x03 << 4);
+	delayMicroseconds(4500); // wait min 4.1ms
+
+	// third go!
+	write4bits(0x03 << 4);
+	delayMicroseconds(150);
+
+	// finally, set to 4-bit interface
+	write4bits(0x02 << 4);
+
+	// set # lines, font size, etc.
+	command(LCD_FUNCTIONSET | _displayfunction);
+
+	// turn the display on with no cursor or blinking default
+	_displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;
+	display();
+
+	// clear it off
+	clear();
+
+	// Initialize to default text direction (for roman languages)
+	_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
+
+	// set the entry mode
+	command(LCD_ENTRYMODESET | _displaymode);
+
+	home();
+}
+
+/********** high level commands, for the user! */
+void LiquidCrystal_I2C::clear(){
+	command(LCD_CLEARDISPLAY);// clear display, set cursor position to zero
+	delayMicroseconds(2000);  // this command takes a long time!
+}
+
+void LiquidCrystal_I2C::home(){
+	command(LCD_RETURNHOME);  // set cursor position to zero
+	delayMicroseconds(2000);  // this command takes a long time!
+}
+
+void LiquidCrystal_I2C::setCursor(uint8_t col, uint8_t row){
+	int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
+	if (row > _rows) {
+		row = _rows-1;    // we count rows starting w/0
+	}
+	command(LCD_SETDDRAMADDR | (col + row_offsets[row]));
+}
+
+// Turn the display on/off (quickly)
+void LiquidCrystal_I2C::noDisplay() {
+	_displaycontrol &= ~LCD_DISPLAYON;
+	command(LCD_DISPLAYCONTROL | _displaycontrol);
+}
+void LiquidCrystal_I2C::display() {
+	_displaycontrol |= LCD_DISPLAYON;
+	command(LCD_DISPLAYCONTROL | _displaycontrol);
+}
+
+// Turns the underline cursor on/off
+void LiquidCrystal_I2C::noCursor() {
+	_displaycontrol &= ~LCD_CURSORON;
+	command(LCD_DISPLAYCONTROL | _displaycontrol);
+}
+void LiquidCrystal_I2C::cursor() {
+	_displaycontrol |= LCD_CURSORON;
+	command(LCD_DISPLAYCONTROL | _displaycontrol);
+}
+
+// Turn on and off the blinking cursor
+void LiquidCrystal_I2C::noBlink() {
+	_displaycontrol &= ~LCD_BLINKON;
+	command(LCD_DISPLAYCONTROL | _displaycontrol);
+}
+void LiquidCrystal_I2C::blink() {
+	_displaycontrol |= LCD_BLINKON;
+	command(LCD_DISPLAYCONTROL | _displaycontrol);
+}
+
+// These commands scroll the display without changing the RAM
+void LiquidCrystal_I2C::scrollDisplayLeft(void) {
+	command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
+}
+void LiquidCrystal_I2C::scrollDisplayRight(void) {
+	command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
+}
+
+// This is for text that flows Left to Right
+void LiquidCrystal_I2C::leftToRight(void) {
+	_displaymode |= LCD_ENTRYLEFT;
+	command(LCD_ENTRYMODESET | _displaymode);
+}
+
+// This is for text that flows Right to Left
+void LiquidCrystal_I2C::rightToLeft(void) {
+	_displaymode &= ~LCD_ENTRYLEFT;
+	command(LCD_ENTRYMODESET | _displaymode);
+}
+
+// This will 'right justify' text from the cursor
+void LiquidCrystal_I2C::autoscroll(void) {
+	_displaymode |= LCD_ENTRYSHIFTINCREMENT;
+	command(LCD_ENTRYMODESET | _displaymode);
+}
+
+// This will 'left justify' text from the cursor
+void LiquidCrystal_I2C::noAutoscroll(void) {
+	_displaymode &= ~LCD_ENTRYSHIFTINCREMENT;
+	command(LCD_ENTRYMODESET | _displaymode);
+}
+
+// Allows us to fill the first 8 CGRAM locations
+// with custom characters
+void LiquidCrystal_I2C::createChar(uint8_t location, uint8_t charmap[]) {
+	location &= 0x7; // we only have 8 locations 0-7
+	command(LCD_SETCGRAMADDR | (location << 3));
+	for (int i=0; i<8; i++) {
+		write(charmap[i]);
+	}
+}
+
+// Turn the (optional) backlight off/on
+void LiquidCrystal_I2C::noBacklight(void) {
+	_backlightval=LCD_NOBACKLIGHT;
+	expanderWrite(0);
+}
+
+void LiquidCrystal_I2C::backlight(void) {
+	_backlightval=LCD_BACKLIGHT;
+	expanderWrite(0);
+}
+bool LiquidCrystal_I2C::getBacklight() {
+  return _backlightval == LCD_BACKLIGHT;
+}
+
+
+/*********** mid level commands, for sending data/cmds */
+
+inline void LiquidCrystal_I2C::command(uint8_t value) {
+	send(value, 0);
+}
+
+inline size_t LiquidCrystal_I2C::write(uint8_t value) {
+	send(value, Rs);
+	return 1;
+}
+
+
+/************ low level data pushing commands **********/
+
+// write either command or data
+void LiquidCrystal_I2C::send(uint8_t value, uint8_t mode) {
+	uint8_t highnib=value&0xf0;
+	uint8_t lownib=(value<<4)&0xf0;
+	write4bits((highnib)|mode);
+	write4bits((lownib)|mode);
+}
+
+void LiquidCrystal_I2C::write4bits(uint8_t value) {
+	expanderWrite(value);
+	pulseEnable(value);
+}
+
+void LiquidCrystal_I2C::expanderWrite(uint8_t _data){
+	Wire.beginTransmission(_addr);
+	Wire.write((int)(_data) | _backlightval);
+	Wire.endTransmission();
+}
+
+void LiquidCrystal_I2C::pulseEnable(uint8_t _data){
+	expanderWrite(_data | En);	// En high
+	delayMicroseconds(1);		// enable pulse must be >450ns
+
+	expanderWrite(_data & ~En);	// En low
+	delayMicroseconds(50);		// commands need > 37us to settle
+}
+
+void LiquidCrystal_I2C::load_custom_character(uint8_t char_num, uint8_t *rows){
+	createChar(char_num, rows);
+}
+
+void LiquidCrystal_I2C::setBacklight(uint8_t new_val){
+	if (new_val) {
+		backlight();		// turn backlight on
+	} else {
+		noBacklight();		// turn backlight off
+	}
+}
+
+void LiquidCrystal_I2C::printstr(const char c[]){
+	//This function is not identical to the function used for "real" I2C displays
+	//it's here so the user sketch doesn't have to be changed
+	print(c);
+}

libraries/Arduino-LiquidCrystal-I2C-library-master/LiquidCrystal_I2C.h

@@ -0,0 +1,165 @@
+#ifndef FDB_LIQUID_CRYSTAL_I2C_H
+#define FDB_LIQUID_CRYSTAL_I2C_H
+
+#include <inttypes.h>
+#include <Print.h>
+
+// commands
+#define LCD_CLEARDISPLAY 0x01
+#define LCD_RETURNHOME 0x02
+#define LCD_ENTRYMODESET 0x04
+#define LCD_DISPLAYCONTROL 0x08
+#define LCD_CURSORSHIFT 0x10
+#define LCD_FUNCTIONSET 0x20
+#define LCD_SETCGRAMADDR 0x40
+#define LCD_SETDDRAMADDR 0x80
+
+// flags for display entry mode
+#define LCD_ENTRYRIGHT 0x00
+#define LCD_ENTRYLEFT 0x02
+#define LCD_ENTRYSHIFTINCREMENT 0x01
+#define LCD_ENTRYSHIFTDECREMENT 0x00
+
+// flags for display on/off control
+#define LCD_DISPLAYON 0x04
+#define LCD_DISPLAYOFF 0x00
+#define LCD_CURSORON 0x02
+#define LCD_CURSOROFF 0x00
+#define LCD_BLINKON 0x01
+#define LCD_BLINKOFF 0x00
+
+// flags for display/cursor shift
+#define LCD_DISPLAYMOVE 0x08
+#define LCD_CURSORMOVE 0x00
+#define LCD_MOVERIGHT 0x04
+#define LCD_MOVELEFT 0x00
+
+// flags for function set
+#define LCD_8BITMODE 0x10
+#define LCD_4BITMODE 0x00
+#define LCD_2LINE 0x08
+#define LCD_1LINE 0x00
+#define LCD_5x10DOTS 0x04
+#define LCD_5x8DOTS 0x00
+
+// flags for backlight control
+#define LCD_BACKLIGHT 0x08
+#define LCD_NOBACKLIGHT 0x00
+
+#define En B00000100  // Enable bit
+#define Rw B00000010  // Read/Write bit
+#define Rs B00000001  // Register select bit
+
+/**
+ * This is the driver for the Liquid Crystal LCD displays that use the I2C bus.
+ *
+ * After creating an instance of this class, first call begin() before anything else.
+ * The backlight is on by default, since that is the most likely operating mode in
+ * most cases.
+ */
+class LiquidCrystal_I2C : public Print {
+public:
+	/**
+	 * Constructor
+	 *
+	 * @param lcd_addr	I2C slave address of the LCD display. Most likely printed on the
+	 *					LCD circuit board, or look in the supplied LCD documentation.
+	 * @param lcd_cols	Number of columns your LCD display has.
+	 * @param lcd_rows	Number of rows your LCD display has.
+	 * @param charsize	The size in dots that the display has, use LCD_5x10DOTS or LCD_5x8DOTS.
+	 */
+	LiquidCrystal_I2C(uint8_t lcd_addr, uint8_t lcd_cols, uint8_t lcd_rows, uint8_t charsize = LCD_5x8DOTS);
+
+	/**
+	 * Set the LCD display in the correct begin state, must be called before anything else is done.
+	 */
+	void begin();
+
+	 /**
+	  * Remove all the characters currently shown. Next print/write operation will start
+	  * from the first position on LCD display.
+	  */
+	void clear();
+
+	/**
+	 * Next print/write operation will will start from the first position on the LCD display.
+	 */
+	void home();
+
+	 /**
+	  * Do not show any characters on the LCD display. Backlight state will remain unchanged.
+	  * Also all characters written on the display will return, when the display in enabled again.
+	  */
+	void noDisplay();
+
+	/**
+	 * Show the characters on the LCD display, this is the normal behaviour. This method should
+	 * only be used after noDisplay() has been used.
+	 */
+	void display();
+
+	/**
+	 * Do not blink the cursor indicator.
+	 */
+	void noBlink();
+
+	/**
+	 * Start blinking the cursor indicator.
+	 */
+	void blink();
+
+	/**
+	 * Do not show a cursor indicator.
+	 */
+	void noCursor();
+
+	/**
+ 	 * Show a cursor indicator, cursor can blink on not blink. Use the
+	 * methods blink() and noBlink() for changing cursor blink.
+	 */
+	void cursor();
+
+	void scrollDisplayLeft();
+	void scrollDisplayRight();
+	void printLeft();
+	void printRight();
+	void leftToRight();
+	void rightToLeft();
+	void shiftIncrement();
+	void shiftDecrement();
+	void noBacklight();
+	void backlight();
+	bool getBacklight();
+	void autoscroll();
+	void noAutoscroll();
+	void createChar(uint8_t, uint8_t[]);
+	void setCursor(uint8_t, uint8_t);
+	virtual size_t write(uint8_t);
+	void command(uint8_t);
+
+	inline void blink_on() { blink(); }
+	inline void blink_off() { noBlink(); }
+	inline void cursor_on() { cursor(); }
+	inline void cursor_off() { noCursor(); }
+
+// Compatibility API function aliases
+	void setBacklight(uint8_t new_val);				// alias for backlight() and nobacklight()
+	void load_custom_character(uint8_t char_num, uint8_t *rows);	// alias for createChar()
+	void printstr(const char[]);
+
+private:
+	void send(uint8_t, uint8_t);
+	void write4bits(uint8_t);
+	void expanderWrite(uint8_t);
+	void pulseEnable(uint8_t);
+	uint8_t _addr;
+	uint8_t _displayfunction;
+	uint8_t _displaycontrol;
+	uint8_t _displaymode;
+	uint8_t _cols;
+	uint8_t _rows;
+	uint8_t _charsize;
+	uint8_t _backlightval;
+};
+
+#endif // FDB_LIQUID_CRYSTAL_I2C_H

libraries/Arduino-LiquidCrystal-I2C-library-master/README.md

@@ -0,0 +1,9 @@
+# Installation #
+Create a new folder called "LiquidCrystal_I2C" under the folder named "libraries" in your Arduino sketchbook folder.
+Create the folder "libraries" in case it does not exist yet. Place all the files in the "LiquidCrystal_I2C" folder.
+
+# Usage #
+To use the library in your own sketch, select it from *Sketch > Import Library*.
+
+-------------------------------------------------------------------------------------------------------------------
+This library is based on work done by DFROBOT (www.dfrobot.com).

libraries/Arduino-LiquidCrystal-I2C-library-master/examples/BlinkingCursor/BlinkingCursor.ino

@@ -0,0 +1,32 @@
+#include <Wire.h> 
+#include <LiquidCrystal_I2C.h>
+
+// Set the LCD address to 0x27 for a 16 chars and 2 line display
+LiquidCrystal_I2C lcd(0x27, 16, 2);
+
+void setup()
+{
+	// initialize the LCD
+	lcd.begin();
+}
+
+void loop()
+{
+	bool blinking = true;
+	lcd.cursor();
+
+	while (1) {
+		if (blinking) {
+			lcd.clear();
+			lcd.print("No cursor blink");
+			lcd.noBlink();
+			blinking = false;
+		} else {
+			lcd.clear();
+			lcd.print("Cursor blink");
+			lcd.blink();
+			blinking = true;
+		}
+		delay(4000);
+	}
+}

libraries/Arduino-LiquidCrystal-I2C-library-master/examples/CustomChars/CustomChars.ino

@@ -0,0 +1,65 @@
+#include <Wire.h>
+#include <LiquidCrystal_I2C.h>
+
+uint8_t bell[8]  = {0x4, 0xe, 0xe, 0xe, 0x1f, 0x0, 0x4};
+uint8_t note[8]  = {0x2, 0x3, 0x2, 0xe, 0x1e, 0xc, 0x0};
+uint8_t clock[8] = {0x0, 0xe, 0x15, 0x17, 0x11, 0xe, 0x0};
+uint8_t heart[8] = {0x0, 0xa, 0x1f, 0x1f, 0xe, 0x4, 0x0};
+uint8_t duck[8]  = {0x0, 0xc, 0x1d, 0xf, 0xf, 0x6, 0x0};
+uint8_t check[8] = {0x0, 0x1 ,0x3, 0x16, 0x1c, 0x8, 0x0};
+uint8_t cross[8] = {0x0, 0x1b, 0xe, 0x4, 0xe, 0x1b, 0x0};
+uint8_t retarrow[8] = {	0x1, 0x1, 0x5, 0x9, 0x1f, 0x8, 0x4};
+
+// Set the LCD address to 0x27 for a 16 chars and 2 line display
+LiquidCrystal_I2C lcd(0x27, 16, 2);
+
+void setup()
+{
+	lcd.begin();
+	lcd.backlight();
+
+	lcd.createChar(0, bell);
+	lcd.createChar(1, note);
+	lcd.createChar(2, clock);
+	lcd.createChar(3, heart);
+	lcd.createChar(4, duck);
+	lcd.createChar(5, check);
+	lcd.createChar(6, cross);
+	lcd.createChar(7, retarrow);
+	lcd.home();
+
+	lcd.print("Hello world...");
+	lcd.setCursor(0, 1);
+	lcd.print(" i ");
+	lcd.write(3);
+	lcd.print(" arduinos!");
+	delay(5000);
+	displayKeyCodes();
+}
+
+// display all keycodes
+void displayKeyCodes(void) {
+	uint8_t i = 0;
+
+	while (1) {
+		lcd.clear();
+		lcd.print("Codes 0x");
+		lcd.print(i, HEX);
+		lcd.print("-0x");
+		lcd.print(i + 16, HEX);
+		lcd.setCursor(0, 1);
+
+		for (int j = 0; j < 16; j++) {
+			lcd.write(i + j);
+		}
+		i += 16;
+
+		delay(4000);
+	}
+}
+
+void loop()
+{
+	// Do nothing here...
+}
+

libraries/Arduino-LiquidCrystal-I2C-library-master/examples/HelloWorld/HelloWorld.ino

@@ -0,0 +1,20 @@
+#include <Wire.h> 
+#include <LiquidCrystal_I2C.h>
+
+// Set the LCD address to 0x27 for a 16 chars and 2 line display
+LiquidCrystal_I2C lcd(0x27, 16, 2);
+
+void setup()
+{
+	// initialize the LCD
+	lcd.begin();
+
+	// Turn on the blacklight and print a message.
+	lcd.backlight();
+	lcd.print("Hello, world!");
+}
+
+void loop()
+{
+	// Do nothing here...
+}

libraries/Arduino-LiquidCrystal-I2C-library-master/examples/SerialDisplay/SerialDisplay.ino

@@ -0,0 +1,34 @@
+/**
+ * Displays text sent over the serial port (e.g. from the Serial Monitor) on
+ * an attached LCD.
+ */
+#include <Wire.h> 
+#include <LiquidCrystal_I2C.h>
+
+// Set the LCD address to 0x27 for a 16 chars and 2 line display
+LiquidCrystal_I2C lcd(0x27, 16, 2);
+
+void setup()
+{
+	lcd.begin();
+	lcd.backlight();
+  
+	// Initialize the serial port at a speed of 9600 baud
+	Serial.begin(9600);
+}
+
+void loop()
+{
+	// If characters arrived over the serial port...
+	if (Serial.available()) {
+		// Wait a bit for the entire message to arrive
+		delay(100);
+		// Clear the screen
+		lcd.clear();
+
+		// Write all characters received with the serial port to the LCD.
+		while (Serial.available() > 0) {
+			lcd.write(Serial.read());
+		}
+	}
+}

libraries/Arduino-LiquidCrystal-I2C-library-master/keywords.txt

@@ -0,0 +1,46 @@
+###########################################
+# Syntax Coloring Map For LiquidCrystal_I2C
+###########################################
+
+###########################################
+# Datatypes (KEYWORD1)
+###########################################
+
+LiquidCrystal_I2C	KEYWORD1
+
+###########################################
+# Methods and Functions (KEYWORD2)
+###########################################
+init	KEYWORD2
+begin	KEYWORD2
+clear	KEYWORD2
+home	KEYWORD2
+noDisplay	KEYWORD2
+display	KEYWORD2
+noBlink	KEYWORD2
+blink	KEYWORD2
+noCursor	KEYWORD2
+cursor	KEYWORD2
+scrollDisplayLeft	KEYWORD2
+scrollDisplayRight	KEYWORD2
+leftToRight	KEYWORD2
+rightToLeft	KEYWORD2
+shiftIncrement	KEYWORD2
+shiftDecrement	KEYWORD2
+noBacklight	KEYWORD2
+backlight	KEYWORD2
+autoscroll	KEYWORD2
+noAutoscroll	KEYWORD2
+createChar	KEYWORD2
+setCursor	KEYWORD2
+print	KEYWORD2
+blink_on	KEYWORD2
+blink_off	KEYWORD2
+cursor_on	KEYWORD2
+cursor_off	KEYWORD2
+setBacklight	KEYWORD2
+load_custom_character	KEYWORD2
+printstr	KEYWORD2
+###########################################
+# Constants (LITERAL1)
+###########################################