Multicore & Modularized

src/display/display.cpp

@@ -0,0 +1,127 @@
+#include "display.h"
+
+
+uint8_t *BlackImage = 0;
+
+
+static int8_t view_count = -1;
+static int8_t view_curr = 0;
+static DisplayWrapper** views = 0;
+
+void Display::setup(){
+    DEV_Module_Init();
+    EPD_2IN13_V2_Init(EPD_2IN13_V2_FULL);
+    EPD_2IN13_V2_Clear();
+    delay(100);
+
+    uint16_t Imagesize = ((EPD_2IN13_V2_WIDTH % 8 == 0) ? (EPD_2IN13_V2_WIDTH / 8 ) : (EPD_2IN13_V2_WIDTH / 8 + 1)) * EPD_2IN13_V2_HEIGHT;
+    if ((BlackImage = (uint8_t *)malloc(Imagesize)) == NULL) exit(1);
+    Paint_NewImage(BlackImage, EPD_2IN13_V2_WIDTH, EPD_2IN13_V2_HEIGHT, 270, WHITE);
+    Paint_SelectImage(BlackImage);
+    Paint_SetMirroring(MIRROR_HORIZONTAL);
+    Paint_Clear(WHITE);
+
+    Paint_DrawIcon(89,54, ICON_LOGO, &FontIcon, BLACK, WHITE);
+    Paint_DrawString_EN(29, 5, "Helcel", &Font45, WHITE, BLACK);
+    Paint_SelectImage(BlackImage);
+    EPD_2IN13_V2_Display(BlackImage);
+    delay(100);
+}
+
+void Display::drawTime(strDateTime* dt){
+    Paint_ClearWindows(170, EPD_2IN13_V2_WIDTH - Font24.Height, 170 + Font24.Width * 4.5, EPD_2IN13_V2_WIDTH, WHITE);
+    if (!dt->valid) return;
+    Paint_DrawTime(170, 98, dt, &Font24, WHITE, BLACK);
+    EPD_2IN13_V2_DisplayPart(BlackImage);
+};
+
+void Display::refresh(){
+    Paint_Clear(WHITE);
+    EPD_2IN13_V2_Init(EPD_2IN13_V2_FULL);
+    EPD_2IN13_V2_DisplayPartBaseImage(BlackImage);
+    EPD_2IN13_V2_Init(EPD_2IN13_V2_PART);
+    Paint_SelectImage(BlackImage);
+};
+
+void Display::update(){
+    Paint_ClearWindows(0, 0, EPD_2IN13_V2_HEIGHT, EPD_2IN13_V2_WIDTH - Font24.Height, WHITE);
+    Paint_ClearWindows(0, EPD_2IN13_V2_WIDTH - Font24.Height, 170, EPD_2IN13_V2_WIDTH, WHITE);
+    if(views && view_curr >=0)
+      views[view_curr]->drawDisplay();
+    EPD_2IN13_V2_DisplayPart(BlackImage);
+}
+
+void Display::setViews(DisplayWrapper** view_tab, int8_t size){
+    view_count = size;
+    views = view_tab;
+};
+
+void Display::nextView(){ view_curr++; view_curr = view_curr%view_count;}
+void Display::prevView(){ view_curr--; view_curr = (view_curr+view_count) % view_count;}
+
+ 
+
+ICON_tpe getWeatherIcon(int id){
+  if(id>=200 && id<300){ //Thunder
+    return ICON_CLOUD_THUNDER;
+  }else if(id>=300 && id<400){//Drizzle
+    return ICON_CLOUD_RAIN;
+  }else if(id>=500 && id<600){//Rain
+    return ICON_CLOUD_RAIN;
+  }else if(id>=600 && id<700){//Snow
+    return ICON_CLOUD_SNOW;
+  }else if(id>=700 && id<800){//Warning
+    return ICON_WARN;
+  }else if(id>=800 && id<900){//Clear & Cloudy
+    if(id==800)      return ICON_SUN;
+    else if(id==801) return ICON_CLOUD_SUN;
+    else             return ICON_CLOUD;
+  }else{
+    return ICON_WARN;
+  }
+}
+
+void WeatherDisplay::drawDisplay() {
+    if(cowm == NULL || !cowm->valid_weather) return;
+    JsonObject weather_0 = cowm->weather["weather"][0];
+    JsonObject weather_main = cowm->weather["main"];
+    JsonObject weather_wind = cowm->weather["wind"];
+    JsonObject weather_sys = cowm->weather["sys"];
+    if(!weather_0 || !weather_main || !weather_sys || !weather_wind) return;
+    Paint_DrawIcon(0,8, getWeatherIcon(weather_0["id"]), &FontIcon, BLACK, WHITE);
+    Paint_DrawString_EN(2,EPD_2IN13_V2_WIDTH - 4 - Font16.Height,weather_0["description"], &Font16, WHITE, BLACK);
+    Paint_DrawFltUnit(76,0,weather_main["temp"], "C", &Font24, BLACK, WHITE);
+    Paint_DrawFltUnit(186,6,weather_main["feels_like"], "C", &Font12, BLACK, WHITE);
+    Paint_DrawIntUnit(76,24,weather_main["pressure"], "hPa", &Font24, BLACK, WHITE);
+    Paint_DrawIntUnit(76,48,weather_main["humidity"], "%", &Font24, BLACK, WHITE);
+    Paint_DrawFltUnit(76,72,weather_wind["speed"], "m/s", &Font24, BLACK, WHITE);
+    strDateTime sunrisedt = NTPtime::ConvertUnixTimestamp(NTPtime::adjustTimeZone(weather_sys["sunrise"], 1.0, 1));
+    strDateTime sunsetdt  = NTPtime::ConvertUnixTimestamp(NTPtime::adjustTimeZone(weather_sys["sunset"], 1.0, 1));
+    Paint_DrawTime(20, 6, &sunrisedt, &Font12, WHITE, BLACK);
+    Paint_DrawTime(20, 76, &sunsetdt, &Font12, WHITE, BLACK);
+}
+
+void TempDisplay::drawDisplay() { 
+    Paint_DrawIcon(0,Font24.Height, ICON_TEMPERATURE,&FontIcon, BLACK, WHITE);
+    Paint_DrawString_EN(2,0,"Temp", &Font24, WHITE, BLACK);
+    Paint_DrawFltUnit(76,0,sensor->heatidx, "C", &Font24, BLACK, WHITE);
+    Paint_DrawFltUnit(76,36,sensor->temp, "C", &Font24, BLACK, WHITE);
+    Paint_DrawFltUnit(160,36,sensor->hum, "%", &Font24, BLACK, WHITE);
+    Paint_DrawFltUnit(76,64,sensor->pres, "hPa", &Font24, BLACK, WHITE);
+}
+
+void AirDisplay::drawDisplay() { 
+    Paint_DrawIcon(0,Font24.Height, ICON_POLUTION,&FontIcon, BLACK, WHITE);
+    Paint_DrawString_EN(2,0,"Air", &Font24, WHITE, BLACK);
+    Paint_DrawIntUnit(150,10, 69,"", &Font24, BLACK, WHITE);
+}
+
+void MainDisplay::drawDisplay() { 
+    Paint_DrawIcon(0,0, ICON_LOGO,&FontIcon, BLACK, WHITE);
+    Paint_DrawString_EN(60,0,"MAIN", &Font24, WHITE, BLACK);
+    Paint_DrawIntUnit(0,30, 69,"", &Font24, BLACK, WHITE);
+}
+
+void CustomDisplay::drawDisplay() { 
+    Paint_DrawString_EN(60,0,"CUSTOM", &Font24, WHITE, BLACK);
+}

src/display/display.h

@@ -0,0 +1,74 @@
+#ifndef TG_DISPLAY_H
+#define TG_DISPLAY_H
+
+#include "../epd/epd_cfg.h"
+#include "../epd/epd_driver.h"
+#include "../epd/epd_paint.h"
+
+
+#include "../ntp/ntp.h"
+#include "../owm/owm.h"
+#include "../sensor/sensor.h" 
+
+
+#include <Arduino.h>
+#include <Wire.h>
+#include <stdlib.h>
+#include <WiFi.h>
+#include <WiFiMulti.h>
+class DisplayWrapper {
+  public:
+    virtual void drawDisplay();
+};
+
+class Display {
+  public:
+    static void setup();
+    static void drawTime(strDateTime* dt);
+    static void refresh();
+    static void update();
+    static void setViews(DisplayWrapper** views, int8_t size);
+
+    static void nextView();
+    static void prevView();
+};
+ 
+
+class WeatherDisplay: public DisplayWrapper {
+   public:
+        WeatherDisplay(OWM* o) : cowm(o){}
+        void drawDisplay();
+    private:
+        OWM* cowm;
+
+        
+};
+
+class TempDisplay: public DisplayWrapper {
+    public:
+        TempDisplay(Sensor* s) : sensor(s){}
+        void drawDisplay();
+    private:
+        Sensor* sensor;
+};
+
+
+class AirDisplay: public DisplayWrapper {
+    public:
+        AirDisplay(Sensor* s) : sensor(s){}
+        void drawDisplay();
+    private:
+        Sensor* sensor;
+};
+
+class MainDisplay: public DisplayWrapper {
+    public:
+        void drawDisplay();
+};
+
+class CustomDisplay: public DisplayWrapper {
+    public:
+        void drawDisplay();
+};
+
+#endif

src/epd/epd_paint.h

@@ -4,7 +4,7 @@
 #include "debug.h"
 #include "epd_cfg.h"
 #include "fonts/fonts.h"
-#include "../time/time.h"
+#include "../ntp/ntp.h"
 
 /**
  * Image attributes

src/influxdb/influx.h

@@ -118,6 +118,10 @@ class Influx {
             client.writePoint(dp);            
         }
 
+        void record_weather(){
+            record(true,false);
+        }
+
         void record_weather(OWM* owm){
             if(!owm) return;
             if(!owm->valid_weather) return;

src/ntp/ntp.cpp

@@ -222,4 +222,10 @@ strDateTime NTPtime::getNTPtime(float _timeZone, boolean _DayLightSaving) {
 	}
 
 	return _dateTime;
-}
+}
+
+
+void NTPtime::updateNTPtime(){
+	strDateTime ndt = getNTPtime(1.0f, true);
+	if(ndt.valid) dt = ndt;
+};

src/ntp/ntp.h

@@ -2,22 +2,38 @@
 #define NTPtime_h
 
 #include <WiFiUdp.h>
-#include "../time/time.h"
+
+struct strDateTime {
+  byte hour;
+  byte minute;
+  byte second;
+  int year;
+  byte month;
+  byte day;
+  byte dayofWeek;
+  boolean valid;
+};
+
 
 class NTPtime {
   public:
     NTPtime(String NTPtime);
+    strDateTime dt = {0};
+
     strDateTime getNTPtime(float _timeZone, boolean _DayLightSaving);
+
+    void updateNTPtime();
+
     bool setSendInterval(unsigned long _sendInterval);  // in seconds
     bool setRecvTimeout(unsigned long _recvTimeout);    // in seconds
 
-
     static boolean summerTime(unsigned long _timeStamp );
     static strDateTime ConvertUnixTimestamp( unsigned long _tempTimeStamp);
     static boolean daylightSavingTime(unsigned long _timeStamp);
     static unsigned long adjustTimeZone(unsigned long _timeStamp, float _timeZone, byte _DayLightSavingSaving);
 
   private:
+
     bool _sendPhase;
     unsigned long _sentTime;
     unsigned long _sendInterval;

src/time/time.h

@@ -1,16 +0,0 @@
-#ifndef time_h
-#define time_h
-
-struct strDateTime
-{
-  byte hour;
-  byte minute;
-  byte second;
-  int year;
-  byte month;
-  byte day;
-  byte dayofWeek;
-  boolean valid;
-};
-
-#endif

src/timedfun/timedfun.h

@@ -0,0 +1,53 @@
+
+
+#ifndef TG_TIMEDFUN_H
+#define TG_TIMEDFUN_H
+
+#include <map>
+#include <stdint.h>
+#include <Arduino.h>
+
+typedef void (*timedfun_ptr)();
+
+class TimedFun {
+    public:
+        TimedFun(){};
+
+        void registerFun(timedfun_ptr p, uint64_t s){
+            funmap[p] = s;
+        };
+
+        void registerFunCond(timedfun_ptr p, uint64_t s){
+            funmap[p] = s;
+        };
+
+        void minuteTick(){
+            ++counter;
+        }
+
+        void update(){
+            for (const auto &e : funmap){
+                if((counter % e.second == 0) ||
+                  ((counter-old_counter) >= e.second) ||
+                  ((counter%e.second) < (old_counter%e.second))){ 
+                    e.first();
+                    yield();
+                }
+            }
+            old_counter = counter;
+        };
+
+        void updateForce(){
+            for (const auto &e : funmap){
+                e.first();
+            }
+        }
+
+    private:
+        uint64_t counter = 0;
+        uint64_t old_counter = 0;
+        std::map<timedfun_ptr,uint64_t> funmap;
+
+};
+
+#endif