Merge remote-tracking branch 'origin/develop'

AbandonedFiles/ESP8266/sensornode_aRest/DHT.cpp

@@ -0,0 +1,259 @@
+/* DHT library
+
+MIT license
+written by Adafruit Industries
+*/
+
+#include "DHT.h"
+
+#define MIN_INTERVAL 2000
+
+DHT::DHT(uint8_t pin, uint8_t type, uint8_t count) {
+  _pin = pin;
+  _type = type;
+  #ifdef __AVR
+    _bit = digitalPinToBitMask(pin);
+    _port = digitalPinToPort(pin);
+  #endif
+  _maxcycles = microsecondsToClockCycles(1000);  // 1 millisecond timeout for
+                                                 // reading pulses from DHT sensor.
+  // Note that count is now ignored as the DHT reading algorithm adjusts itself
+  // basd on the speed of the processor.
+}
+
+void DHT::begin(void) {
+  // set up the pins!
+  pinMode(_pin, INPUT_PULLUP);
+  // Using this value makes sure that millis() - lastreadtime will be
+  // >= MIN_INTERVAL right away. Note that this assignment wraps around,
+  // but so will the subtraction.
+  _lastreadtime = -MIN_INTERVAL;
+  DEBUG_PRINT("Max clock cycles: "); DEBUG_PRINTLN(_maxcycles, DEC);
+}
+
+//boolean S == Scale.  True == Fahrenheit; False == Celcius
+float DHT::readTemperature(bool S, bool force) {
+  float f = NAN;
+
+  if (read(force)) {
+    switch (_type) {
+    case DHT11:
+      f = data[2];
+      if(S) {
+        f = convertCtoF(f);
+      }
+      break;
+    case DHT22:
+    case DHT21:
+      f = data[2] & 0x7F;
+      f *= 256;
+      f += data[3];
+      f *= 0.1;
+      if (data[2] & 0x80) {
+        f *= -1;
+      }
+      if(S) {
+        f = convertCtoF(f);
+      }
+      break;
+    }
+  }
+  return f;
+}
+
+float DHT::convertCtoF(float c) {
+  return c * 1.8 + 32;
+}
+
+float DHT::convertFtoC(float f) {
+  return (f - 32) * 0.55555;
+}
+
+float DHT::readHumidity(bool force) {
+  float f = NAN;
+  if (read()) {
+    switch (_type) {
+    case DHT11:
+      f = data[0];
+      break;
+    case DHT22:
+    case DHT21:
+      f = data[0];
+      f *= 256;
+      f += data[1];
+      f *= 0.1;
+      break;
+    }
+  }
+  return f;
+}
+
+//boolean isFahrenheit: True == Fahrenheit; False == Celcius
+float DHT::computeHeatIndex(float temperature, float percentHumidity, bool isFahrenheit) {
+  // Using both Rothfusz and Steadman's equations
+  // http://www.wpc.ncep.noaa.gov/html/heatindex_equation.shtml
+  float hi;
+
+  if (!isFahrenheit)
+    temperature = convertCtoF(temperature);
+
+  hi = 0.5 * (temperature + 61.0 + ((temperature - 68.0) * 1.2) + (percentHumidity * 0.094));
+
+  if (hi > 79) {
+    hi = -42.379 +
+             2.04901523 * temperature +
+            10.14333127 * percentHumidity +
+            -0.22475541 * temperature*percentHumidity +
+            -0.00683783 * pow(temperature, 2) +
+            -0.05481717 * pow(percentHumidity, 2) +
+             0.00122874 * pow(temperature, 2) * percentHumidity +
+             0.00085282 * temperature*pow(percentHumidity, 2) +
+            -0.00000199 * pow(temperature, 2) * pow(percentHumidity, 2);
+
+    if((percentHumidity < 13) && (temperature >= 80.0) && (temperature <= 112.0))
+      hi -= ((13.0 - percentHumidity) * 0.25) * sqrt((17.0 - abs(temperature - 95.0)) * 0.05882);
+
+    else if((percentHumidity > 85.0) && (temperature >= 80.0) && (temperature <= 87.0))
+      hi += ((percentHumidity - 85.0) * 0.1) * ((87.0 - temperature) * 0.2);
+  }
+
+  return isFahrenheit ? hi : convertFtoC(hi);
+}
+
+boolean DHT::read(bool force) {
+  // Check if sensor was read less than two seconds ago and return early
+  // to use last reading.
+  uint32_t currenttime = millis();
+  if (!force && ((currenttime - _lastreadtime) < 2000)) {
+    return _lastresult; // return last correct measurement
+  }
+  _lastreadtime = currenttime;
+
+  // Reset 40 bits of received data to zero.
+  data[0] = data[1] = data[2] = data[3] = data[4] = 0;
+
+  // Send start signal.  See DHT datasheet for full signal diagram:
+  //   http://www.adafruit.com/datasheets/Digital%20humidity%20and%20temperature%20sensor%20AM2302.pdf
+
+  // Go into high impedence state to let pull-up raise data line level and
+  // start the reading process.
+  digitalWrite(_pin, HIGH);
+  delay(250);
+
+  // First set data line low for 20 milliseconds.
+  pinMode(_pin, OUTPUT);
+  digitalWrite(_pin, LOW);
+  delay(20);
+
+  uint32_t cycles[80];
+  {
+    // Turn off interrupts temporarily because the next sections are timing critical
+    // and we don't want any interruptions.
+    InterruptLock lock;
+
+    // End the start signal by setting data line high for 40 microseconds.
+    digitalWrite(_pin, HIGH);
+    delayMicroseconds(40);
+
+    // Now start reading the data line to get the value from the DHT sensor.
+    pinMode(_pin, INPUT_PULLUP);
+    delayMicroseconds(10);  // Delay a bit to let sensor pull data line low.
+
+    // First expect a low signal for ~80 microseconds followed by a high signal
+    // for ~80 microseconds again.
+    if (expectPulse(LOW) == 0) {
+      DEBUG_PRINTLN(F("Timeout waiting for start signal low pulse."));
+      _lastresult = false;
+      return _lastresult;
+    }
+    if (expectPulse(HIGH) == 0) {
+      DEBUG_PRINTLN(F("Timeout waiting for start signal high pulse."));
+      _lastresult = false;
+      return _lastresult;
+    }
+
+    // Now read the 40 bits sent by the sensor.  Each bit is sent as a 50
+    // microsecond low pulse followed by a variable length high pulse.  If the
+    // high pulse is ~28 microseconds then it's a 0 and if it's ~70 microseconds
+    // then it's a 1.  We measure the cycle count of the initial 50us low pulse
+    // and use that to compare to the cycle count of the high pulse to determine
+    // if the bit is a 0 (high state cycle count < low state cycle count), or a
+    // 1 (high state cycle count > low state cycle count). Note that for speed all
+    // the pulses are read into a array and then examined in a later step.
+    for (int i=0; i<80; i+=2) {
+      cycles[i]   = expectPulse(LOW);
+      cycles[i+1] = expectPulse(HIGH);
+    }
+  } // Timing critical code is now complete.
+
+  // Inspect pulses and determine which ones are 0 (high state cycle count < low
+  // state cycle count), or 1 (high state cycle count > low state cycle count).
+  for (int i=0; i<40; ++i) {
+    uint32_t lowCycles  = cycles[2*i];
+    uint32_t highCycles = cycles[2*i+1];
+    if ((lowCycles == 0) || (highCycles == 0)) {
+      DEBUG_PRINTLN(F("Timeout waiting for pulse."));
+      _lastresult = false;
+      return _lastresult;
+    }
+    data[i/8] <<= 1;
+    // Now compare the low and high cycle times to see if the bit is a 0 or 1.
+    if (highCycles > lowCycles) {
+      // High cycles are greater than 50us low cycle count, must be a 1.
+      data[i/8] |= 1;
+    }
+    // Else high cycles are less than (or equal to, a weird case) the 50us low
+    // cycle count so this must be a zero.  Nothing needs to be changed in the
+    // stored data.
+  }
+
+  DEBUG_PRINTLN(F("Received:"));
+  DEBUG_PRINT(data[0], HEX); DEBUG_PRINT(F(", "));
+  DEBUG_PRINT(data[1], HEX); DEBUG_PRINT(F(", "));
+  DEBUG_PRINT(data[2], HEX); DEBUG_PRINT(F(", "));
+  DEBUG_PRINT(data[3], HEX); DEBUG_PRINT(F(", "));
+  DEBUG_PRINT(data[4], HEX); DEBUG_PRINT(F(" =? "));
+  DEBUG_PRINTLN((data[0] + data[1] + data[2] + data[3]) & 0xFF, HEX);
+
+  // Check we read 40 bits and that the checksum matches.
+  if (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF)) {
+    _lastresult = true;
+    return _lastresult;
+  }
+  else {
+    DEBUG_PRINTLN(F("Checksum failure!"));
+    _lastresult = false;
+    return _lastresult;
+  }
+}
+
+// Expect the signal line to be at the specified level for a period of time and
+// return a count of loop cycles spent at that level (this cycle count can be
+// used to compare the relative time of two pulses).  If more than a millisecond
+// ellapses without the level changing then the call fails with a 0 response.
+// This is adapted from Arduino's pulseInLong function (which is only available
+// in the very latest IDE versions):
+//   https://github.com/arduino/Arduino/blob/master/hardware/arduino/avr/cores/arduino/wiring_pulse.c
+uint32_t DHT::expectPulse(bool level) {
+  uint32_t count = 0;
+  // On AVR platforms use direct GPIO port access as it's much faster and better
+  // for catching pulses that are 10's of microseconds in length:
+  #ifdef __AVR
+    uint8_t portState = level ? _bit : 0;
+    while ((*portInputRegister(_port) & _bit) == portState) {
+      if (count++ >= _maxcycles) {
+        return 0; // Exceeded timeout, fail.
+      }
+    }
+  // Otherwise fall back to using digitalRead (this seems to be necessary on ESP8266
+  // right now, perhaps bugs in direct port access functions?).
+  #else
+    while (digitalRead(_pin) == level) {
+      if (count++ >= _maxcycles) {
+        return 0; // Exceeded timeout, fail.
+      }
+    }
+  #endif
+
+  return count;
+}

AbandonedFiles/ESP8266/sensornode_aRest/DHT.h

@@ -0,0 +1,75 @@
+/* DHT library
+
+MIT license
+written by Adafruit Industries
+*/
+#ifndef DHT_H
+#define DHT_H
+
+#if ARDUINO >= 100
+ #include "Arduino.h"
+#else
+ #include "WProgram.h"
+#endif
+
+
+// Uncomment to enable printing out nice debug messages.
+//#define DHT_DEBUG
+
+// Define where debug output will be printed.
+#define DEBUG_PRINTER Serial
+
+// Setup debug printing macros.
+#ifdef DHT_DEBUG
+  #define DEBUG_PRINT(...) { DEBUG_PRINTER.print(__VA_ARGS__); }
+  #define DEBUG_PRINTLN(...) { DEBUG_PRINTER.println(__VA_ARGS__); }
+#else
+  #define DEBUG_PRINT(...) {}
+  #define DEBUG_PRINTLN(...) {}
+#endif
+
+// Define types of sensors.
+#define DHT11 11
+#define DHT22 22
+#define DHT21 21
+#define AM2301 21
+
+
+class DHT {
+  public:
+   DHT(uint8_t pin, uint8_t type, uint8_t count=6);
+   void begin(void);
+   float readTemperature(bool S=false, bool force=false);
+   float convertCtoF(float);
+   float convertFtoC(float);
+   float computeHeatIndex(float temperature, float percentHumidity, bool isFahrenheit=true);
+   float readHumidity(bool force=false);
+   boolean read(bool force=false);
+
+ private:
+  uint8_t data[5];
+  uint8_t _pin, _type;
+  #ifdef __AVR
+    // Use direct GPIO access on an 8-bit AVR so keep track of the port and bitmask
+    // for the digital pin connected to the DHT.  Other platforms will use digitalRead.
+    uint8_t _bit, _port;
+  #endif
+  uint32_t _lastreadtime, _maxcycles;
+  bool _lastresult;
+
+  uint32_t expectPulse(bool level);
+
+};
+
+class InterruptLock {
+  public:
+   InterruptLock() {
+    noInterrupts();
+   }
+   ~InterruptLock() {
+    interrupts();
+   }
+
+};
+
+#endif

AbandonedFiles/ESP8266/sensornode_aRest/sensornode.ino

@@ -0,0 +1,130 @@
+#include "DHT.h"
+#include <ESP8266WiFi.h>
+#include "aREST.h"
+#include <climits>
+
+//If the debug macro is enabled, there's a freeMemory routine
+//Check if this resolves the crashes...
+#define DEBUG_MODE 1
+
+
+//DHT settings:
+#define DHTPIN 14     // what digital pin we're connected to
+
+#define MEASURESECONDS 60 //shouldn't be < 2sec
+
+// Uncomment whatever type you're using!
+//#define DHTTYPE DHT11   // DHT 11
+#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321
+//#define DHTTYPE DHT21   // DHT 21 (AM2301)
+
+
+// Initialize DHT sensor.
+// Note that older versions of this library took an optional third parameter to
+// tweak the timings for faster processors.  This parameter is no longer needed
+// as the current DHT reading algorithm adjusts itself to work on faster procs.
+DHT dht(DHTPIN, DHTTYPE);
+
+// Create aREST instance
+aREST rest = aREST();
+
+// WiFi settings:
+const char* ssid = "Your_SSID";
+const char* password = "Your_Password";
+
+#define LISTEN_PORT 80
+
+// Create an instance of the server
+WiFiServer server(LISTEN_PORT);
+
+// Variables to be exposed to the API
+float temperature;
+float humidity;
+
+
+//milli counter
+unsigned long millitotal = 0;
+float millicounter = 0;
+
+//Temp variables
+float h, t;
+
+//First measurement
+bool firstmeasurement = true;
+
+
+void setup() {
+  Serial.begin(115200);
+  Serial.println("Sensornode start");
+
+  //dht driver initialization
+  dht.begin();
+
+  //Expose variables to the rest api
+  rest.variable("temperature", &temperature);
+  rest.variable("humidity", &humidity);
+
+  // Set a ID (ID must be greater than 0)
+  rest.set_id("1");
+  rest.set_name("sensornode");
+
+
+  // Connect to WiFi
+  Serial.println("Connecting to wlan");
+  WiFi.begin(ssid, password);
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+  Serial.println("\nWiFi connected");
+
+  // Start the server
+  server.begin();
+  Serial.println("Server started");
+
+  // Print the IP address
+  Serial.println(WiFi.localIP());
+}
+
+void loop() {
+  // Wait a few seconds between measurements.
+  millicounter = millis();
+  
+  if (millicounter >= millitotal) {
+    // Reading temperature or humidity takes about 250 milliseconds!
+    // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
+    h = dht.readHumidity();
+    // Read temperature as Celsius (the default)
+    t = dht.readTemperature();
+    
+    // Check if any reads failed and exit early (to try again).
+    if (isnan(h) || isnan(t)) {
+      Serial.println("Failed to read from DHT sensor!");
+      return;
+    } else {
+      //set the new values
+      humidity = h;
+      temperature = t;
+    }
+
+    //set new milli counter
+    //millis will overflow after approx. 52 days. To prevent errors we're checking the limits
+    if (millis() + (MEASURESECONDS * 1000) <= ULONG_MAX) {
+      millitotal = millis() + (MEASURESECONDS * 1000);
+    } else {
+      millitotal = 0;
+    }
+  }
+  // Handle REST calls
+  WiFiClient client = server.available();
+  if (!client) {
+    return;
+  }
+  while(!client.available()){
+    delay(1);
+  }
+  rest.handle(client);
+
+  //Let the esp chill a bit
+  delay(100);
+}

AbandonedFiles/humidityserver/CMakeLists.txt

@@ -0,0 +1,32 @@
+cmake_minimum_required(VERSION 2.6)
+
+project (humidityserver CXX)
+
+set(HUMIDITYSERVER_HEADERS humidityserver.h)
+
+set(PROJECT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
+set(HUMIDITYSERVER_CODEGEN_DIR "${PROJECT_BINARY_DIR}/codegen")
+
+PREPEND(HUMIDITYSERVER_HEADERS_PATHS ${PROJECT_SOURCE_DIR} ${HUMIDITYSERVER_HEADERS})
+
+CODEGEN_FILES(HUMIDITYSERVER_CODEGEN_SOURCES ${HUMIDITYSERVER_CODEGEN_DIR} ${HUMIDITYSERVER_HEADERS})
+
+add_custom_command(OUTPUT ${HUMIDITYSERVER_CODEGEN_SOURCES}
+    COMMAND ${NGREST_BIN_PATH}ngrestcg -i "${PROJECT_SOURCE_DIR}" -o ${HUMIDITYSERVER_CODEGEN_DIR} -t service ${HUMIDITYSERVER_HEADERS}
+    DEPENDS ${HUMIDITYSERVER_HEADERS_PATHS}
+)
+
+file(GLOB HUMIDITYSERVER_SOURCES ${PROJECT_SOURCE_DIR}/*.c*)
+
+list(APPEND HUMIDITYSERVER_SOURCES ${HUMIDITYSERVER_CODEGEN_SOURCES})
+
+include_directories(${PROJECT_SOURCE_DIR} $ENV{NGREST_EXT_INCLUDES})
+
+add_library(humidityserver MODULE ${HUMIDITYSERVER_SOURCES})
+
+set_target_properties(humidityserver PROPERTIES PREFIX "")
+set_target_properties(humidityserver PROPERTIES
+    LIBRARY_OUTPUT_DIRECTORY "${PROJECT_SERVICES_DIR}"
+)
+
+target_link_libraries(humidityserver ngrestutils ngrestcommon ngrestjson ngrestengine $ENV{NGREST_EXT_LIBS})

AbandonedFiles/humidityserver/src/calculate.c

@@ -0,0 +1,80 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h> /* link against math lib */
+#include "calculate.h"
+
+#define R 8314.3 //J/(kmol*K) (universelle Gaskonstante)
+#define mw 18.016 //kg/kmol (Molekulargewicht des Wasserdampfes)
+
+/*
+Bezeichnungen:
+r = relative Luftfeuchte
+T = Temperatur in °C
+TK = Temperatur in Kelvin (TK = T + 273.15)
+TD = Taupunkttemperatur in °C
+DD = Dampfdruck in hPa
+SDD = Sättigungsdampfdruck in hPa
+
+Parameter:
+a = 7.5, b = 237.3 für T >= 0
+a = 7.6, b = 240.7 für T < 0 über Wasser (Taupunkt)
+a = 9.5, b = 265.5 für T < 0 über Eis (Frostpunkt)
+
+R* = 8314.3 J/(kmol*K) (universelle Gaskonstante)
+mw = 18.016 kg/kmol (Molekulargewicht des Wasserdampfes)
+AF = absolute Feuchte in g Wasserdampf pro m3 Luft
+
+Formeln:
+
+    SDD(T) = 6.1078 * 10^((a*T)/(b+T))
+    DD(r,T) = r/100 * SDD(T)
+    r(T,TD) = 100 * SDD(TD) / SDD(T)
+    TD(r,T) = b*v/(a-v) mit v(r,T) = log10(DD(r,T)/6.1078)
+    AF(r,TK) = 10^5 * mw/R* * DD(r,T)/TK; AF(TD,TK) = 10^5 * mw/R* * SDD(TD)/TK
+*/
+
+static float sdd(float temperature) {
+  //select constant based on input temperature
+  float a = 7.5, b = 237.3;
+  if (temperature >= 0) {
+    a = 7.6;
+    b = 240.7;
+  }
+  return 6.1078 * pow(10, (a * temperature) / (b + temperature));
+}
+
+static float dd(float relativeHumidity, float temperature) {
+  return relativeHumidity / 100 * sdd(temperature);
+}
+
+/* CURRENTLY UNUSED
+
+static float r(float temperature, float dewTemperature) {
+  // This is optional. Necessary with dew point measurements.
+  return 100 * sdd(dewTemperature) / sdd(temperature);
+}
+
+static float v(float relativeHumidity, float temperature) {
+  log10(dd(relativeHumidity, temperature)/6.1078);
+}
+
+static float td(float relativeHumidity, float temperature) {
+  //select constant based on input temperature
+  float a = 7.5, b = 237.3;
+  if (temperature >= 0) {
+    a = 7.6;
+    b = 240.7;
+  }
+  return b * v(relativeHumidity, temperature) / (a - v(relativeHumidity, temperature));
+}
+*/
+static float af(float relativeHumidity, float temperature) {
+    float tk = temperature + 273.15;
+    return pow(10, 5) * mw/R * dd(relativeHumidity, temperature) / tk;
+}
+
+float absoluteHumidityFloat(float temperature, float humidity) {
+    return af(humidity, temperature);
+}
+
+  

AbandonedFiles/humidityserver/src/calculate.h

@@ -0,0 +1,15 @@
+#ifndef calculate_H
+#define calculate_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+float absoluteHumidityFloat(float temperature, float humidity);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

AbandonedFiles/humidityserver/src/humidityserver.cpp

@@ -0,0 +1,18 @@
+// This file generated by ngrestcg
+// For more information, please visit: https://github.com/loentar/ngrest
+
+#include "humidityserver.h"
+#include "calculate.h"
+#include <ngrest/common/Nullable.h>
+
+
+float humidityserver::absolutehumidity(float temperature, float humidity) {
+    
+    //Format: node_id, pin, humidity, temperature, gm3, isoutside
+    int node_id = 1;
+    int pin = 0;
+    int isoutside = 0;
+    float absHum = absoluteHumidityFloat(temperature, humidity); 
+
+    return absHum; 
+}

AbandonedFiles/humidityserver/src/humidityserver.h

@@ -0,0 +1,28 @@
+// This file generated by ngrestcg
+// For more information, please visit: https://github.com/loentar/ngrest
+
+#ifndef HUMIDITYSERVER_H
+#define HUMIDITYSERVER_H
+
+#include <ngrest/common/Service.h>
+
+//! Dummy description for the service
+/*! Some detailed description of the service */
+// '*location' comment sets resource path for this service
+// *location: humidityserver
+class humidityserver: public ngrest::Service
+{
+public:
+    // *method: GET
+    // *location: /abshum?temperature={temperature}&humidity={humidity}
+    float absolutehumidity(float temperature, float humidity);
+private:
+    //Format: Table, User, Password
+    
+};
+
+
+#endif // HUMIDITYSERVER_H
+
+
+

Configs/humidityserver

@@ -0,0 +1,39 @@
+#!/bin/sh
+### BEGIN INIT INFO
+# Provides:          humidityserver
+# Required-Start:    $local_fs
+# Required-Stop:     $local_fs
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# X-Interactive:     false
+# Short-Description: Humidity Rest Server
+# Description:       Start/stop humidity rest server
+### END INIT INFO
+
+DESC="HimidityPi rest server"
+NAME=humidityserver
+#DAEMON=
+
+do_start()
+{
+   echo "starting!";
+   /usr/bin/humidityserver &
+}
+
+do_stop()
+{
+   echo "stopping!"
+   killall humidityserver
+}
+
+
+case "$1" in
+   start)
+     do_start
+     ;;
+   stop)
+     do_stop
+     ;;
+esac
+
+exit 0

Configs/laravel.conf

@@ -0,0 +1,15 @@
+<VirtualHost *:80>
+    ServerName localhost
+
+    ServerAdmin lala@lala.de
+    DocumentRoot /var/www/html/public
+
+    <Directory /var/www/html>
+        AllowOverride All
+    </Directory>
+
+    ErrorLog ${APACHE_LOG_DIR}/error.log
+    CustomLog ${APACHE_LOG_DIR}/access.log combined
+
+
+</VirtualHost>

ESP8266/sensornode/sensornode.ino

@@ -1,11 +1,8 @@
 #include "DHT.h"
 #include <ESP8266WiFi.h>
-#include "aREST.h"
-#include <climits>
+#include <ESP8266HTTPClient.h>
 
-//If the debug macro is enabled, there's a freeMemory routine
-//Check if this resolves the crashes...
-#define DEBUG_MODE 1
+#include <climits>
 
 
 //DHT settings:
@@ -25,22 +22,11 @@
 // as the current DHT reading algorithm adjusts itself to work on faster procs.
 DHT dht(DHTPIN, DHTTYPE);
 
-// Create aREST instance
-aREST rest = aREST();
 
 // WiFi settings:
 const char* ssid = "Your_SSID";
 const char* password = "Your_Password";
 
-#define LISTEN_PORT 80
-
-// Create an instance of the server
-WiFiServer server(LISTEN_PORT);
-
-// Variables to be exposed to the API
-float temperature;
-float humidity;
-
 
 //milli counter
 unsigned long millitotal = 0;
@@ -60,15 +46,6 @@ void setup() {
   //dht driver initialization
   dht.begin();
 
-  //Expose variables to the rest api
-  rest.variable("temperature", &temperature);
-  rest.variable("humidity", &humidity);
-
-  // Set a ID (ID must be greater than 0)
-  rest.set_id("1");
-  rest.set_name("sensornode");
-
-
   // Connect to WiFi
   Serial.println("Connecting to wlan");
   WiFi.begin(ssid, password);
@@ -78,19 +55,11 @@ void setup() {
   }
   Serial.println("\nWiFi connected");
 
-  // Start the server
-  server.begin();
-  Serial.println("Server started");
-
   // Print the IP address
   Serial.println(WiFi.localIP());
 }
 
 void loop() {
-  // Wait a few seconds between measurements.
-  millicounter = millis();
-  
-  if (millicounter >= millitotal) {
   // Reading temperature or humidity takes about 250 milliseconds!
   // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
   h = dht.readHumidity();
@@ -102,29 +71,18 @@ void loop() {
     Serial.println("Failed to read from DHT sensor!");
     return;
   } else {
-      //set the new values
-      humidity = h;
-      temperature = t;
+    // Initialize the client library
+    HTTPClient client;
+
+    // Make a HTTP request:
+    String url = "http://raspitemp:1337/abshum/" + String(t) + "/" + String(h);
+    client.begin(url);
+    client.GET();
+    client.end();
   }
 
-    //set new milli counter
-    //millis will overflow after approx. 52 days. To prevent errors we're checking the limits
-    if (millis() + (MEASURESECONDS * 1000) <= ULONG_MAX) {
-      millitotal = millis() + (MEASURESECONDS * 1000);
-    } else {
-      millitotal = 0;
-    }
-  }
-  // Handle REST calls
-  WiFiClient client = server.available();
-  if (!client) {
-    return;
-  }
-  while(!client.available()){
-    delay(1);
-  }
-  rest.handle(client);
-
+  //https://www.mikrocontroller.net/topic/384345
+  ESP.deepSleep(MEASURESECONDS * 1000000);
   //Let the esp chill a bit
   delay(100);
 }

Laravel/app/Console/Kernel.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace App\Console;
+
+use Illuminate\Console\Scheduling\Schedule;
+use Illuminate\Foundation\Console\Kernel as ConsoleKernel;
+
+class Kernel extends ConsoleKernel
+{
+    /**
+     * The Artisan commands provided by your application.
+     *
+     * @var array
+     */
+    protected $commands = [
+        //
+    ];
+
+    /**
+     * Define the application's command schedule.
+     *
+     * @param  \Illuminate\Console\Scheduling\Schedule  $schedule
+     * @return void
+     */
+    protected function schedule(Schedule $schedule)
+    {
+        // $schedule->command('inspire')
+        //          ->hourly();
+    }
+
+    /**
+     * Register the commands for the application.
+     *
+     * @return void
+     */
+    protected function commands()
+    {
+        $this->load(__DIR__.'/Commands');
+
+        require base_path('routes/console.php');
+    }
+}

Laravel/app/Exceptions/Handler.php

@@ -0,0 +1,53 @@
+<?php
+
+namespace App\Exceptions;
+
+use Exception;
+use Illuminate\Foundation\Exceptions\Handler as ExceptionHandler;
+
+class Handler extends ExceptionHandler
+{
+    /**
+     * A list of the exception types that are not reported.
+     *
+     * @var array
+     */
+    protected $dontReport = [
+        //
+    ];
+
+    /**
+     * A list of the inputs that are never flashed for validation exceptions.
+     *
+     * @var array
+     */
+    protected $dontFlash = [
+        'password',
+        'password_confirmation',
+    ];
+
+    /**
+     * Report or log an exception.
+     *
+     * This is a great spot to send exceptions to Sentry, Bugsnag, etc.
+     *
+     * @param  \Exception  $exception
+     * @return void
+     */
+    public function report(Exception $exception)
+    {
+        parent::report($exception);
+    }
+
+    /**
+     * Render an exception into an HTTP response.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Exception  $exception
+     * @return \Illuminate\Http\Response
+     */
+    public function render($request, Exception $exception)
+    {
+        return parent::render($request, $exception);
+    }
+}

Laravel/app/Http/Controllers/Auth/ForgotPasswordController.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Foundation\Auth\SendsPasswordResetEmails;
+
+class ForgotPasswordController extends Controller
+{
+    /*
+    |--------------------------------------------------------------------------
+    | Password Reset Controller
+    |--------------------------------------------------------------------------
+    |
+    | This controller is responsible for handling password reset emails and
+    | includes a trait which assists in sending these notifications from
+    | your application to your users. Feel free to explore this trait.
+    |
+    */
+
+    use SendsPasswordResetEmails;
+
+    /**
+     * Create a new controller instance.
+     *
+     * @return void
+     */
+    public function __construct()
+    {
+        $this->middleware('guest');
+    }
+}

Laravel/app/Http/Controllers/Auth/LoginController.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Foundation\Auth\AuthenticatesUsers;
+
+class LoginController extends Controller
+{
+    /*
+    |--------------------------------------------------------------------------
+    | Login Controller
+    |--------------------------------------------------------------------------
+    |
+    | This controller handles authenticating users for the application and
+    | redirecting them to your home screen. The controller uses a trait
+    | to conveniently provide its functionality to your applications.
+    |
+    */
+
+    use AuthenticatesUsers;
+
+    /**
+     * Where to redirect users after login.
+     *
+     * @var string
+     */
+    protected $redirectTo = '/home';
+
+    /**
+     * Create a new controller instance.
+     *
+     * @return void
+     */
+    public function __construct()
+    {
+        $this->middleware('guest')->except('logout');
+    }
+}

Laravel/app/Http/Controllers/Auth/RegisterController.php

@@ -0,0 +1,71 @@
+<?php
+
+namespace App\Http\Controllers\Auth;
+
+use App\User;
+use App\Http\Controllers\Controller;
+use Illuminate\Support\Facades\Validator;
+use Illuminate\Foundation\Auth\RegistersUsers;
+
+class RegisterController extends Controller
+{
+    /*
+    |--------------------------------------------------------------------------
+    | Register Controller
+    |--------------------------------------------------------------------------
+    |
+    | This controller handles the registration of new users as well as their
+    | validation and creation. By default this controller uses a trait to
+    | provide this functionality without requiring any additional code.
+    |
+    */
+
+    use RegistersUsers;
+
+    /**
+     * Where to redirect users after registration.
+     *
+     * @var string
+     */
+    protected $redirectTo = '/home';
+
+    /**
+     * Create a new controller instance.
+     *
+     * @return void
+     */
+    public function __construct()
+    {
+        $this->middleware('guest');
+    }
+
+    /**
+     * Get a validator for an incoming registration request.
+     *
+     * @param  array  $data
+     * @return \Illuminate\Contracts\Validation\Validator
+     */
+    protected function validator(array $data)
+    {
+        return Validator::make($data, [
+            'name' => 'required|string|max:255',
+            'email' => 'required|string|email|max:255|unique:users',
+            'password' => 'required|string|min:6|confirmed',
+        ]);
+    }
+
+    /**
+     * Create a new user instance after a valid registration.
+     *
+     * @param  array  $data
+     * @return \App\User
+     */
+    protected function create(array $data)
+    {
+        return User::create([
+            'name' => $data['name'],
+            'email' => $data['email'],
+            'password' => bcrypt($data['password']),
+        ]);
+    }
+}