lovebox.ino

// *****************************************************************************
// 
// See README for explanations how the MQTT and GitHub-gist-fetching versions of
// this application work.
//
// *****************************************************************************
#include "settings.h"

#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>
#include <Servo.h>
#include <TZ.h>
#include "SSD1306Wire.h"

#ifdef USE_MQTT
#include <PubSubClient.h>
WiFiClient wifiClient;
PubSubClient mqttClient(wifiClient);
char* mqttMessage;
bool newMqttMessageAvailable;
#else
const int fetchIntervalMillis = fetchIntervalSeconds * 1000;
#endif

SSD1306Wire oled(0x3C, D2, D1);
Servo myservo;
int pos = 90;
int increment = -1;
int lightValue;
String mode;
char idSaved = '0';
bool wasRead = true;

void drawMessage(const String& message) {
  Serial.println("Drawing message....");
  oled.clear();

  // differentiat between *t*ext and image messages
  if (mode[0] == 't') {
    oled.drawStringMaxWidth(0, 0, 128, message);
  } else {
    for (int i = 0; i <= message.length(); i++) {
      int x = i % 129;
      int y = i / 129;
      if (message[i] == '1') {
        oled.setPixel(x, y);
      }
    }
  }
  oled.display();
  Serial.println("done.");
}

// Set time via NTP, as required for x.509 validation
void setClock() {
  // General C time functions: https://en.wikipedia.org/wiki/C_date_and_time_functions
  configTime(TIMEZONE, "pool.ntp.org");

  Serial.print("Waiting for NTP time sync: ");
  time_t now = time(nullptr);
  // 1546300800 = 01/01/2019 @ 12:00am (UTC)
  while (now < 1546300800) {
    delay(500);
    Serial.print(".");
    now = time(nullptr);
  }
  Serial.println();
  time_t nowUtc = mktime(gmtime(&now));

  Serial.print("Local time: ");
  Serial.print(ctime(&now));
  Serial.print("UTC:        ");
  Serial.print(ctime(&nowUtc));
  Serial.println();
}

void wifiConnect() {
  Serial.printf("Connecting to WiFi '%s'...", ssid);
  if (WiFi.status() != WL_CONNECTED) {
    WiFi.begin(ssid, password);

    while (WiFi.status() != WL_CONNECTED) {
      delay(500);
      Serial.print(".");
    }
  }
  Serial.print("..done. IP ");
  Serial.println(WiFi.localIP());
}

#ifdef USE_MQTT
void mqttConnect() {
  mqttClient.setServer(mqttServer, mqttPort);
  mqttClient.setCallback(mqttCallback);
 
  while (!mqttClient.connected()) {
    Serial.println("Connecting to MQTT...");
    if (mqttClient.connect(mqttClientId, mqttUser, mqttPassword)) {
      Serial.println("connected");  
    } else {
      Serial.print("failed with state ");
      Serial.println(mqttClient.state());
      delay(2000);
    }
  }
  mqttClient.publish(mqttPublishTopic, "Hello from Lovebox");
  mqttClient.subscribe(mqttSubscribeTopic);
}

void mqttCallback(char* topic, byte* payload, unsigned int length) {
  // resetting the "message was read" flag
  wasRead = 0;

  mode = (char)payload[0];

  Serial.println("New MQTT message:");
  Serial.println(mode);

  // skip 2 bytes (mode plus follwing newline) but add 1 for the terminating 0 appended at the end
  mqttMessage = new char[length - 2 + 1];
  memcpy (mqttMessage, (char*)payload + 2, length - 2);
  mqttMessage[length - 2] = '\0';
  
  Serial.print(mqttMessage);
  newMqttMessageAvailable = true;
  mqttClient.publish(mqttPublishTopic, "New message fully processed");
}

#else
void getGistMessage() {
  Serial.println("Fetching gist message...");
  const int httpsPort = 443;
  const char* host = "gist.githubusercontent.com";

  BearSSL::WiFiClientSecure client;
  BearSSL::X509List cert(digicertRootCert);
  client.setTrustAnchors(&cert);
  if (!client.connect(host, httpsPort)) {
    Serial.println("Failed to connect to GitHub");
    return;
  }

  // add current millis as a cache-busting means
  client.print(String("GET ") + url + "?" + millis() + " HTTP/1.1\r\n" +
               "Host: " + host + "\r\n" +
               "User-Agent: ESP8266\r\n" +
               "Connection: close\r\n\r\n");

  while (client.connected()) {
    String temp = client.readStringUntil('\n');
    if (temp == "\r") {
      break;
    }
  }
  String id = client.readStringUntil('\n');
  Serial.printf("\tid: '%s', last processed id: '%c'\n", id.c_str(), idSaved);
  if (id[0] != idSaved) { // new message
    wasRead = 0;
    idSaved = id[0];

    mode = client.readStringUntil('\n');
    Serial.println("\tmode: " + mode);
    String line = client.readStringUntil(0);
    Serial.println("\tmessage: " + line);
    drawMessage(line);
  } else {
    Serial.println("\t-> message id wasn't updated");
  }
}
#endif

void spinServo() {
  myservo.write(pos);
  delay(50);    // wait 50ms to turn servo

  if (pos == 75 || pos == 105) { // 75°-105° range
    increment *= -1;
  }
  pos += increment;
}

void setup() {
  Serial.begin(115200);
  Serial.println("\n\n");

  Serial.print("Attaching servo...");
  myservo.attach(16);       // Servo an D0
  Serial.println("done.");

  Serial.print("Initializing display...");
  oled.init();
  oled.flipScreenVertically();
  oled.setColor(WHITE);
  oled.setTextAlignment(TEXT_ALIGN_LEFT);
  oled.setFont(ArialMT_Plain_10);

  oled.clear();
  oled.drawString(30, 30, "<3 LOVEBOX <3");
  oled.display();
  Serial.println("done.");

  wifiConnect();
  setClock();
  
  #ifdef USE_MQTT
  Serial.println("Running in MQTT mode.");
  // 128 x 64 pixels require at most 8192 bytes (1 per pixel) for pixelated images 
  // plus 1 byte to denote the message type ('t' = text, 'b' = "binary")
  // plus newlines
  mqttClient.setBufferSize(8192 + 100);
  mqttConnect();
  #else
  Serial.printf("Running in GitHub-gist-fetching mode. Initial state: last processed id '%c' %s read.\n", idSaved, (wasRead ? "was" : "wasn't"));
  #endif
}

void loop() {
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("Lost WiFi connection. Attempting to reconnect.");
    wifiConnect();
    setClock();
  }

  #ifdef USE_MQTT
  if (!mqttClient.connected()) {
    Serial.println("Lost connection to MQTT broker. Attempting to reconnect.");
    mqttConnect();
  }
  mqttClient.loop();
  if (newMqttMessageAvailable) {
    drawMessage(mqttMessage);
    mqttClient.publish(mqttPublishTopic, "New message rendered");
    delete[] mqttMessage;
    newMqttMessageAvailable = false;
  }
  #else
  if (wasRead) {
    getGistMessage();
  }
  #endif

  while (!wasRead) {
    yield();
    spinServo();
    lightValue = analogRead(0);
    if (lightValue > lightValueThreshold) {
      Serial.printf("Analog read value (LDR) %d above threshold of %d -> consider message read.\n", lightValue, lightValueThreshold);
      #ifdef USE_MQTT
      mqttClient.publish(mqttPublishTopic, "Message was read");
      #endif
      wasRead = 1;
    }
  }
  #ifndef USE_MQTT
  delay(fetchIntervalMillis);
  #endif
}