thomas
/
ESP-Weather


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334
							#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <WiFiUdp.h>
#include <SHT21.h>
#include <vector>
#include <WebSocketServer.h>
#include <WiFiServer.h>
#include <EEPROM.h>
#include <DNSServer.h>
#include <WiFiManager.h>

#define NTP_PORT 2392
#define MAX_WAIT_TIME 550
#define EEPROM_SIZE 512

// NTP-Client
IPAddress timeServerIP; 
const char* ntpServerName = "time.nist.gov";
const int NTP_PACKET_SIZE = 48; 
byte ntpPacketBuffer[NTP_PACKET_SIZE]; 
WiFiUDP ntp;
unsigned long timestamp = 0;
unsigned long timeReceived = 0;
unsigned long lastStorageTime = 0;
byte storeAtBoot = 1;
unsigned long lastNTP = 0;

SHT21 SHT21;
ESP8266WebServer server(80);
WiFiServer serverSocket(2391);
WebSocketServer webSocketServer;

#define DEFAULT_SSID "ESP-Weather"
#define DEFAULT_PASS "testtest"

IPAddress broadcastIP;

struct __attribute__((__packed__)) Measurement {
    float temperature;
    float humidity;
};

struct __attribute__((__packed__)) Header {
    uint16_t count;
    uint16_t checksum;
};

#define MAX_STORAGE (EEPROM_SIZE - sizeof(Header)) / sizeof(Measurement)

struct __attribute__((__packed__)) PersistentStorage {
    Measurement data[MAX_STORAGE];
    Header header;
};

PersistentStorage storage;

void writeMemory(PersistentStorage &s) {
    Serial.println("write Memory");
    unsigned char* r = (unsigned char*) &s;
    uint16_t a = 0, b = 0;
    for (int i = 0; i < sizeof(PersistentStorage) - 2; i++) {
        a = (a + r[i]) % 255;
        b = (b + a) % 255;
    }
    s.header.checksum = (b << 8) | a;
    for (int i = 0; i < sizeof(PersistentStorage); i++) {
        EEPROM.write(i, r[i]);
    }
    EEPROM.commit();
}

PersistentStorage readMemory() {
    PersistentStorage s;
    unsigned char* r = (unsigned char*) &s;
    for (int i = 0; i < sizeof(PersistentStorage); i++) {
        r[i] = EEPROM.read(i);
    }
    uint16_t a = 0, b = 0;
    for (int i = 0; i < sizeof(PersistentStorage) - 2; i++) {
        a = (a + r[i]) % 255;
        b = (b + a) % 255;
    }
    if (s.header.checksum != ((b << 8) | a)) {
        Serial.print("Checksum error ");
        Serial.print(s.header.checksum);
        Serial.print(" ");
        Serial.println((b << 8) | a);
        s.header.count = 0;
    } else {
        Serial.println("Checksum ok");
    }
    return s;
}

std::vector<IPAddress> vecClients; 

// UDP-Config
unsigned int localPort = 2390;
char packetBuffer[255];                                       
char pingBuffer[] = "pingESP8266v0.1";
char echoBuffer[] = "echoESP8266v0.1";
WiFiUDP Udp;

unsigned long lastTime;
bool waitingForReplies = false;

const char* htmlBegin = "<html><head>\
<title>Sysadmin</title>\
<script src=\"http://hoegerle-home.de/sysAdmin/js/jquery-3.1.1.min.js\"></script>\
<script src=\"http://hoegerle-home.de/sysAdmin/js/bootstrap.min.js\"></script>\
<script src=\"http://hoegerle-home.de/sysAdmin/js/Chart.bundle.min.js\"></script>\
<script src=\"http://hoegerle-home.de/sysAdmin/js/script.js\"></script>\
<link rel=\"stylesheet\" href=\"http://hoegerle-home.de/sysAdmin/css/bootstrap.min.css\" />\
</head><body>\
<script type=\"text/javascript\">";
const char* htmlEnd = "</script></body></html>";

// root-URL
void handleRoot() {
    // send a reply, to the IP address and port that sent us the packet we received
    Udp.beginPacket(broadcastIP, 2390);
    Udp.write(pingBuffer);
    Udp.endPacket();

    // Timer starten
    lastTime = millis();
    waitingForReplies = true;

    Serial.println("Sending UDP Broadcast...");
}

// URL nicht vorhanden
void handleNotFound(){
    String message = "File Not Found\n\n";
    message += "URI: ";
    message += server.uri();
    message += "\nMethod: ";
    message += (server.method() == HTTP_GET)?"GET":"POST";
    message += "\nArguments: ";
    message += server.args();
    message += "\n";
    for (uint8_t i = 0; i < server.args(); i++){
        message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
    }
    server.send(404, "text/plain", message);
}

void setup(void) {
    EEPROM.begin(EEPROM_SIZE);

    // Debugging
    Serial.begin(115200);
    Serial.println();
    Serial.println("ESP-Weather init...");

    //SHT21.begin();
    // The SHT library is simpy calling Wire.begin(), but the default
    // config does not match the pins i'm using (sda - 2; scl - 0)
    Wire.begin(2, 0);

    WiFiManager wifiManager;
    // use one or the other, never both!
    wifiManager.autoConnect(DEFAULT_SSID, DEFAULT_PASS);
    //wifiManager.startConfigPortal(DEFAULT_SSID, DEFAULT_PASS);

    storage = readMemory();

    // Wait for connection
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Serial.println("");
    Serial.print("IP address: ");
    Serial.println(WiFi.localIP());

    broadcastIP = ~WiFi.subnetMask() | WiFi.gatewayIP();

    server.on("/", handleRoot);
    server.onNotFound(handleNotFound);
    server.begin();

    serverSocket.begin();

    // NTP-Client
    ntp.begin(NTP_PORT);
    WiFi.hostByName(ntpServerName, timeServerIP); 
    lastNTP = millis();
    sendNTPpacket(timeServerIP); 

    Udp.begin(localPort);
    Serial.println("ESP-Weather ready!");
}

void loop(void){
    server.handleClient();

    // Websocket fuer Browser
    WiFiClient client = serverSocket.available();
    if (client.connected() && webSocketServer.handshake(client)) {
        Serial.println("Building WebSocket Response...");

        String json = "{\"H\":";
        json += String(SHT21.getHumidity());
        json += ",";
        json += "\"T\":";
        json += String(SHT21.getTemperature());
        json += ", \"EEPROM\" : [";
        for (int i = 0; i < storage.header.count; i++) {
            json += "{\"H\":";
            json += String(storage.data[i].humidity);
            json += ",";
            json += "\"T\":";
            json += String(storage.data[i].temperature);
            json += "}";
            if (i < storage.header.count - 1) {
                json += ",";
            }
        }
        json += "]}";

        Serial.println("WebSocket Response:");
        Serial.println(json);

        webSocketServer.sendData(json);
        client.flush();
        client.stop();
    }

    // NTP wiederholen falls keine Antwort
    if ((timestamp == 0) && ((millis() - lastNTP) > 2000)) {
        Serial.println("NTP packet retry...");
        WiFi.hostByName(ntpServerName, timeServerIP);
        lastNTP = millis();
        sendNTPpacket(timeServerIP);
    }

    // NTP Paket vom Server erhalten
    if (ntp.parsePacket() >= NTP_PACKET_SIZE) {
        ntp.read(ntpPacketBuffer, NTP_PACKET_SIZE);
        unsigned long highWord = word(ntpPacketBuffer[40], ntpPacketBuffer[41]);
        unsigned long lowWord = word(ntpPacketBuffer[42], ntpPacketBuffer[43]);
        unsigned long secsSince1900 = highWord << 16 | lowWord;
        const unsigned long seventyYears = 2208988800UL;
        unsigned long epoch = secsSince1900 - seventyYears;
        timestamp = epoch;
        timeReceived = millis();
        Serial.print("Got NTP time: ");
        Serial.println(epoch);
    }

    // EEPROM-Schreiben jede Stunde
    if ((((((millis() - timeReceived) / 1000) + timestamp) % 3600) == 0)
            && (timestamp != 0) && (((millis() - lastStorageTime) > 100000) || storeAtBoot) ) {
        Serial.println("Storing new data packet...");
        lastStorageTime = millis();
        storeAtBoot = 0;
        if (storage.header.count < MAX_STORAGE) {
            storage.header.count++;
        } else {
            for(int i = 0; i < MAX_STORAGE - 1; i++) {
                storage.data[i] = storage.data[i+1];
            }
        }
        storage.data[storage.header.count - 1].temperature = SHT21.getTemperature();
        storage.data[storage.header.count - 1].humidity = SHT21.getHumidity();
        writeMemory(storage);
    }

    // UDP
    int packetSize = Udp.parsePacket();
    if (packetSize) {
        IPAddress remoteIp = Udp.remoteIP();
        // read the packet into packetBufffer
        int len = Udp.read(packetBuffer, 255);
        if (len > 0) {
            packetBuffer[len] = 0;
        }

        Serial.print("Got UDP packet: ");
        Serial.println(packetBuffer);

        if (strcmp(packetBuffer, pingBuffer) == 0) {
            Serial.println("Broadcast");
            Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
            Udp.print(echoBuffer);
            Udp.endPacket();
        } else if((strcmp(packetBuffer, echoBuffer) == 0) && (waitingForReplies == true)) {
            vecClients.push_back(Udp.remoteIP());
        }
    }

    if (((millis() - lastTime) >= MAX_WAIT_TIME) && (waitingForReplies == true)) {
        Serial.println("Timeout, sending response...");
        waitingForReplies = false;
        String message = htmlBegin;
        message += "var clients = Array(";
        message += "\"" + WiFi.localIP().toString() + "\"";
        if (vecClients.size() > 0) {
            message += ", ";
        }
        for (int i = 0; i < vecClients.size(); i++) {
            message += "\"" + vecClients[i].toString() + "\"";
            if (i < (vecClients.size() - 1)) {
                message += ", ";
            }
        }
        message += ");";
        message += htmlEnd;

        vecClients.clear();

        server.send(200, "text/html", message);
    }
}

void sendNTPpacket(IPAddress& address) {
    Serial.println("Sending NTP packet...");
    memset(ntpPacketBuffer, 0, NTP_PACKET_SIZE);
    ntpPacketBuffer[0] = 0b11100011; // LI, Version, Mode
    ntpPacketBuffer[1] = 0;
    ntpPacketBuffer[2] = 6;
    ntpPacketBuffer[3] = 0xEC;
    ntpPacketBuffer[12]  = 49;
    ntpPacketBuffer[13]  = 0x4E;
    ntpPacketBuffer[14]  = 49;
    ntpPacketBuffer[15]  = 52;

    ntp.beginPacket(address, 123);
    ntp.write(ntpPacketBuffer, NTP_PACKET_SIZE);
    ntp.endPacket();
}