Current version from old git. Release 0.0.9

src/lib/PubSubClient/src/PubSubClient.cpp

+/*
+
+  PubSubClient.cpp - A simple client for MQTT.
+  Nick O'Leary
+  http://knolleary.net
+*/
+
+#include "PubSubClient.h"
+#include "Arduino.h"
+
+PubSubClient::PubSubClient() {
+    this->_state = MQTT_DISCONNECTED;
+    this->_client = NULL;
+    this->stream = NULL;
+    setCallback(NULL);
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+
+PubSubClient::PubSubClient(Client& client) {
+    this->_state = MQTT_DISCONNECTED;
+    setClient(client);
+    this->stream = NULL;
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+
+PubSubClient::PubSubClient(IPAddress addr, uint16_t port, Client& client) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(addr, port);
+    setClient(client);
+    this->stream = NULL;
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(IPAddress addr, uint16_t port, Client& client, Stream& stream) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(addr,port);
+    setClient(client);
+    setStream(stream);
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(IPAddress addr, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(addr, port);
+    setCallback(callback);
+    setClient(client);
+    this->stream = NULL;
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(IPAddress addr, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client, Stream& stream) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(addr,port);
+    setCallback(callback);
+    setClient(client);
+    setStream(stream);
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+
+PubSubClient::PubSubClient(uint8_t *ip, uint16_t port, Client& client) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(ip, port);
+    setClient(client);
+    this->stream = NULL;
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(uint8_t *ip, uint16_t port, Client& client, Stream& stream) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(ip,port);
+    setClient(client);
+    setStream(stream);
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(uint8_t *ip, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(ip, port);
+    setCallback(callback);
+    setClient(client);
+    this->stream = NULL;
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(uint8_t *ip, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client, Stream& stream) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(ip,port);
+    setCallback(callback);
+    setClient(client);
+    setStream(stream);
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+
+PubSubClient::PubSubClient(const char* domain, uint16_t port, Client& client) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(domain,port);
+    setClient(client);
+    this->stream = NULL;
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(const char* domain, uint16_t port, Client& client, Stream& stream) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(domain,port);
+    setClient(client);
+    setStream(stream);
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(const char* domain, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(domain,port);
+    setCallback(callback);
+    setClient(client);
+    this->stream = NULL;
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(const char* domain, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client, Stream& stream) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(domain,port);
+    setCallback(callback);
+    setClient(client);
+    setStream(stream);
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+
+PubSubClient::~PubSubClient() {
+  free(this->buffer);
+}
+
+boolean PubSubClient::connect(const char *id) {
+    return connect(id,NULL,NULL,0,0,0,0,1);
+}
+
+boolean PubSubClient::connect(const char *id, const char *user, const char *pass) {
+    return connect(id,user,pass,0,0,0,0,1);
+}
+
+boolean PubSubClient::connect(const char *id, const char* willTopic, uint8_t willQos, boolean willRetain, const char* willMessage) {
+    return connect(id,NULL,NULL,willTopic,willQos,willRetain,willMessage,1);
+}
+
+boolean PubSubClient::connect(const char *id, const char *user, const char *pass, const char* willTopic, uint8_t willQos, boolean willRetain, const char* willMessage) {
+    return connect(id,user,pass,willTopic,willQos,willRetain,willMessage,1);
+}
+
+boolean PubSubClient::connect(const char *id, const char *user, const char *pass, const char* willTopic, uint8_t willQos, boolean willRetain, const char* willMessage, boolean cleanSession) {
+    if (!connected()) {
+        int result = 0;
+
+
+        if(_client->connected()) {
+            result = 1;
+        } else {
+            if (domain != NULL) {
+                result = _client->connect(this->domain, this->port);
+            } else {
+                result = _client->connect(this->ip, this->port);
+            }
+        }
+
+        if (result == 1) {
+            nextMsgId = 1;
+            // Leave room in the buffer for header and variable length field
+            uint16_t length = MQTT_MAX_HEADER_SIZE;
+            unsigned int j;
+
+#if MQTT_VERSION == MQTT_VERSION_3_1
+            uint8_t d[9] = {0x00,0x06,'M','Q','I','s','d','p', MQTT_VERSION};
+#define MQTT_HEADER_VERSION_LENGTH 9
+#elif MQTT_VERSION == MQTT_VERSION_3_1_1
+            uint8_t d[7] = {0x00,0x04,'M','Q','T','T',MQTT_VERSION};
+#define MQTT_HEADER_VERSION_LENGTH 7
+#endif
+            for (j = 0;j<MQTT_HEADER_VERSION_LENGTH;j++) {
+                this->buffer[length++] = d[j];
+            }
+
+            uint8_t v;
+            if (willTopic) {
+                v = 0x04|(willQos<<3)|(willRetain<<5);
+            } else {
+                v = 0x00;
+            }
+            if (cleanSession) {
+                v = v|0x02;
+            }
+
+            if(user != NULL) {
+                v = v|0x80;
+
+                if(pass != NULL) {
+                    v = v|(0x80>>1);
+                }
+            }
+            this->buffer[length++] = v;
+
+            this->buffer[length++] = ((this->keepAlive) >> 8);
+            this->buffer[length++] = ((this->keepAlive) & 0xFF);
+
+            CHECK_STRING_LENGTH(length,id)
+            length = writeString(id,this->buffer,length);
+            if (willTopic) {
+                CHECK_STRING_LENGTH(length,willTopic)
+                length = writeString(willTopic,this->buffer,length);
+                CHECK_STRING_LENGTH(length,willMessage)
+                length = writeString(willMessage,this->buffer,length);
+            }
+
+            if(user != NULL) {
+                CHECK_STRING_LENGTH(length,user)
+                length = writeString(user,this->buffer,length);
+                if(pass != NULL) {
+                    CHECK_STRING_LENGTH(length,pass)
+                    length = writeString(pass,this->buffer,length);
+                }
+            }
+
+            write(MQTTCONNECT,this->buffer,length-MQTT_MAX_HEADER_SIZE);
+
+            lastInActivity = lastOutActivity = millis();
+
+            while (!_client->available()) {
+                unsigned long t = millis();
+                if (t-lastInActivity >= ((int32_t) this->socketTimeout*1000UL)) {
+                    _state = MQTT_CONNECTION_TIMEOUT;
+                    _client->stop();
+                    return false;
+                }
+            }
+            uint8_t llen;
+            uint32_t len = readPacket(&llen);
+
+            if (len == 4) {
+                if (buffer[3] == 0) {
+                    lastInActivity = millis();
+                    pingOutstanding = false;
+                    _state = MQTT_CONNECTED;
+                    return true;
+                } else {
+                    _state = buffer[3];
+                }
+            }
+            _client->stop();
+        } else {
+            _state = MQTT_CONNECT_FAILED;
+        }
+        return false;
+    }
+    return true;
+}
+
+// reads a byte into result
+boolean PubSubClient::readByte(uint8_t * result) {
+   uint32_t previousMillis = millis();
+   while(!_client->available()) {
+     yield();
+     uint32_t currentMillis = millis();
+     if(currentMillis - previousMillis >= ((int32_t) this->socketTimeout * 1000)){
+       return false;
+     }
+   }
+   *result = _client->read();
+   return true;
+}
+
+// reads a byte into result[*index] and increments index
+boolean PubSubClient::readByte(uint8_t * result, uint16_t * index){
+  uint16_t current_index = *index;
+  uint8_t * write_address = &(result[current_index]);
+  if(readByte(write_address)){
+    *index = current_index + 1;
+    return true;
+  }
+  return false;
+}
+
+uint32_t PubSubClient::readPacket(uint8_t* lengthLength) {
+    uint16_t len = 0;
+    if(!readByte(this->buffer, &len)) return 0;
+    bool isPublish = (this->buffer[0]&0xF0) == MQTTPUBLISH;
+    uint32_t multiplier = 1;
+    uint32_t length = 0;
+    uint8_t digit = 0;
+    uint16_t skip = 0;
+    uint32_t start = 0;
+
+    do {
+        if (len == 5) {
+            // Invalid remaining length encoding - kill the connection
+            _state = MQTT_DISCONNECTED;
+            _client->stop();
+            return 0;
+        }
+        if(!readByte(&digit)) return 0;
+        this->buffer[len++] = digit;
+        length += (digit & 127) * multiplier;
+        multiplier <<=7; //multiplier *= 128
+    } while ((digit & 128) != 0);
+    *lengthLength = len-1;
+
+    if (isPublish) {
+        // Read in topic length to calculate bytes to skip over for Stream writing
+        if(!readByte(this->buffer, &len)) return 0;
+        if(!readByte(this->buffer, &len)) return 0;
+        skip = (this->buffer[*lengthLength+1]<<8)+this->buffer[*lengthLength+2];
+        start = 2;
+        if (this->buffer[0]&MQTTQOS1) {
+            // skip message id
+            skip += 2;
+        }
+    }
+    uint32_t idx = len;
+
+    for (uint32_t i = start;i<length;i++) {
+        if(!readByte(&digit)) return 0;
+        if (this->stream) {
+            if (isPublish && idx-*lengthLength-2>skip) {
+                this->stream->write(digit);
+            }
+        }
+
+        if (len < this->bufferSize) {
+            this->buffer[len] = digit;
+            len++;
+        }
+        idx++;
+    }
+
+    if (!this->stream && idx > this->bufferSize) {
+        len = 0; // This will cause the packet to be ignored.
+    }
+    return len;
+}
+
+boolean PubSubClient::loop() {
+    if (connected()) {
+        unsigned long t = millis();
+        if ((t - lastInActivity > this->keepAlive*1000UL) || (t - lastOutActivity > this->keepAlive*1000UL)) {
+            if (pingOutstanding) {
+                this->_state = MQTT_CONNECTION_TIMEOUT;
+                _client->stop();
+                return false;
+            } else {
+                this->buffer[0] = MQTTPINGREQ;
+                this->buffer[1] = 0;
+                _client->write(this->buffer,2);
+                lastOutActivity = t;
+                lastInActivity = t;
+                pingOutstanding = true;
+            }
+        }
+        if (_client->available()) {
+            uint8_t llen;
+            uint16_t len = readPacket(&llen);
+            uint16_t msgId = 0;
+            uint8_t *payload;
+            if (len > 0) {
+                lastInActivity = t;
+                uint8_t type = this->buffer[0]&0xF0;
+                if (type == MQTTPUBLISH) {
+                    if (callback) {
+                        uint16_t tl = (this->buffer[llen+1]<<8)+this->buffer[llen+2]; /* topic length in bytes */
+                        memmove(this->buffer+llen+2,this->buffer+llen+3,tl); /* move topic inside buffer 1 byte to front */
+                        this->buffer[llen+2+tl] = 0; /* end the topic as a 'C' string with \x00 */
+                        char *topic = (char*) this->buffer+llen+2;
+                        // msgId only present for QOS>0
+                        if ((this->buffer[0]&0x06) == MQTTQOS1) {
+                            msgId = (this->buffer[llen+3+tl]<<8)+this->buffer[llen+3+tl+1];
+                            payload = this->buffer+llen+3+tl+2;
+                            callback(topic,payload,len-llen-3-tl-2);
+
+                            this->buffer[0] = MQTTPUBACK;
+                            this->buffer[1] = 2;
+                            this->buffer[2] = (msgId >> 8);
+                            this->buffer[3] = (msgId & 0xFF);
+                            _client->write(this->buffer,4);
+                            lastOutActivity = t;
+
+                        } else {
+                            payload = this->buffer+llen+3+tl;
+                            callback(topic,payload,len-llen-3-tl);
+                        }
+                    }
+                } else if (type == MQTTPINGREQ) {
+                    this->buffer[0] = MQTTPINGRESP;
+                    this->buffer[1] = 0;
+                    _client->write(this->buffer,2);
+                } else if (type == MQTTPINGRESP) {
+                    pingOutstanding = false;
+                }
+            } else if (!connected()) {
+                // readPacket has closed the connection
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+boolean PubSubClient::publish(const char* topic, const char* payload) {
+    return publish(topic,(const uint8_t*)payload, payload ? strnlen(payload, this->bufferSize) : 0,false);
+}
+
+boolean PubSubClient::publish(const char* topic, const char* payload, boolean retained) {
+    return publish(topic,(const uint8_t*)payload, payload ? strnlen(payload, this->bufferSize) : 0,retained);
+}
+
+boolean PubSubClient::publish(const char* topic, const uint8_t* payload, unsigned int plength) {
+    return publish(topic, payload, plength, false);
+}
+
+boolean PubSubClient::publish(const char* topic, const uint8_t* payload, unsigned int plength, boolean retained) {
+    if (connected()) {
+        if (this->bufferSize < MQTT_MAX_HEADER_SIZE + 2+strnlen(topic, this->bufferSize) + plength) {
+            // Too long
+            return false;
+        }
+        // Leave room in the buffer for header and variable length field
+        uint16_t length = MQTT_MAX_HEADER_SIZE;
+        length = writeString(topic,this->buffer,length);
+
+        // Add payload
+        uint16_t i;
+        for (i=0;i<plength;i++) {
+            this->buffer[length++] = payload[i];
+        }
+
+        // Write the header
+        uint8_t header = MQTTPUBLISH;
+        if (retained) {
+            header |= 1;
+        }
+        return write(header,this->buffer,length-MQTT_MAX_HEADER_SIZE);
+    }
+    return false;
+}
+
+boolean PubSubClient::publish_P(const char* topic, const char* payload, boolean retained) {
+    return publish_P(topic, (const uint8_t*)payload, payload ? strnlen(payload, this->bufferSize) : 0, retained);
+}
+
+boolean PubSubClient::publish_P(const char* topic, const uint8_t* payload, unsigned int plength, boolean retained) {
+    uint8_t llen = 0;
+    uint8_t digit;
+    unsigned int rc = 0;
+    uint16_t tlen;
+    unsigned int pos = 0;
+    unsigned int i;
+    uint8_t header;
+    unsigned int len;
+    int expectedLength;
+
+    if (!connected()) {
+        return false;
+    }
+
+    tlen = strnlen(topic, this->bufferSize);
+
+    header = MQTTPUBLISH;
+    if (retained) {
+        header |= 1;
+    }
+    this->buffer[pos++] = header;
+    len = plength + 2 + tlen;
+    do {
+        digit = len  & 127; //digit = len %128
+        len >>= 7; //len = len / 128
+        if (len > 0) {
+            digit |= 0x80;
+        }
+        this->buffer[pos++] = digit;
+        llen++;
+    } while(len>0);
+
+    pos = writeString(topic,this->buffer,pos);
+
+    rc += _client->write(this->buffer,pos);
+
+    for (i=0;i<plength;i++) {
+        rc += _client->write((char)pgm_read_byte_near(payload + i));
+    }
+
+    lastOutActivity = millis();
+
+    expectedLength = 1 + llen + 2 + tlen + plength;
+
+    return (rc == expectedLength);
+}
+
+boolean PubSubClient::beginPublish(const char* topic, unsigned int plength, boolean retained) {
+    if (connected()) {
+        // Send the header and variable length field
+        uint16_t length = MQTT_MAX_HEADER_SIZE;
+        length = writeString(topic,this->buffer,length);
+        uint8_t header = MQTTPUBLISH;
+        if (retained) {
+            header |= 1;
+        }
+        size_t hlen = buildHeader(header, this->buffer, plength+length-MQTT_MAX_HEADER_SIZE);
+        uint16_t rc = _client->write(this->buffer+(MQTT_MAX_HEADER_SIZE-hlen),length-(MQTT_MAX_HEADER_SIZE-hlen));
+        lastOutActivity = millis();
+        return (rc == (length-(MQTT_MAX_HEADER_SIZE-hlen)));
+    }
+    return false;
+}
+
+int PubSubClient::endPublish() {
+ return 1;
+}
+
+size_t PubSubClient::write(uint8_t data) {
+    lastOutActivity = millis();
+    return _client->write(data);
+}
+
+size_t PubSubClient::write(const uint8_t *buffer, size_t size) {
+    lastOutActivity = millis();
+    return _client->write(buffer,size);
+}
+
+size_t PubSubClient::buildHeader(uint8_t header, uint8_t* buf, uint16_t length) {
+    uint8_t lenBuf[4];
+    uint8_t llen = 0;
+    uint8_t digit;
+    uint8_t pos = 0;
+    uint16_t len = length;
+    do {
+
+        digit = len  & 127; //digit = len %128
+        len >>= 7; //len = len / 128
+        if (len > 0) {
+            digit |= 0x80;
+        }
+        lenBuf[pos++] = digit;
+        llen++;
+    } while(len>0);
+
+    buf[4-llen] = header;
+    for (int i=0;i<llen;i++) {
+        buf[MQTT_MAX_HEADER_SIZE-llen+i] = lenBuf[i];
+    }
+    return llen+1; // Full header size is variable length bit plus the 1-byte fixed header
+}
+
+boolean PubSubClient::write(uint8_t header, uint8_t* buf, uint16_t length) {
+    uint16_t rc;
+    uint8_t hlen = buildHeader(header, buf, length);
+
+#ifdef MQTT_MAX_TRANSFER_SIZE
+    uint8_t* writeBuf = buf+(MQTT_MAX_HEADER_SIZE-hlen);
+    uint16_t bytesRemaining = length+hlen;  //Match the length type
+    uint8_t bytesToWrite;
+    boolean result = true;
+    while((bytesRemaining > 0) && result) {
+        bytesToWrite = (bytesRemaining > MQTT_MAX_TRANSFER_SIZE)?MQTT_MAX_TRANSFER_SIZE:bytesRemaining;
+        rc = _client->write(writeBuf,bytesToWrite);
+        result = (rc == bytesToWrite);
+        bytesRemaining -= rc;
+        writeBuf += rc;
+    }
+    return result;
+#else
+    rc = _client->write(buf+(MQTT_MAX_HEADER_SIZE-hlen),length+hlen);
+    lastOutActivity = millis();
+    return (rc == hlen+length);
+#endif
+}
+
+boolean PubSubClient::subscribe(const char* topic) {
+    return subscribe(topic, 0);
+}
+
+boolean PubSubClient::subscribe(const char* topic, uint8_t qos) {
+    size_t topicLength = strnlen(topic, this->bufferSize);
+    if (topic == 0) {
+        return false;
+    }
+    if (qos > 1) {
+        return false;
+    }
+    if (this->bufferSize < 9 + topicLength) {
+        // Too long
+        return false;
+    }
+    if (connected()) {
+        // Leave room in the buffer for header and variable length field
+        uint16_t length = MQTT_MAX_HEADER_SIZE;
+        nextMsgId++;
+        if (nextMsgId == 0) {
+            nextMsgId = 1;
+        }
+        this->buffer[length++] = (nextMsgId >> 8);
+        this->buffer[length++] = (nextMsgId & 0xFF);
+        length = writeString((char*)topic, this->buffer,length);
+        this->buffer[length++] = qos;
+        return write(MQTTSUBSCRIBE|MQTTQOS1,this->buffer,length-MQTT_MAX_HEADER_SIZE);
+    }
+    return false;
+}
+
+boolean PubSubClient::unsubscribe(const char* topic) {
+	size_t topicLength = strnlen(topic, this->bufferSize);
+    if (topic == 0) {
+        return false;
+    }
+    if (this->bufferSize < 9 + topicLength) {
+        // Too long
+        return false;
+    }
+    if (connected()) {
+        uint16_t length = MQTT_MAX_HEADER_SIZE;
+        nextMsgId++;
+        if (nextMsgId == 0) {
+            nextMsgId = 1;
+        }
+        this->buffer[length++] = (nextMsgId >> 8);
+        this->buffer[length++] = (nextMsgId & 0xFF);
+        length = writeString(topic, this->buffer,length);
+        return write(MQTTUNSUBSCRIBE|MQTTQOS1,this->buffer,length-MQTT_MAX_HEADER_SIZE);
+    }
+    return false;
+}
+
+void PubSubClient::disconnect() {
+    this->buffer[0] = MQTTDISCONNECT;
+    this->buffer[1] = 0;
+    _client->write(this->buffer,2);
+    _state = MQTT_DISCONNECTED;
+    _client->flush();
+    _client->stop();
+    lastInActivity = lastOutActivity = millis();
+}
+
+uint16_t PubSubClient::writeString(const char* string, uint8_t* buf, uint16_t pos) {
+    const char* idp = string;
+    uint16_t i = 0;
+    pos += 2;
+    while (*idp) {
+        buf[pos++] = *idp++;
+        i++;
+    }
+    buf[pos-i-2] = (i >> 8);
+    buf[pos-i-1] = (i & 0xFF);
+    return pos;
+}
+
+
+boolean PubSubClient::connected() {
+    boolean rc;
+    if (_client == NULL ) {
+        rc = false;
+    } else {
+        rc = (int)_client->connected();
+        if (!rc) {
+            if (this->_state == MQTT_CONNECTED) {
+                this->_state = MQTT_CONNECTION_LOST;
+                _client->flush();
+                _client->stop();
+            }
+        } else {
+            return this->_state == MQTT_CONNECTED;
+        }
+    }
+    return rc;
+}
+
+PubSubClient& PubSubClient::setServer(uint8_t * ip, uint16_t port) {
+    IPAddress addr(ip[0],ip[1],ip[2],ip[3]);
+    return setServer(addr,port);
+}
+
+PubSubClient& PubSubClient::setServer(IPAddress ip, uint16_t port) {
+    this->ip = ip;
+    this->port = port;
+    this->domain = NULL;
+    return *this;
+}
+
+PubSubClient& PubSubClient::setServer(const char * domain, uint16_t port) {
+    this->domain = domain;
+    this->port = port;
+    return *this;
+}
+
+PubSubClient& PubSubClient::setCallback(MQTT_CALLBACK_SIGNATURE) {
+    this->callback = callback;
+    return *this;
+}
+
+PubSubClient& PubSubClient::setClient(Client& client){
+    this->_client = &client;
+    return *this;
+}
+
+PubSubClient& PubSubClient::setStream(Stream& stream){
+    this->stream = &stream;
+    return *this;
+}
+
+int PubSubClient::state() {
+    return this->_state;
+}
+
+boolean PubSubClient::setBufferSize(uint16_t size) {
+    if (size == 0) {
+        // Cannot set it back to 0
+        return false;
+    }
+    if (this->bufferSize == 0) {
+        this->buffer = (uint8_t*)malloc(size);
+    } else {
+        uint8_t* newBuffer = (uint8_t*)realloc(this->buffer, size);
+        if (newBuffer != NULL) {
+            this->buffer = newBuffer;
+        } else {
+            return false;
+        }
+    }
+    this->bufferSize = size;
+    return (this->buffer != NULL);
+}
+
+uint16_t PubSubClient::getBufferSize() {
+    return this->bufferSize;
+}
+PubSubClient& PubSubClient::setKeepAlive(uint16_t keepAlive) {
+    this->keepAlive = keepAlive;
+    return *this;
+}
+PubSubClient& PubSubClient::setSocketTimeout(uint16_t timeout) {
+    this->socketTimeout = timeout;
+    return *this;
+}

src/lib/PubSubClient/src/PubSubClient.h

+/*
+ PubSubClient.h - A simple client for MQTT.
+  Nick O'Leary
+  http://knolleary.net
+*/
+
+#ifndef PubSubClient_h
+#define PubSubClient_h
+
+#include <Arduino.h>
+#include "IPAddress.h"
+#include "Client.h"
+#include "Stream.h"
+
+#define MQTT_VERSION_3_1      3
+#define MQTT_VERSION_3_1_1    4
+
+// MQTT_VERSION : Pick the version
+//#define MQTT_VERSION MQTT_VERSION_3_1
+#ifndef MQTT_VERSION
+#define MQTT_VERSION MQTT_VERSION_3_1_1
+#endif
+
+// MQTT_MAX_PACKET_SIZE : Maximum packet size. Override with setBufferSize().
+#ifndef MQTT_MAX_PACKET_SIZE
+#define MQTT_MAX_PACKET_SIZE 256
+#endif
+
+// MQTT_KEEPALIVE : keepAlive interval in Seconds. Override with setKeepAlive()
+#ifndef MQTT_KEEPALIVE
+#define MQTT_KEEPALIVE 15
+#endif
+
+// MQTT_SOCKET_TIMEOUT: socket timeout interval in Seconds. Override with setSocketTimeout()
+#ifndef MQTT_SOCKET_TIMEOUT
+#define MQTT_SOCKET_TIMEOUT 15
+#endif
+
+// MQTT_MAX_TRANSFER_SIZE : limit how much data is passed to the network client
+//  in each write call. Needed for the Arduino Wifi Shield. Leave undefined to
+//  pass the entire MQTT packet in each write call.
+//#define MQTT_MAX_TRANSFER_SIZE 80
+
+// Possible values for client.state()
+#define MQTT_CONNECTION_TIMEOUT     -4
+#define MQTT_CONNECTION_LOST        -3
+#define MQTT_CONNECT_FAILED         -2
+#define MQTT_DISCONNECTED           -1
+#define MQTT_CONNECTED               0
+#define MQTT_CONNECT_BAD_PROTOCOL    1
+#define MQTT_CONNECT_BAD_CLIENT_ID   2
+#define MQTT_CONNECT_UNAVAILABLE     3
+#define MQTT_CONNECT_BAD_CREDENTIALS 4
+#define MQTT_CONNECT_UNAUTHORIZED    5
+
+#define MQTTCONNECT     1 << 4  // Client request to connect to Server
+#define MQTTCONNACK     2 << 4  // Connect Acknowledgment
+#define MQTTPUBLISH     3 << 4  // Publish message
+#define MQTTPUBACK      4 << 4  // Publish Acknowledgment
+#define MQTTPUBREC      5 << 4  // Publish Received (assured delivery part 1)
+#define MQTTPUBREL      6 << 4  // Publish Release (assured delivery part 2)
+#define MQTTPUBCOMP     7 << 4  // Publish Complete (assured delivery part 3)
+#define MQTTSUBSCRIBE   8 << 4  // Client Subscribe request
+#define MQTTSUBACK      9 << 4  // Subscribe Acknowledgment
+#define MQTTUNSUBSCRIBE 10 << 4 // Client Unsubscribe request
+#define MQTTUNSUBACK    11 << 4 // Unsubscribe Acknowledgment
+#define MQTTPINGREQ     12 << 4 // PING Request
+#define MQTTPINGRESP    13 << 4 // PING Response
+#define MQTTDISCONNECT  14 << 4 // Client is Disconnecting
+#define MQTTReserved    15 << 4 // Reserved
+
+#define MQTTQOS0        (0 << 1)
+#define MQTTQOS1        (1 << 1)
+#define MQTTQOS2        (2 << 1)
+
+// Maximum size of fixed header and variable length size header
+#define MQTT_MAX_HEADER_SIZE 5
+
+#if defined(ESP8266) || defined(ESP32)
+#include <functional>
+#define MQTT_CALLBACK_SIGNATURE std::function<void(char*, uint8_t*, unsigned int)> callback
+#else
+#define MQTT_CALLBACK_SIGNATURE void (*callback)(char*, uint8_t*, unsigned int)
+#endif
+
+#define CHECK_STRING_LENGTH(l,s) if (l+2+strnlen(s, this->bufferSize) > this->bufferSize) {_client->stop();return false;}
+
+class PubSubClient : public Print {
+private:
+   Client* _client;
+   uint8_t* buffer;
+   uint16_t bufferSize;
+   uint16_t keepAlive;
+   uint16_t socketTimeout;
+   uint16_t nextMsgId;
+   unsigned long lastOutActivity;
+   unsigned long lastInActivity;
+   bool pingOutstanding;
+   MQTT_CALLBACK_SIGNATURE;
+   uint32_t readPacket(uint8_t*);
+   boolean readByte(uint8_t * result);
+   boolean readByte(uint8_t * result, uint16_t * index);
+   boolean write(uint8_t header, uint8_t* buf, uint16_t length);
+   uint16_t writeString(const char* string, uint8_t* buf, uint16_t pos);
+   // Build up the header ready to send
+   // Returns the size of the header
+   // Note: the header is built at the end of the first MQTT_MAX_HEADER_SIZE bytes, so will start
+   //       (MQTT_MAX_HEADER_SIZE - <returned size>) bytes into the buffer
+   size_t buildHeader(uint8_t header, uint8_t* buf, uint16_t length);
+   IPAddress ip;
+   const char* domain;
+   uint16_t port;
+   Stream* stream;
+   int _state;
+public:
+   PubSubClient();
+   PubSubClient(Client& client);
+   PubSubClient(IPAddress, uint16_t, Client& client);
+   PubSubClient(IPAddress, uint16_t, Client& client, Stream&);
+   PubSubClient(IPAddress, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client);
+   PubSubClient(IPAddress, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client, Stream&);
+   PubSubClient(uint8_t *, uint16_t, Client& client);
+   PubSubClient(uint8_t *, uint16_t, Client& client, Stream&);
+   PubSubClient(uint8_t *, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client);
+   PubSubClient(uint8_t *, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client, Stream&);
+   PubSubClient(const char*, uint16_t, Client& client);
+   PubSubClient(const char*, uint16_t, Client& client, Stream&);
+   PubSubClient(const char*, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client);
+   PubSubClient(const char*, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client, Stream&);
+
+   ~PubSubClient();
+
+   PubSubClient& setServer(IPAddress ip, uint16_t port);
+   PubSubClient& setServer(uint8_t * ip, uint16_t port);
+   PubSubClient& setServer(const char * domain, uint16_t port);
+   PubSubClient& setCallback(MQTT_CALLBACK_SIGNATURE);
+   PubSubClient& setClient(Client& client);
+   PubSubClient& setStream(Stream& stream);
+   PubSubClient& setKeepAlive(uint16_t keepAlive);
+   PubSubClient& setSocketTimeout(uint16_t timeout);
+
+   boolean setBufferSize(uint16_t size);
+   uint16_t getBufferSize();
+
+   boolean connect(const char* id);
+   boolean connect(const char* id, const char* user, const char* pass);
+   boolean connect(const char* id, const char* willTopic, uint8_t willQos, boolean willRetain, const char* willMessage);
+   boolean connect(const char* id, const char* user, const char* pass, const char* willTopic, uint8_t willQos, boolean willRetain, const char* willMessage);
+   boolean connect(const char* id, const char* user, const char* pass, const char* willTopic, uint8_t willQos, boolean willRetain, const char* willMessage, boolean cleanSession);
+   void disconnect();
+   boolean publish(const char* topic, const char* payload);
+   boolean publish(const char* topic, const char* payload, boolean retained);
+   boolean publish(const char* topic, const uint8_t * payload, unsigned int plength);
+   boolean publish(const char* topic, const uint8_t * payload, unsigned int plength, boolean retained);
+   boolean publish_P(const char* topic, const char* payload, boolean retained);
+   boolean publish_P(const char* topic, const uint8_t * payload, unsigned int plength, boolean retained);
+   // Start to publish a message.
+   // This API:
+   //   beginPublish(...)
+   //   one or more calls to write(...)
+   //   endPublish()
+   // Allows for arbitrarily large payloads to be sent without them having to be copied into
+   // a new buffer and held in memory at one time
+   // Returns 1 if the message was started successfully, 0 if there was an error
+   boolean beginPublish(const char* topic, unsigned int plength, boolean retained);
+   // Finish off this publish message (started with beginPublish)
+   // Returns 1 if the packet was sent successfully, 0 if there was an error
+   int endPublish();
+   // Write a single byte of payload (only to be used with beginPublish/endPublish)
+   virtual size_t write(uint8_t);
+   // Write size bytes from buffer into the payload (only to be used with beginPublish/endPublish)
+   // Returns the number of bytes written
+   virtual size_t write(const uint8_t *buffer, size_t size);
+   boolean subscribe(const char* topic);
+   boolean subscribe(const char* topic, uint8_t qos);
+   boolean unsubscribe(const char* topic);
+   boolean loop();
+   boolean connected();
+   int state();
+
+};
+
+
+#endif

src/lib/SparkFun_SCD30_Arduino_Library/LICENSE.md

+SparkFun License Information
+============================
+
+SparkFun uses two different licenses for our files — one for hardware and one for code.
+
+Hardware
+---------
+
+**SparkFun hardware is released under [Creative Commons Share-alike 4.0 International](http://creativecommons.org/licenses/by-sa/4.0/).**
+
+Note: This is a human-readable summary of (and not a substitute for) the [license](http://creativecommons.org/licenses/by-sa/4.0/legalcode).
+
+You are free to:
+
+Share — copy and redistribute the material in any medium or format
+Adapt — remix, transform, and build upon the material
+for any purpose, even commercially.
+The licensor cannot revoke these freedoms as long as you follow the license terms.
+Under the following terms:
+
+Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
+ShareAlike — If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original.
+No additional restrictions — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.
+Notices:
+
+You do not have to comply with the license for elements of the material in the public domain or where your use is permitted by an applicable exception or limitation.
+No warranties are given. The license may not give you all of the permissions necessary for your intended use. For example, other rights such as publicity, privacy, or moral rights may limit how you use the material.
+
+
+Code
+--------
+
+**SparkFun code, firmware, and software is released under the MIT License(http://opensource.org/licenses/MIT).**
+
+The MIT License (MIT)
+
+Copyright (c) 2016 SparkFun Electronics
+
+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.

src/lib/SparkFun_SCD30_Arduino_Library/README.md

+SparkFun SCD30 CO2 Sensor Library
+===========================================================
+
+![SparkFun SCD30 CO2 Sensor](https://cdn.sparkfun.com//assets/parts/1/2/9/8/4/SparkFun_Sensirion_SCD30.jpg)
+
+[*SparkX CO₂ Humidity and Temperature Sensor - SCD30 (SPX-14751)*](https://www.sparkfun.com/products/14751)
+
+The SCD30 from Sensirion is a high quality [NDIR](https://en.wikipedia.org/wiki/Nondispersive_infrared_sensor) based CO₂ sensor capable of detecting 400 to 10000ppm with an accuracy of ±(30ppm+3%). In order to improve accuracy the SCD30 has temperature and humidity sensing built-in, as well as commands to set the current altitude.
+
+We've written an Arduino library to make reading the CO₂, humidity, and temperature very easy. It can be downloaded through the Arduino Library manager: search for 'SparkFun SCD30'. We recommend using a [Qwiic Breadboard Cable](https://www.sparkfun.com/products/14425) to connect the SCD30 to a Qwiic compatible board. The Ye*LL*ow wire goes in the SC*L* pin. The SCD30 also supports a serial interface but we haven't worked with it.
+
+The CO₂ sensor works very well and for additional accuracy the SCD30 accepts ambient pressure readings. We recommend using the SCD30 in conjunction with the [Qwiic Pressure Sensor - MS5637](https://www.sparkfun.com/products/14688) or the [Qwiic Environmental Sensor - BME680](https://www.sparkfun.com/products/14570) to obtain the current barometric pressure.
+
+Note: The SCD30 has an automatic self-calibration routine. Sensirion recommends 7 days of continuous readings with at least 1 hour a day of 'fresh air' for self-calibration to complete.
+
+Library written by Nathan Seidle ([SparkFun](http://www.sparkfun.com)).
+
+Thanks to!
+
+* [jobr97](https://github.com/jobr97) for adding the getTemperatureOffset() method
+* [bobobo1618](https://github.com/bobobo1618) for writing a CRC check and improving the return values of the library
+* [labeneator](https://github.com/labeneator) for adding method to disable calibrate at begin
+
+Repository Contents
+-------------------
+
+* **/examples** - Example sketches for the library (.ino). Run these from the Arduino IDE. 
+* **/src** - Source files for the library (.cpp, .h).
+* **keywords.txt** - Keywords from this library that will be highlighted in the Arduino IDE. 
+* **library.properties** - General library properties for the Arduino package manager. 
+
+Documentation
+--------------
+
+* **[Installing an Arduino Library Guide](https://learn.sparkfun.com/tutorials/installing-an-arduino-library)** - Basic information on how to install an Arduino library.
+
+License Information
+-------------------
+
+This product is _**open source**_! 
+
+Various bits of the code have different licenses applied. Anything SparkFun wrote is beerware; if you see me (or any other SparkFun employee) at the local, and you've found our code helpful, please buy us a round! 
+
+Please use, reuse, and modify these files as you see fit. Please maintain attribution to SparkFun Electronics and release anything derivative under the same license.
+
+Distributed as-is; no warranty is given.
+
+- Your friends at SparkFun.

src/lib/SparkFun_SCD30_Arduino_Library/keywords.txt

+#######################################
+# Syntax Coloring Map
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+SCD30				KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+SCD30				KEYWORD2
+begin				KEYWORD2
+beginMeasuring			KEYWORD2
+getCO2				KEYWORD2
+getHumidity			KEYWORD2
+getTemperature			KEYWORD2
+getTemperatureOffset		KEYWORD2
+setMeasurementInterval		KEYWORD2
+setAmbientPressure		KEYWORD2
+setAltitudeCompensation		KEYWORD2
+setAutoSelfCalibration		KEYWORD2
+setTemperatureOffset		KEYWORD2
+setForcedRecalibrationFactor 	KEYWORD2
+dataAvailable			KEYWORD2
+readMeasurement			KEYWORD2
+sendCommand			KEYWORD2
+sendCommand			KEYWORD2
+readRegister			KEYWORD2
+computeCRC8			KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+
+SCD30_ADDRESS				LITERAL1
+COMMAND_CONTINUOUS_MEASUREMENT		LITERAL1
+COMMAND_SET_MEASUREMENT_INTERVAL	LITERAL1
+COMMAND_GET_DATA_READY			LITERAL1
+COMMAND_READ_MEASUREMENT		LITERAL1
+COMMAND_AUTOMATIC_SELF_CALIBRATION	LITERAL1
+COMMAND_SET_FORCED_RECALIBRATION_FACTOR	LITERAL1
+COMMAND_SET_TEMPERATURE_OFFSET		LITERAL1
+COMMAND_SET_ALTITUDE_COMPENSATION	LITERAL1

src/lib/SparkFun_SCD30_Arduino_Library/library.properties

+name=SparkFun SCD30 Arduino Library
+version=1.0.8
+author=SparkFun Electronics
+maintainer=SparkFun Electronics <sparkfun.com>
+sentence=Library for the Sensirion SCD30 CO2 Sensor
+paragraph=An Arduinolibrary for the SCD30 CO2 sensor from Sensirion. The SCD30 is a high quality <a href="https://en.wikipedia.org/wiki/Nondispersive_infrared_sensor">NDIR</a> based CO₂ sensor capable of detecting 400 to 10000ppm with an accuracy of ±(30ppm+3%). In order to improve accuracy the SCD30 has temperature and humidity sensing built-in, as well as commands to set the current altitude.<br><br>Get the SCD30 <a href="https://www.sparkfun.com/products/14751">here</a>.
+category=Sensors
+url=https://github.com/sparkfun/SparkFun_SCD30_Arduino_Library
+architectures=*

src/lib/SparkFun_SCD30_Arduino_Library/src/SparkFun_SCD30_Arduino_Library.cpp

+/*
+  This is a library written for the SCD30
+  SparkFun sells these at its website: www.sparkfun.com
+  Do you like this library? Help support SparkFun. Buy a board!
+  https://www.sparkfun.com/products/14751
+
+  Written by Nathan Seidle @ SparkFun Electronics, May 22nd, 2018
+
+  The SCD30 measures CO2 with accuracy of +/- 30ppm.
+
+  This library handles the initialization of the SCD30 and outputs
+  CO2 levels, relative humidty, and temperature.
+
+  https://github.com/sparkfun/SparkFun_SCD30_Arduino_Library
+
+  Development environment specifics:
+  Arduino IDE 1.8.5
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "SparkFun_SCD30_Arduino_Library.h"
+
+SCD30::SCD30(void)
+{
+  // Constructor
+}
+
+//Initialize the Serial port
+bool SCD30::begin(TwoWire &wirePort, bool autoCalibrate)
+{
+  _i2cPort = &wirePort; //Grab which port the user wants us to use
+
+  /* Especially during obtaining the ACK BIT after a byte sent the SCD30 is using clock stretching  (but NOT only there)!
+   * The need for clock stretching is described in the Sensirion_CO2_Sensors_SCD30_Interface_Description.pdf
+   *
+   * The default clock stretch (maximum wait time) on the ESP8266-library (2.4.2) is 230us which is set during _i2cPort->begin();
+   * In the current implementation of the ESP8266 I2C driver there is NO error message when this time expired, while
+   * the clock stretch is still happening, causing uncontrolled behaviour of the hardware combination.
+   *
+   * To set ClockStretchlimit() a check for ESP8266 boards has been added in the driver.
+   *
+   * With setting to 20000, we set a max timeout of 20mS (> 20x the maximum measured) basically disabling the time-out 
+   * and now wait for clock stretch to be controlled by the client.
+   */
+
+#if defined(ARDUINO_ARCH_ESP8266)
+  _i2cPort->setClockStretchLimit(200000);
+#endif
+
+  //Check for device to respond correctly
+  if (beginMeasuring() == true) //Start continuous measurements
+  {
+    setMeasurementInterval(2);    //2 seconds between measurements
+    setAutoSelfCalibration(autoCalibrate); //Enable auto-self-calibration
+
+    return (true);
+  }
+
+  return (false); //Something went wrong
+}
+
+//Returns the latest available CO2 level
+//If the current level has already been reported, trigger a new read
+uint16_t SCD30::getCO2(void)
+{
+  if (co2HasBeenReported == true) //Trigger a new read
+    readMeasurement();            //Pull in new co2, humidity, and temp into global vars
+
+  co2HasBeenReported = true;
+
+  return (uint16_t)co2; //Cut off decimal as co2 is 0 to 10,000
+}
+
+//Returns the latest available humidity
+//If the current level has already been reported, trigger a new read
+float SCD30::getHumidity(void)
+{
+  if (humidityHasBeenReported == true) //Trigger a new read
+    readMeasurement();                 //Pull in new co2, humidity, and temp into global vars
+
+  humidityHasBeenReported = true;
+
+  return humidity;
+}
+
+//Returns the latest available temperature
+//If the current level has already been reported, trigger a new read
+float SCD30::getTemperature(void)
+{
+  if (temperatureHasBeenReported == true) //Trigger a new read
+    readMeasurement();                    //Pull in new co2, humidity, and temp into global vars
+
+  temperatureHasBeenReported = true;
+
+  return temperature;
+}
+
+//Enables or disables the ASC
+bool SCD30::setAutoSelfCalibration(bool enable)
+{
+  if (enable)
+    return sendCommand(COMMAND_AUTOMATIC_SELF_CALIBRATION, 1); //Activate continuous ASC
+  else
+    return sendCommand(COMMAND_AUTOMATIC_SELF_CALIBRATION, 0); //Deactivate continuous ASC
+}
+
+//Set the forced recalibration factor. See 1.3.7.
+//The reference CO2 concentration has to be within the range 400 ppm ≤ cref(CO2) ≤ 2000 ppm.
+bool SCD30::setForcedRecalibrationFactor(uint16_t concentration)
+{
+  if (concentration < 400 || concentration > 2000)
+  {
+    return false; //Error check.
+  }
+  return sendCommand(COMMAND_SET_FORCED_RECALIBRATION_FACTOR, concentration);
+}
+
+//Get the temperature offset. See 1.3.8.
+float SCD30::getTemperatureOffset()
+{
+  //WARNING: convention is surprising. TemperatureOffset can only be positive. +2.0f means that the sensor outputs 2 Kelvin too much, and should be 2K lower.
+  uint16_t response = readRegister(COMMAND_SET_TEMPERATURE_OFFSET);
+  return (float)response / 100;
+}
+
+//Set the temperature offset. See 1.3.8.
+bool SCD30::setTemperatureOffset(float tempOffset)
+{
+  if (tempOffset < 0){
+    return false;
+  }
+  //WARNING: convention is surprising. TemperatureOffset can only be positive. +2.0f means that the sensor outputs 2 Kelvin too much, and should be 2K lower.
+  int16_t tickOffset = tempOffset * 100;
+  return sendCommand(COMMAND_SET_TEMPERATURE_OFFSET, tickOffset);
+}
+
+//Set the altitude compenstation. See 1.3.9.
+bool SCD30::setAltitudeCompensation(uint16_t altitude)
+{
+  return sendCommand(COMMAND_SET_ALTITUDE_COMPENSATION, altitude);
+}
+
+//Set the pressure compenstation. This is passed during measurement startup.
+//mbar can be 700 to 1200
+bool SCD30::setAmbientPressure(uint16_t pressure_mbar)
+{
+  if (pressure_mbar < 700 || pressure_mbar > 1200)
+  {
+    return false;
+  }
+  return sendCommand(COMMAND_CONTINUOUS_MEASUREMENT, pressure_mbar);
+}
+
+//Begins continuous measurements
+//Continuous measurement status is saved in non-volatile memory. When the sensor
+//is powered down while continuous measurement mode is active SCD30 will measure
+//continuously after repowering without sending the measurement command.
+//Returns true if successful
+bool SCD30::beginMeasuring(uint16_t pressureOffset)
+{
+  return (sendCommand(COMMAND_CONTINUOUS_MEASUREMENT, pressureOffset));
+}
+
+//Overload - no pressureOffset
+bool SCD30::beginMeasuring(void)
+{
+  return (beginMeasuring(0));
+}
+
+//Sets interval between measurements
+//2 seconds to 1800 seconds (30 minutes)
+bool SCD30::setMeasurementInterval(uint16_t interval)
+{
+  return sendCommand(COMMAND_SET_MEASUREMENT_INTERVAL, interval);
+}
+
+//Returns true when data is available
+bool SCD30::dataAvailable()
+{
+  uint16_t response = readRegister(COMMAND_GET_DATA_READY);
+
+  if (response == 1)
+    return (true);
+  return (false);
+}
+
+//Get 18 bytes from SCD30
+//Updates global variables with floats
+//Returns true if success
+bool SCD30::readMeasurement()
+{
+  //Verify we have data from the sensor
+  if (dataAvailable() == false)
+    return (false);
+
+  uint32_t tempCO2 = 0;
+  uint32_t tempHumidity = 0;
+  uint32_t tempTemperature = 0;
+
+  _i2cPort->beginTransmission(SCD30_ADDRESS);
+  _i2cPort->write(COMMAND_READ_MEASUREMENT >> 8);   //MSB
+  _i2cPort->write(COMMAND_READ_MEASUREMENT & 0xFF); //LSB
+  if (_i2cPort->endTransmission() != 0)
+    return (0); //Sensor did not ACK
+
+  const uint8_t receivedBytes = _i2cPort->requestFrom((uint8_t)SCD30_ADDRESS, (uint8_t)18);
+  bool error = false;
+  if (_i2cPort->available())
+  {
+    byte bytesToCrc[2];
+    for (byte x = 0; x < 18; x++)
+    {
+      byte incoming = _i2cPort->read();
+
+      switch (x)
+      {
+      case 0:
+      case 1:
+      case 3:
+      case 4:
+        tempCO2 <<= 8;
+        tempCO2 |= incoming;
+        bytesToCrc[x % 3] = incoming;
+        break;
+      case 6:
+      case 7:
+      case 9:
+      case 10:
+        tempTemperature <<= 8;
+        tempTemperature |= incoming;
+        bytesToCrc[x % 3] = incoming;
+        break;
+      case 12:
+      case 13:
+      case 15:
+      case 16:
+        tempHumidity <<= 8;
+        tempHumidity |= incoming;
+        bytesToCrc[x % 3] = incoming;
+        break;
+      default:
+        //Validate CRC
+        const uint8_t foundCrc = computeCRC8(bytesToCrc, 2);
+        if (foundCrc != incoming)
+        {
+          //Serial.printf("Found CRC in byte %u, expected %u, got %u\n", x, incoming, foundCrc);
+          error = true;
+        }
+        break;
+      }
+    }
+  }
+  else
+  {
+    //Serial.printf("No SCD30 data found from I2C, i2c claims we should receive %u bytes\n", receivedBytes);
+    return false;
+  }
+
+  if (error)
+  {
+    //Serial.println("Encountered error reading SCD30 data.");
+    return false;
+  }
+  //Now copy the uint32s into their associated floats
+  memcpy(&co2, &tempCO2, sizeof(co2));
+  memcpy(&temperature, &tempTemperature, sizeof(temperature));
+  memcpy(&humidity, &tempHumidity, sizeof(humidity));
+
+  //Mark our global variables as fresh
+  co2HasBeenReported = false;
+  humidityHasBeenReported = false;
+  temperatureHasBeenReported = false;
+
+  return (true); //Success! New data available in globals.
+}
+
+//Gets two bytes from SCD30
+uint16_t SCD30::readRegister(uint16_t registerAddress)
+{
+  _i2cPort->beginTransmission(SCD30_ADDRESS);
+  _i2cPort->write(registerAddress >> 8);   //MSB
+  _i2cPort->write(registerAddress & 0xFF); //LSB
+  if (_i2cPort->endTransmission() != 0)
+    return (0); //Sensor did not ACK
+
+  _i2cPort->requestFrom((uint8_t)SCD30_ADDRESS, (uint8_t)2);
+  if (_i2cPort->available())
+  {
+    uint8_t msb = _i2cPort->read();
+    uint8_t lsb = _i2cPort->read();
+    return ((uint16_t)msb << 8 | lsb);
+  }
+  return (0); //Sensor did not respond
+}
+
+//Sends a command along with arguments and CRC
+bool SCD30::sendCommand(uint16_t command, uint16_t arguments)
+{
+  uint8_t data[2];
+  data[0] = arguments >> 8;
+  data[1] = arguments & 0xFF;
+  uint8_t crc = computeCRC8(data, 2); //Calc CRC on the arguments only, not the command
+
+  _i2cPort->beginTransmission(SCD30_ADDRESS);
+  _i2cPort->write(command >> 8);     //MSB
+  _i2cPort->write(command & 0xFF);   //LSB
+  _i2cPort->write(arguments >> 8);   //MSB
+  _i2cPort->write(arguments & 0xFF); //LSB
+  _i2cPort->write(crc);
+  if (_i2cPort->endTransmission() != 0)
+    return (false); //Sensor did not ACK
+
+  return (true);
+}
+
+//Sends just a command, no arguments, no CRC
+bool SCD30::sendCommand(uint16_t command)
+{
+  _i2cPort->beginTransmission(SCD30_ADDRESS);
+  _i2cPort->write(command >> 8);   //MSB
+  _i2cPort->write(command & 0xFF); //LSB
+  if (_i2cPort->endTransmission() != 0)
+    return (false); //Sensor did not ACK
+
+  return (true);
+}
+
+//Given an array and a number of bytes, this calculate CRC8 for those bytes
+//CRC is only calc'd on the data portion (two bytes) of the four bytes being sent
+//From: http://www.sunshine2k.de/articles/coding/crc/understanding_crc.html
+//Tested with: http://www.sunshine2k.de/coding/javascript/crc/crc_js.html
+//x^8+x^5+x^4+1 = 0x31
+uint8_t SCD30::computeCRC8(uint8_t data[], uint8_t len)
+{
+  uint8_t crc = 0xFF; //Init with 0xFF
+
+  for (uint8_t x = 0; x < len; x++)
+  {
+    crc ^= data[x]; // XOR-in the next input byte
+
+    for (uint8_t i = 0; i < 8; i++)
+    {
+      if ((crc & 0x80) != 0)
+        crc = (uint8_t)((crc << 1) ^ 0x31);
+      else
+        crc <<= 1;
+    }
+  }
+
+  return crc; //No output reflection
+}

src/lib/SparkFun_SCD30_Arduino_Library/src/SparkFun_SCD30_Arduino_Library.h

+/*
+  This is a library written for the SCD30
+  SparkFun sells these at its website: www.sparkfun.com
+  Do you like this library? Help support SparkFun. Buy a board!
+  https://www.sparkfun.com/products/14751
+
+  Written by Nathan Seidle @ SparkFun Electronics, May 22nd, 2018
+
+  The SCD30 measures CO2 with accuracy of +/- 30ppm.
+
+  This library handles the initialization of the SCD30 and outputs
+  CO2 levels, relative humidty, and temperature.
+
+  https://github.com/sparkfun/SparkFun_SCD30_Arduino_Library
+
+  Development environment specifics:
+  Arduino IDE 1.8.5
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __SparkFun_SCD30_ARDUINO_LIBARARY_H__
+#define __SparkFun_SCD30_ARDUINO_LIBARARY_H__
+
+#include "Arduino.h"
+#include <Wire.h>
+
+//The default I2C address for the SCD30 is 0x61.
+#define SCD30_ADDRESS 0x61
+
+//Available commands
+
+#define COMMAND_CONTINUOUS_MEASUREMENT 0x0010
+#define COMMAND_SET_MEASUREMENT_INTERVAL 0x4600
+#define COMMAND_GET_DATA_READY 0x0202
+#define COMMAND_READ_MEASUREMENT 0x0300
+#define COMMAND_AUTOMATIC_SELF_CALIBRATION 0x5306
+#define COMMAND_SET_FORCED_RECALIBRATION_FACTOR 0x5204
+#define COMMAND_SET_TEMPERATURE_OFFSET 0x5403
+#define COMMAND_SET_ALTITUDE_COMPENSATION 0x5102
+
+class SCD30
+{
+public:
+	SCD30(void);
+  
+	bool begin(bool autoCalibrate) { return begin(Wire, autoCalibrate); }
+	bool begin(TwoWire &wirePort = Wire, bool autoCalibrate=true); //By default use Wire port
+
+	bool beginMeasuring(uint16_t pressureOffset);
+	bool beginMeasuring(void);
+
+	uint16_t getCO2(void);
+	float getHumidity(void);
+	float getTemperature(void);
+	float getTemperatureOffset(void);
+
+	bool setMeasurementInterval(uint16_t interval);
+	bool setAmbientPressure(uint16_t pressure_mbar);
+	bool setAltitudeCompensation(uint16_t altitude);
+	bool setAutoSelfCalibration(bool enable);
+	bool setForcedRecalibrationFactor(uint16_t concentration);
+	bool setTemperatureOffset(float tempOffset);
+
+	bool dataAvailable();
+	bool readMeasurement();
+
+	bool sendCommand(uint16_t command, uint16_t arguments);
+	bool sendCommand(uint16_t command);
+
+	uint16_t readRegister(uint16_t registerAddress);
+
+	uint8_t computeCRC8(uint8_t data[], uint8_t len);
+
+private:
+	//Variables
+	TwoWire *_i2cPort; //The generic connection to user's chosen I2C hardware
+
+	//Global main datums
+	float co2 = 0;
+	float temperature = 0;
+	float humidity = 0;
+
+	//These track the staleness of the current data
+	//This allows us to avoid calling readMeasurement() every time individual datums are requested
+	bool co2HasBeenReported = true;
+	bool humidityHasBeenReported = true;
+	bool temperatureHasBeenReported = true;
+};
+#endif

util.cpp

+#include "util.h"
+
+namespace config {
+  const char *ntp_server = NTP_SERVER;
+  const long utc_offset_in_seconds = UTC_OFFSET_IN_SECONDS; // UTC+1
+}
+
+// Get last 3 bytes of ESP MAC (worldwide unique)
+String macToID() {
+  uint8_t mac[6];
+  WiFi.macAddress(mac);
+  String result;
+  for (int i = 3; i < 6; i++) {
+    if (mac[i] < 16)
+      result += '0';
+    result += String(mac[i], HEX);
+  }
+  result.toLowerCase();
+  return result;
+}
+
+//NOTE: ESP32 sometimes couldn't access the NTP server, and every loop would take +1000ms
+// ifdefs could be used to define functions specific to ESP32, e.g. with configTime
+namespace ntp {
+  WiFiUDP ntpUDP;
+  NTPClient timeClient(ntpUDP, config::ntp_server, config::utc_offset_in_seconds, 60000UL);
+
+  void initialize() {
+    timeClient.begin();
+  }
+
+  void update() {
+    timeClient.update();
+  }
+
+  String getLocalTime() {
+    return timeClient.getFormattedDate();
+  }
+}
+
+uint32_t max_loop_duration = 0;
+
+//FIXME: Remove every instance of Strings, to avoid heap fragmentation problems. (Start:  "Free heap space : 17104 bytes")
+// See more https://cpp4arduino.com/2020/02/07/how-to-format-strings-without-the-string-class.html
+const String SENSOR_ID = "ESP" + macToID();

util.h

+#ifndef AMPEL_UTIL_H_INCLUDED
+#define AMPEL_UTIL_H_INCLUDED
+#include <Arduino.h>
+#include "config.h"
+#include "wifi_util.h" // To get MAC
+
+#include <WiFiUdp.h> //required for NTP
+#include "src/lib/NTPClient-master/NTPClient.h" // NTP
+
+#if defined(ESP8266)
+#  define BOARD "ESP8266"
+#  define get_free_heap_size() system_get_free_heap_size()
+#elif defined(ESP32)
+#  define BOARD "ESP32"
+#  define get_free_heap_size() esp_get_free_heap_size()
+#else
+#  define BOARD "Unknown"
+#endif
+
+namespace ntp {
+  void initialize();
+  void update();
+  String getLocalTime();
+}
+
+#define seconds() (millis() / 1000UL)
+extern uint32_t max_loop_duration;
+const extern String SENSOR_ID;
+
+#endif

web_server.cpp

+#include "web_server.h"
+
+namespace config {
+  // Values should be defined in config.h
+#ifdef HTTP_USER
+  const char *http_user = HTTP_USER;
+#else
+  const char *http_user = "";
+#endif
+#ifdef HTTP_PASSWORD
+  const char *http_password = HTTP_PASSWORD;
+#else
+  const char *http_password = "";
+#endif
+
+}
+
+namespace web_server {
+
+  const char *header_template;
+  const char *body_template;
+  const char *script_template;
+  void handleWebServerRoot();
+  void handleWebServerCSV();
+  void handlePageNotFound();
+  void handleDeleteCSV();
+
+#if defined(ESP8266)
+  ESP8266WebServer http(80); // Create a webserver object that listens for HTTP request on port 80
+#endif
+#if defined(ESP32)
+  WebServer http(80);
+#endif
+
+  void update() {
+    http.handleClient(); // Listen for HTTP requests from clients
+  }
+
+  void initialize() {
+    header_template =
+        PSTR("<!doctype html><html lang=en>"
+            "<head>\n"
+            "<title>%d ppm - CO2 SENSOR - %s - %s</title>\n"
+            "<meta charset='UTF-8'>"
+            // HfT Favicon
+            "<link rel='icon' type='image/png' sizes='16x16' href='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABHNCSVQICAgIfAhkiAAAAHtJREFUOE9jvMnA+5+BAsBIFQMkl85h+P3kGcOb8jqwW+TPH2H4de0GA29UGNxtfx49YWCRk0HwHz5iuKegwwB2AS4DkA2F6VR6cAWsEQbgBqDY9vARw/ejJ+Au+LxsFcPz6BSwHpwGYPMCSS6gyAAKYhESiKMGjPgwAADopHVhn5ynEwAAAABJRU5ErkJggg=='/>"
+            // Responsive grid:
+            "<link rel='stylesheet' href='https://unpkg.com/purecss@2.0.3/build/pure-min.css'>\n"
+            "<link rel='stylesheet' href='https://unpkg.com/purecss@2.0.3/build/grids-responsive-min.css'>\n"
+            // JS Graphs:
+            "<script src='https://cdn.plot.ly/plotly-basic-1.58.2.min.js'></script>\n"
+            // Fullscreen
+            "<meta name='viewport' content='width=device-width, initial-scale=1'>\n"
+            // Refresh after every measurement.
+            // "<meta http-equiv='refresh' content='%d'>\n"
+            "</head>\n"
+            "<body>\n"
+
+            "<div class='pure-g'><div class='pure-u-1'><div class='pure-menu'><p class='pure-menu-heading'>HfT-Stuttgart CO<sub>2</sub> sensor</p></div></div>\n"
+            "<div class='pure-u-1'><ul class='pure-menu pure-menu-horizontal pure-menu-list'>\n"
+            "<li class='pure-menu-item'><a href='#graph' class='pure-menu-link'>Graph</a></li>\n"
+            "<li class='pure-menu-item'><a href='#table' class='pure-menu-link'>Info</a></li>\n"
+            "<li class='pure-menu-item'><a href='#log' class='pure-menu-link'>Log</a></li>\n"
+            "<li class='pure-menu-item'><a href='./%s' class='pure-menu-link'>Download CSV</a></li>\n"
+            "</ul></div></div>\n");
+
+    body_template =
+        PSTR("<div class='pure-g'>\n"
+            "<div class='pure-u-1' id='graph'></div>\n" // Graph placeholder
+            "</div>\n"
+            "<div class='pure-g'>\n"
+            //Sensor table
+            "<table id='table' class='pure-table-striped pure-u-1 pure-u-md-1-2'>\n"
+            "<tr><th>Sensor</th><th>%s</th></tr>\n"
+            "<tr><td>CO<sub>2</sub> concentration</td><td>%5d ppm</td></tr>\n"
+            "<tr><td>Temperature</td><td>%.1f&#8451;</td></tr>\n"
+            "<tr><td>Humidity</td><td>%.1f%%</td></tr>\n"
+            "<tr><td>Last measurement</td><td>%s</td></tr>\n"
+            "<tr><td>Measurement timestep</td><td>%5d s</td></tr>\n"
+            "<tr><td>Last CSV write</td><td>%s</td></tr>\n"
+            "<tr><td>CSV timestep</td><td>%5d s</td></tr>\n"
+#ifdef MQTT
+            "<tr><td>Last MQTT publish</td><td>%s</td></tr>\n"
+            "<tr><td>MQTT publish timestep</td><td>%5d s</td></tr>\n"
+#endif
+            "<tr><td>Temperature offset</td><td>%.1fK</td></tr>\n"
+            "<tr><td>Local address</td><td><a href='http://%s.local/'>%s.local</a></td></tr>\n"
+            "<tr><td>Local IP</td><td><a href='http://%s'>%s</a></td></tr>\n"
+            "<tr><td>Free heap space</td><td>%6d bytes</td></tr>\n"
+            "<tr><td>Available drive space</td><td>%d kB</td></tr>\n"
+            "<tr><td>Max loop duration</td><td>%5d ms</td></tr>\n"
+            "<tr><td>Board</td><td>%s</td></tr>\n"
+            "<tr><td>Uptime</td><td>%4d h %02d min %02d s</td></tr>\n"
+            "</table>\n"
+            // CSV placeholder
+            "<div id='log' class='pure-u-1 pure-u-md-1-2'></div>\n"
+            "<form action='/delete_csv' method='POST' onsubmit=\"return confirm('Are you really sure you want to delete all data?') && (document.body.style.cursor = 'wait');\">"
+            "<input type='submit' value='Delete CSV'/>"
+            "</form>\n"
+            "</div>\n");
+
+    script_template = PSTR("<script>\n"
+        "document.body.style.cursor = 'default';\n"
+        "fetch('./%s',{credentials:'include'})\n"
+        // Get CSV, fill table and fill diagram
+        ".then(response=>response.text())\n"
+        ".then(csvText=>csvToTable(csvText))\n"
+        ".then(htmlTable=>addLogTableToPage(htmlTable))\n"
+        ".then(_=>Plotly.newPlot('graph',data,layout,{displaylogo:false}))\n"
+        ".catch(e=>console.error(e));\n"
+        "xs=[];\n"
+        "data=[{x:xs,y:[],type:'scatter',name:'CO<sub>2</sub>',line:{color:'#2ca02c'}},\n"
+        "{x:xs,y:[],type:'scatter',name:'Temperature',yaxis:'y2',line:{color:'#ff7f0e',dash:'dot'}},\n"
+        "{x:xs,y:[],type:'scatter',name:'Humidity',yaxis:'y3',line:{color:'#1f77b4',dash:'dot'}}];\n"
+        "layout={height:600,title:'%s',legend:{xanchor:'right',x:0.2,y:1.0},\n"
+        "xaxis:{domain:[0.0,0.85]},yaxis:{ticksuffix:'ppm',range:[0,2000],dtick:200},\n"
+        "yaxis2:{overlaying:'y',side:'right',ticksuffix:'°C',position:0.9,anchor:'free',range:[0,30],dtick:3},\n"
+        "yaxis3:{overlaying:'y',side:'right',ticksuffix:'%%',position:0.95,anchor:'free',range:[0,100],dtick:10}\n"
+        "};\n"
+        "function csvToTable(csvText) {\n"
+        "csvText=csvText.trim();\n"
+        "lines=csvText.split('\\n');\n"
+        "table=document.createElement('table');\n"
+        "table.className='pure-table-striped';\n"
+        "n=lines.length;\n"
+        "lines.forEach((line,i)=>{\n"
+        "fields=line.split(';');\n"
+        "xs.push(fields[0]);\n"
+        "data[0]['y'].push(fields[1]);\n"
+        "data[1]['y'].push(fields[2]);\n"
+        "data[2]['y'].push(fields[3]);\n"
+        "if(i>4 && i<n-12){if(i==5){fields=['...','...','...','...']}else{return;}}\n"
+        "row=document.createElement('tr');\n"
+        "fields.forEach((field,index)=>{\n"
+        "cell=document.createElement(i<2?'th':'td');\n"
+        "cell.appendChild(document.createTextNode(field));\n"
+        "row.appendChild(cell);});\n"
+        "table.appendChild(row);});\n"
+        "return table;}\n"
+        "function addLogTableToPage(table){document.getElementById('log').appendChild(table);}\n"
+        "</script>\n"
+        "</body>\n"
+        "</html>");
+
+    // Web-server
+    http.on("/", handleWebServerRoot);
+    http.on("/" + csv_writer::filename, handleWebServerCSV);
+    http.on("/delete_csv", HTTP_POST, handleDeleteCSV);
+    http.onNotFound(handlePageNotFound);
+    http.begin();
+
+    Serial.print(F("You can access this sensor via http://"));
+    Serial.print(SENSOR_ID);
+    Serial.print(F(".local (might be unstable) or http://"));
+    Serial.println(WiFi.localIP());
+  }
+
+  // Allow access if http_user or http_password are empty, or if provided credentials match
+  bool shouldBeAllowed() {
+    return strcmp(config::http_user, "") == 0 || strcmp(config::http_password, "") == 0
+        || http.authenticate(config::http_user, config::http_password);
+  }
+
+  void handleWebServerRoot() {
+    if (!shouldBeAllowed()) {
+      return http.requestAuthentication(DIGEST_AUTH);
+    }
+
+    unsigned long ss = seconds();
+    unsigned int hh = ss / 3600;
+    ss -= hh * 3600;
+    uint8_t mm = ss / 60;
+    ss -= mm * 60;
+    uint16_t available_fs_space = csv_writer::getAvailableSpace() / 1024;
+
+    //NOTE: Splitting in multiple parts in order to use less RAM
+    char content[2000]; // Update if needed
+    // Header size : 1383 - Body size : 1246 - Script size : 1648
+    // Header
+    snprintf_P(content, sizeof(content), header_template, sensor::co2, SENSOR_ID.c_str(),
+        WiFi.localIP().toString().c_str(), csv_writer::filename.c_str());
+
+    http.setContentLength(CONTENT_LENGTH_UNKNOWN);
+    http.send_P(200, PSTR("text/html"), content);
+
+    // Body
+    snprintf_P(content, sizeof(content), body_template, SENSOR_ID.c_str(), sensor::co2, sensor::temperature,
+        sensor::humidity, sensor::timestamp.c_str(), config::measurement_timestep,
+        csv_writer::last_successful_write.c_str(), config::csv_interval,
+#ifdef MQTT
+        mqtt::last_successful_publish.c_str(), config::sending_interval,
+#endif
+        config::temperature_offset, SENSOR_ID.c_str(), SENSOR_ID.c_str(), WiFi.localIP().toString().c_str(),
+        WiFi.localIP().toString().c_str(), get_free_heap_size(), available_fs_space, max_loop_duration, BOARD, hh, mm,
+        ss);
+
+    http.sendContent(content);
+
+    // Script
+    snprintf_P(content, sizeof(content), script_template, csv_writer::filename.c_str(), SENSOR_ID.c_str());
+
+    http.sendContent(content);
+  }
+
+  void handleWebServerCSV() {
+    if (!shouldBeAllowed()) {
+      return http.requestAuthentication(DIGEST_AUTH);
+    }
+    if (FS_LIB.exists(csv_writer::filename)) {
+      fs::File csv_file = FS_LIB.open(csv_writer::filename, "r");
+      http.sendHeader("Content-Length", String(csv_file.size()));
+      http.streamFile(csv_file, F("text/csv"));
+      csv_file.close();
+    } else {
+      http.send(204, F("text/html"), F("No data available."));
+    }
+  }
+
+  void handleDeleteCSV() {
+    if (!shouldBeAllowed()) {
+      return http.requestAuthentication(DIGEST_AUTH);
+    }
+    Serial.print("Removing CSV file...");
+    FS_LIB.remove(csv_writer::filename);
+    Serial.println(" Done!");
+    http.sendHeader("Location", "/");
+    http.send(303);
+  }
+
+  void handlePageNotFound() {
+    http.send(404, F("text/plain"), F("404: Not found"));
+  }
+}

web_server.h

+#ifndef WEB_SERVER_H_
+#define WEB_SERVER_H_
+#if defined(ESP8266)
+#  include <ESP8266WebServer.h>
+#endif
+#if defined(ESP32)
+#  include <WebServer.h>
+#endif
+
+#include "config.h"
+#include "util.h"
+#include "co2_sensor.h"
+#include "csv_writer.h"
+#ifdef MQTT
+#  include "mqtt.h"
+#endif
+
+namespace web_server {
+  void initialize();
+  void update();
+}
+#endif

wifi_util.cpp

+#include "wifi_util.h"
+
+namespace config {
+  // WiFi config. See 'config.h' if you want to modify those values.
+#ifdef WIFI_SSID
+  const char *wifi_ssid = WIFI_SSID;
+  const char *wifi_password = WIFI_PASSWORD;
+#else
+  const char *wifi_ssid = "NO_WIFI";
+  const char *wifi_password = "";
+#endif
+
+#ifdef WIFI_TIMEOUT
+  const uint8_t wifi_timeout = WIFI_TIMEOUT;  // [s] Will try to connect during wifi_timeout seconds before failing.
+#else
+  const uint8_t wifi_timeout = 60;  // [s] Will try to connect during wifi_timeout seconds before failing.
+#endif
+}
+
+// Initialize Wi-Fi
+void WiFiConnect(const String &hostname) {
+  //NOTE: WiFi Multi could allow multiple SSID and passwords.
+  if (strcmp(config::wifi_ssid, "NO_WIFI") == 0) {
+    Serial.println("Please change WIFI_SSID in config.h if you want to connect.");
+    WiFi.disconnect(true);
+    WiFi.mode(WIFI_OFF);
+    return;
+  }
+  WiFi.persistent(false); // Don't write user & password to Flash.
+  WiFi.mode(WIFI_STA);  // Set ESP8266 to be a WiFi-client only
+#if defined(ESP8266)
+    WiFi.hostname(hostname);
+#endif
+#if defined(ESP32)
+  WiFi.setHostname(hostname.c_str());
+#endif
+
+  Serial.print("\nConnecting to ");
+  Serial.println(config::wifi_ssid);
+  WiFi.begin(config::wifi_ssid, config::wifi_password);
+
+  // Wait for connection, at most wifi_timeout seconds
+  for (int i = 0; i <= config::wifi_timeout && (WiFi.status() != WL_CONNECTED); i++) {
+    LedEffects::showRainbowWheel();
+    Serial.print(".");
+  }
+  if (WiFi.status() == WL_CONNECTED) {
+    LedEffects::showKITTWheel(color::green);
+    Serial.println();
+    Serial.print("\nWiFi connected, IP address: ");
+    Serial.println(WiFi.localIP());
+  } else {
+    LedEffects::showKITTWheel(color::red);
+    Serial.println("\nConnection to WiFi failed");
+  }
+}

wifi_util.h

+#ifndef WIFI_UTIL_H_INCLUDED
+#  define WIFI_UTIL_H_INCLUDED
+#  if defined(ESP8266)
+#    include <ESP8266WiFi.h>
+#  elif defined(ESP32)
+#    include <WiFi.h>
+#  endif
+
+#include "led_effects.h"
+#include "config.h"
+void WiFiConnect(const String &hostname);
+
+#endif