Kettenoeler/Software/ChainLube/src/main.cpp

#include <Arduino.h>
#include <Wire.h>
#include <U8g2lib.h>
#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>
#include <ESP8266mDNS.h>
#include <ArduinoOTA.h>
#include <RemoteDebug.h>
#include <FastLED.h>
#include <Ticker.h>

#include "common.h"
#include "rmtdbghelp.h"

const char *ssid = QUOTE(WIFI_SSID);
const char *password = QUOTE(WIFI_PASSWORD);

const uint32_t connectTimeoutMs = 5000;

#ifdef DEBUG
const bool debug_flag = true;
#else
const bool debug_flag = false;
#endif

bool startSetupMode = false;
char DeviceName[33];

volatile uint32_t wheel_pulse = 0;

typedef struct tLubeConfig
{
  uint32_t DistancePerLube_Default = 0;
  uint32_t DistancePerLube_Rain = 0;
  uint32_t tankCapacity_ml = 320;
  uint32_t amountPerDose_µl = 0;
  uint32_t tankRemain_µl = 0;
  uint8_t TankRemindAtPercentage = 30;
  uint8_t PulsePerRevolution = 1;
  uint32_t DistancePerRevolution_mm = 2000;

} sLubeConfig;

U8X8_SSD1306_128X64_NONAME_HW_I2C u8x8(-1);
RemoteDebug Debug;
ESP8266WiFiMulti wifiMulti;
CRGB leds[1];

// Function-Prototypes
String IpAddress2String(const IPAddress &ipAddress);
void processCmdRemoteDebug();
void RemotDebug_printSystemInfo();
void RemoteDebug_printWifiInfo();
void wifiMaintainConnectionTicker_callback();
void IRAM_ATTR trigger_ISR();
extern void RunLubeApp();
extern void initWebUI();

Ticker WiFiMaintainConnectionTicker(wifiMaintainConnectionTicker_callback, 1000, 0, MILLIS);

void setup()
{
  system_update_cpu_freq(SYS_CPU_80MHZ);
  snprintf(DeviceName, 32, HOST_NAME, ESP.getChipId());
  WiFi.mode(WIFI_OFF);
  WiFi.persistent(false);
  Serial.begin(115200);
  Serial.setDebugOutput(true);

  Serial.println("Souko's ChainLube Mk1");
  Serial.println(DeviceName);

  u8x8.begin();
  u8x8.setFont(u8x8_font_chroma48medium8_r);

  FastLED.addLeds<WS2811, GPIO_LED, GRB>(leds, 1); // GRB ordering is assumed

  pinMode(GPIO_TRIGGER, INPUT_PULLUP);
  pinMode(GPIO_BUTTON, INPUT_PULLUP);
  pinMode(GPIO_PUMP, OUTPUT);

  attachInterrupt(digitalPinToInterrupt(GPIO_TRIGGER), trigger_ISR, FALLING);

  WiFi.mode(WIFI_STA);
  WiFi.setHostname(DeviceName);
  wifiMulti.addAP(QUOTE(WIFI_SSID), QUOTE(WIFI_PASSWORD));

  Serial.println("Connecting Wifi...");
  if (wifiMulti.run() == WL_CONNECTED)
  {
    Serial.println("");
    Serial.println("WiFi connected");
    Serial.println("IP address: ");
    Serial.print(WiFi.localIP());
  }

  WiFiMaintainConnectionTicker.start();

  if (MDNS.begin(DeviceName))
    MDNS.addService("telnet", "tcp", 23);

  Debug.begin(DeviceName);        // Initialize the WiFi server
  Debug.setResetCmdEnabled(true); // Enable the reset command
  Debug.showProfiler(true);       // Profiler (Good to measure times, to optimize codes)
  Debug.showColors(true);         // Colors
  Debug.setPassword(QUOTE(ADMIN_PASSWORD));

  Debug.setHelpProjectsCmds(helpCmd);
  Debug.setCallBackProjectCmds(&processCmdRemoteDebug);

  ArduinoOTA.setPort(8266);
  ArduinoOTA.setHostname(DeviceName);
  ArduinoOTA.setPassword(QUOTE(ADMIN_PASSWORD));

  ArduinoOTA.onStart([]()
                     {
                       u8x8.clearDisplay();
                       u8x8.drawString(0, 0, "OTA-Update");
                       u8x8.refreshDisplay(); });

  ArduinoOTA.onProgress([](unsigned int progress, unsigned int total)
                        {
                          static bool refreshed = false;
                          if (!refreshed)
                          {
                            u8x8.clearDisplay();
                            refreshed = true;
                            u8x8.drawString(0, 0, "OTA Upload");
                          }
                          uint32_t percent = progress / (total / 100);
                          u8x8.setCursor(0, 1);
                          u8x8.printf("%d %%", percent);
                          u8x8.refreshDisplay(); });

  ArduinoOTA.onEnd([]()
                   {
                     u8x8.clearDisplay();
                     u8x8.drawString(0, 0, "OTA-Restart");
                     u8x8.refreshDisplay(); });

  ArduinoOTA.begin();

  u8x8.clearDisplay();
  u8x8.drawString(4, 0, "Souko's");
  u8x8.drawString(1, 1, "ChainLube Mk1");
  u8x8.refreshDisplay();

  initWebUI();
}

void loop()
{
  leds[0] = digitalRead(GPIO_BUTTON) ? CRGB::Green : CRGB::Red;

  RunLubeApp();

  WiFiMaintainConnectionTicker.update();
  FastLED.show();
  ArduinoOTA.handle();
  Debug.handle();
  yield();
}

String IpAddress2String(const IPAddress &ipAddress)
{
  return String(ipAddress[0]) + String(".") +
         String(ipAddress[1]) + String(".") +
         String(ipAddress[2]) + String(".") +
         String(ipAddress[3]);
}

void processCmdRemoteDebug()
{
  String lastCmd = Debug.getLastCommand();

  if (lastCmd == "sysinfo")
    RemotDebug_printSystemInfo();
  else if (lastCmd == "netinfo")
    RemoteDebug_printWifiInfo();
}

void RemotDebug_printSystemInfo()
{
  debugA("Souko's ChainOiler Mk1");
  debugA("Hostname: %s", DeviceName);

  debugA("Sdk version: %s", ESP.getSdkVersion());
  debugA("Core Version: %s", ESP.getCoreVersion().c_str());
  debugA("Boot Version: %u", ESP.getBootVersion());
  debugA("Boot Mode: %u", ESP.getBootMode());
  debugA("CPU Frequency: %u MHz", ESP.getCpuFreqMHz());
  debugA("Reset reason: %s", ESP.getResetReason().c_str());

  debugA("OTA-Pass: %s", QUOTE(ADMIN_PASSWORD));
}

void RemoteDebug_printWifiInfo()
{
}

void wifiMaintainConnectionTicker_callback()
{
  static uint32_t WiFiFailCount = 0;
  const uint32_t WiFiFailMax = 20;

  if (wifiMulti.run(connectTimeoutMs) == WL_CONNECTED)
  {
    return;
  }
  else
  {
    if (WiFiFailCount < WiFiFailMax)
    {
      WiFiFailCount++;
    }
    else
    {
      Serial.println("WiFi not connected! - Start AP");
      WiFi.mode(WIFI_OFF);
      WiFi.softAP(DeviceName, QUOTE(WIFI_AP_PASSWORD));
      WiFiMaintainConnectionTicker.stop();
      Serial.println("WiFi AP started, stopped Maintain-Timer");
    }
  }
}

void trigger_ISR()
{
  wheel_pulse++;
}