mirror of https://github.com/arendst/Tasmota.git
1411 lines
61 KiB
C++
1411 lines
61 KiB
C++
|
/* Simple firmware for a ESP32 displaying a static image on an EPaper Screen.
|
||
|
|
*
|
||
|
|
* Write an image into a header file using a 3...2...1...0 format per pixel,
|
||
|
|
* for 4 bits color (16 colors - well, greys.) MSB first. At 80 MHz, screen
|
||
|
|
* clears execute in 1.075 seconds and images are drawn in 1.531 seconds.
|
||
|
|
*/
|
||
|
|
#define ESP32
|
||
|
|
|
||
|
|
#include "esp_heap_caps.h"
|
||
|
|
#include "esp_log.h"
|
||
|
|
#include "esp_timer.h"
|
||
|
|
#include "esp_types.h"
|
||
|
|
#include "freertos/FreeRTOS.h"
|
||
|
|
#include "freertos/task.h"
|
||
|
|
#include "sdkconfig.h"
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <string.h>
|
||
|
|
|
||
|
|
#include "epd_driver.h"
|
||
|
|
|
||
|
|
#include "Arduino.h"
|
||
|
|
#define ARDUINOJSON_ENABLE_ARDUINO_STRING 1
|
||
|
|
#include "ArduinoJson.h"
|
||
|
|
#include <HTTPClient.h>
|
||
|
|
|
||
|
|
#include <WiFi.h>
|
||
|
|
#include "time.h"
|
||
|
|
#include <SPI.h>
|
||
|
|
|
||
|
|
#include "owm_credentials.h"
|
||
|
|
//#include "common_functions.h"
|
||
|
|
#include "forecast_record.h"
|
||
|
|
#include "lang.h"
|
||
|
|
|
||
|
|
#define SCREEN_WIDTH EPD_WIDTH
|
||
|
|
#define SCREEN_HEIGHT EPD_HEIGHT
|
||
|
|
|
||
|
|
|
||
|
|
//################ VERSION ##################################################
|
||
|
|
String version = "1.0 / 9.7in"; // Programme version, see change log at end
|
||
|
|
//################ VARIABLES ##################################################
|
||
|
|
|
||
|
|
enum alignment {LEFT, RIGHT, CENTER};
|
||
|
|
#define GxEPD_WHITE 0xFF
|
||
|
|
#define GxEPD_BLACK 0x00
|
||
|
|
#define GRAY 0x88
|
||
|
|
#define LRAY 0xBB
|
||
|
|
#define DRAY 0x44
|
||
|
|
#define autoscale_on true
|
||
|
|
#define autoscale_off false
|
||
|
|
#define barchart_on true
|
||
|
|
#define barchart_off false
|
||
|
|
|
||
|
|
boolean LargeIcon = true, SmallIcon = false;
|
||
|
|
#define Large 28 // For icon drawing, needs to be odd number for best effect
|
||
|
|
#define Small 8 // 6 For icon drawing, needs to be odd number for best effect
|
||
|
|
const byte MaxEvents = 10; // For event reporting, the maximum that can be recorded
|
||
|
|
String Time_str = "--:--:--";
|
||
|
|
String Date_str = "-- -- ----";
|
||
|
|
String EventMessage[MaxEvents]; // strings for Time, Date and Error reporting
|
||
|
|
const byte EventThreshold = 2; // Change to 1 to view all messages on e-paper screen
|
||
|
|
int wifi_signal, CurrentHour = 0, CurrentMin = 0, CurrentSec = 0, EventCnt = 0;
|
||
|
|
|
||
|
|
//################ PROGRAM VARIABLES and OBJECTS ##########################################
|
||
|
|
#define max_readings 8
|
||
|
|
|
||
|
|
Forecast_record_type WxConditions[1];
|
||
|
|
Forecast_record_type WxForecast[max_readings];
|
||
|
|
|
||
|
|
float pressure_readings[max_readings] = {0};
|
||
|
|
float temperature_readings[max_readings] = {0};
|
||
|
|
float humidity_readings[max_readings] = {0};
|
||
|
|
float rain_readings[max_readings] = {0};
|
||
|
|
float snow_readings[max_readings] = {0};
|
||
|
|
|
||
|
|
long SleepDuration = 60; // Sleep time in minutes, aligned to the nearest minute boundary, so if 30 will always update at 00 or 30 past the hour
|
||
|
|
int WakeupTime = 6; // Don't wakeup until after 07:00 to save battery power
|
||
|
|
int SleepTime = 23; // Sleep after (23+1) 00:00 to save battery power
|
||
|
|
long StartTime = 0, SleepTimer = 0;
|
||
|
|
long Delta = 12; // correction factor to compensate the ESP32 speed
|
||
|
|
// Prevents display at xx:59:yy and then xx:00:yy (one minute later) to save power
|
||
|
|
String LocalIP;
|
||
|
|
|
||
|
|
uint8_t *fb;
|
||
|
|
|
||
|
|
//fonts
|
||
|
|
|
||
|
|
#include "opensans8.h"
|
||
|
|
#include "opensans8b.h"
|
||
|
|
#include "opensans12.h"
|
||
|
|
#include "opensans12b.h"
|
||
|
|
#include "opensans16.h"
|
||
|
|
#include "opensans16b.h"
|
||
|
|
#include "opensans24.h"
|
||
|
|
#include "opensans24b.h"
|
||
|
|
|
||
|
|
EpdFont currentFont;
|
||
|
|
|
||
|
|
|
||
|
|
bool obtainWeatherData(WiFiClient& client, const String& RequestType);
|
||
|
|
float mm_to_inches(float value_mm);
|
||
|
|
float hPa_to_inHg(float value_hPa);
|
||
|
|
int JulianDate(int d, int m, int y);
|
||
|
|
float SumOfPrecip(float DataArray[], int readings);
|
||
|
|
String TitleCase(String text);
|
||
|
|
double NormalizedMoonPhase(int d, int m, int y);
|
||
|
|
void Convert_Readings_to_Imperial();
|
||
|
|
bool DecodeWeather(WiFiClient& json, String Type);
|
||
|
|
String ConvertUnixTime(int unix_time);
|
||
|
|
|
||
|
|
void DisplayWeather();
|
||
|
|
void DisplayGeneralInfoSection();
|
||
|
|
void DisplayMainWeatherSection(int x, int y);
|
||
|
|
void DisplayDisplayWindSection(int x, int y, float angle, float windspeed, int Cradius);
|
||
|
|
String WindDegToDirection(float winddirection);
|
||
|
|
void DisplayTemperatureSection(int x, int y, int twidth, int tdepth);
|
||
|
|
void DisplayForecastTextSection(int x, int y , int fwidth, int fdepth);
|
||
|
|
void DisplayForecastWeather(int x, int y, int index);
|
||
|
|
void DisplayPressureSection(int x, int y, int pwidth, int pdepth, float pressure, String slope);
|
||
|
|
void DisplayAstronomySection(int x, int y);
|
||
|
|
void DrawMoon(int x, int y, int dd, int mm, int yy, String hemisphere);
|
||
|
|
String MoonPhase(int d, int m, int y, String hemisphere);
|
||
|
|
void DisplayForecastSection(int x, int y);
|
||
|
|
void DisplayConditionsSection(int x, int y, String IconName, bool IconSize);
|
||
|
|
void arrow(int x, int y, int asize, float aangle, int pwidth, int plength);
|
||
|
|
void DisplayStatusSection(int x, int y, int rssi);
|
||
|
|
void DrawRSSI(int x, int y, int rssi);
|
||
|
|
boolean SetupTime();
|
||
|
|
boolean UpdateLocalTime() ;
|
||
|
|
void DrawBattery(int x, int y);
|
||
|
|
void addcloud(int x, int y, int scale, int linesize);
|
||
|
|
void addraindrop(int x, int y, int scale);
|
||
|
|
void addsnow(int x, int y, int scale, bool IconSize);
|
||
|
|
void addtstorm(int x, int y, int scale);
|
||
|
|
void addsun(int x, int y, int scale, bool IconSize);
|
||
|
|
void addfog(int x, int y, int scale, int linesize, bool IconSize);
|
||
|
|
void Sunny(int x, int y, bool IconSize, String IconName);
|
||
|
|
void MostlySunny(int x, int y, bool IconSize, String IconName) ;
|
||
|
|
void MostlyCloudy(int x, int y, bool IconSize, String IconName);
|
||
|
|
void Cloudy(int x, int y, bool IconSize, String IconName);
|
||
|
|
void Rain(int x, int y, bool IconSize, String IconName);
|
||
|
|
void ExpectRain(int x, int y, bool IconSize, String IconName);
|
||
|
|
void ChanceRain(int x, int y, bool IconSize, String IconName);
|
||
|
|
void Tstorms(int x, int y, bool IconSize, String IconName);
|
||
|
|
void Snow(int x, int y, bool IconSize, String IconName);
|
||
|
|
void Fog(int x, int y, bool IconSize, String IconName);
|
||
|
|
void Haze(int x, int y, bool IconSize, String IconName);
|
||
|
|
void CloudCover(int x, int y, int CCover);
|
||
|
|
void Visibility(int x, int y, String Visi);
|
||
|
|
void addmoon(int x, int y, int scale, bool IconSize);
|
||
|
|
void Nodata(int x, int y, bool IconSize, String IconName);
|
||
|
|
void DrawGraph(int x_pos, int y_pos, int gwidth, int gheight, float Y1Min, float Y1Max, String title, float DataArray[], int readings, boolean auto_scale, boolean barchart_mode);
|
||
|
|
void drawString(int x, int y, String text, alignment align);
|
||
|
|
void drawStringMaxWidth(int x, int y, unsigned int text_width, String text, alignment align);
|
||
|
|
void ReportEvent(String EventMessage[]);
|
||
|
|
void DisplayPrecipitationSection(int x, int y, int pwidth, int pdepth);
|
||
|
|
void DisplayTime();
|
||
|
|
//void VerboseRecordOfResetReason(RESET_REASON reason);
|
||
|
|
|
||
|
|
void fillCircle(int x, int y, int r, uint8_t color);
|
||
|
|
void drawFastHLine(int16_t x0, int16_t y0, int length, uint16_t color);
|
||
|
|
void drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);
|
||
|
|
void drawCircle(int x0, int y0, int r, uint8_t color);
|
||
|
|
void drawRect(int16_t x, int16_t y, int16_t w, int16_t h,uint16_t color);
|
||
|
|
void fillRect(int16_t x, int16_t y, int16_t w, int16_t h,uint16_t color);
|
||
|
|
void fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
|
||
|
|
int16_t x2, int16_t y2, uint16_t color);
|
||
|
|
void drawPixel(int x, int y, uint8_t color) ;
|
||
|
|
void setFont(EpdFont const&font);
|
||
|
|
bool getRandomImage(WiFiClient & client);
|
||
|
|
void drawImage(WiFiClient & client);
|
||
|
|
bool decodeImage(WiFiClient& json);
|
||
|
|
|
||
|
|
|
||
|
|
void Delay(uint32_t millis) { vTaskDelay(millis / portTICK_PERIOD_MS); }
|
||
|
|
|
||
|
|
uint32_t Millis() { return esp_timer_get_time() / 1000; }
|
||
|
|
|
||
|
|
void BeginSleep() {
|
||
|
|
epd_poweroff();
|
||
|
|
long SleepTimer = SleepDuration * 60; //Some ESP32 are too fast to maintain accurate time
|
||
|
|
esp_sleep_enable_timer_wakeup(SleepTimer * 1000000LL);
|
||
|
|
#ifdef BUILTIN_LED
|
||
|
|
pinMode(BUILTIN_LED, INPUT); // If it's On, turn it off and some boards use GPIO-5 for SPI-SS, which remains low after screen use
|
||
|
|
digitalWrite(BUILTIN_LED, HIGH);
|
||
|
|
#endif
|
||
|
|
Serial.println("Entering " + String(SleepTimer) + "-secs of sleep time");
|
||
|
|
Serial.println("Awake for : " + String((millis() - StartTime) / 1000.0, 3) + "-secs");
|
||
|
|
Serial.println("Starting deep-sleep period...");
|
||
|
|
epd_deinit();
|
||
|
|
esp_deep_sleep_start(); // Sleep for e.g. 30 minutes
|
||
|
|
}
|
||
|
|
|
||
|
|
boolean SetupTime() {
|
||
|
|
configTime(gmtOffset_sec, daylightOffset_sec, ntpServer, "time.nist.gov"); //(gmtOffset_sec, daylightOffset_sec, ntpServer)
|
||
|
|
setenv("TZ", Timezone, 1); //setenv()adds the "TZ" variable to the environment with a value TimeZone, only used if set to 1, 0 means no change
|
||
|
|
tzset(); // Set the TZ environment variable
|
||
|
|
delay(100);
|
||
|
|
bool TimeStatus = UpdateLocalTime();
|
||
|
|
return TimeStatus;
|
||
|
|
}
|
||
|
|
|
||
|
|
uint8_t StartWiFi() {
|
||
|
|
Serial.print("\r\nConnecting to: "); Serial.println(String(ssid));
|
||
|
|
IPAddress dns(8, 8, 8, 8); // Google DNS
|
||
|
|
WiFi.disconnect();
|
||
|
|
WiFi.mode(WIFI_STA); // switch off AP
|
||
|
|
WiFi.setAutoConnect(true);
|
||
|
|
WiFi.setAutoReconnect(true);
|
||
|
|
WiFi.begin(ssid, password);
|
||
|
|
unsigned long start = millis();
|
||
|
|
uint8_t connectionStatus;
|
||
|
|
bool AttemptConnection = true;
|
||
|
|
while (AttemptConnection) {
|
||
|
|
connectionStatus = WiFi.status();
|
||
|
|
if (millis() > start + 15000) { // Wait 15-secs maximum
|
||
|
|
AttemptConnection = false;
|
||
|
|
}
|
||
|
|
if (connectionStatus == WL_CONNECTED || connectionStatus == WL_CONNECT_FAILED) {
|
||
|
|
AttemptConnection = false;
|
||
|
|
}
|
||
|
|
delay(50);
|
||
|
|
}
|
||
|
|
if (connectionStatus == WL_CONNECTED) {
|
||
|
|
wifi_signal = WiFi.RSSI(); // Get Wifi Signal strength now, because the WiFi will be turned off to save power!
|
||
|
|
Serial.println("WiFi connected at: " + WiFi.localIP().toString());
|
||
|
|
}
|
||
|
|
else Serial.println("WiFi connection *** FAILED ***");
|
||
|
|
return connectionStatus;
|
||
|
|
}
|
||
|
|
|
||
|
|
void StopWiFi() {
|
||
|
|
WiFi.disconnect();
|
||
|
|
WiFi.mode(WIFI_OFF);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void loop() {
|
||
|
|
|
||
|
|
printf("current temperature: %f\n", epd_ambient_temperature());
|
||
|
|
Delay(300);
|
||
|
|
|
||
|
|
Delay(200000);
|
||
|
|
}
|
||
|
|
|
||
|
|
void setup() {
|
||
|
|
StartTime = millis();
|
||
|
|
Serial.begin(115200);
|
||
|
|
if (StartWiFi() == WL_CONNECTED && SetupTime() == true) {
|
||
|
|
//if ((CurrentHour >= WakeupTime && CurrentHour <= SleepTime)) {
|
||
|
|
byte Attempts = 1;
|
||
|
|
bool RxWeather = false, RxForecast = false;
|
||
|
|
WiFiClient client; // wifi client object
|
||
|
|
while ((RxWeather == false || RxForecast == false) && Attempts <= 2) { // Try up-to 2 time for Weather and Forecast data
|
||
|
|
if (RxWeather == false) RxWeather = obtainWeatherData(client, "weather");
|
||
|
|
if (RxForecast == false) RxForecast = obtainWeatherData(client, "forecast");
|
||
|
|
Attempts++;
|
||
|
|
}
|
||
|
|
if (true || (RxWeather && RxForecast)) { // Only if received both Weather or Forecast proceed
|
||
|
|
StopWiFi(); // Reduces power consumption
|
||
|
|
|
||
|
|
|
||
|
|
epd_poweron();
|
||
|
|
volatile uint32_t t1 = Millis();
|
||
|
|
epd_clear();
|
||
|
|
volatile uint32_t t2 = Millis();
|
||
|
|
printf("EPD clear took %dms.\n", t2 - t1);
|
||
|
|
|
||
|
|
//epd_poweroff();
|
||
|
|
//epd_poweron();
|
||
|
|
|
||
|
|
|
||
|
|
//drawImage(client);
|
||
|
|
DisplayWeather();
|
||
|
|
//DisplayTime();
|
||
|
|
|
||
|
|
t1 = Millis();
|
||
|
|
int temperature = epd_ambient_temperature();
|
||
|
|
if (temperature <= 0) temperature = 25;
|
||
|
|
enum EpdDrawMode mode = (enum EpdDrawMode)(MODE_GC16 | MODE_PACKING_2PPB | PREVIOUSLY_WHITE);
|
||
|
|
epd_draw_base(epd_full_screen(), fb, epd_full_screen(), mode, temperature, NULL, EPD_BUILTIN_WAVEFORM);
|
||
|
|
t2 = Millis();
|
||
|
|
epd_poweroff();
|
||
|
|
|
||
|
|
//display.display(false); // Full screen update mode
|
||
|
|
}
|
||
|
|
//}
|
||
|
|
}
|
||
|
|
BeginSleep();
|
||
|
|
}
|
||
|
|
|
||
|
|
void epd_task(void *pvParameters) {
|
||
|
|
epd_init(EPD_LUT_1K);
|
||
|
|
|
||
|
|
ESP_LOGW("main", "allocating...\n");
|
||
|
|
|
||
|
|
fb = (uint8_t *)heap_caps_malloc(EPD_WIDTH * EPD_HEIGHT / 2, MALLOC_CAP_SPIRAM);
|
||
|
|
memset(fb, 0xFF, EPD_WIDTH * EPD_HEIGHT / 2);
|
||
|
|
|
||
|
|
while (1) {
|
||
|
|
loop();
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
extern "C" {
|
||
|
|
void app_main() {
|
||
|
|
ESP_LOGW("main", "Hello World!\n");
|
||
|
|
|
||
|
|
heap_caps_print_heap_info(MALLOC_CAP_INTERNAL);
|
||
|
|
heap_caps_print_heap_info(MALLOC_CAP_SPIRAM);
|
||
|
|
|
||
|
|
xTaskCreatePinnedToCore(&epd_task, "epd task", 10000, NULL, 2, NULL, 1);
|
||
|
|
|
||
|
|
initArduino();
|
||
|
|
setup();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void drawImage(WiFiClient & client) {
|
||
|
|
getRandomImage(client);
|
||
|
|
}
|
||
|
|
|
||
|
|
void Convert_Readings_to_Imperial() {
|
||
|
|
WxConditions[0].Pressure = hPa_to_inHg(WxConditions[0].Pressure);
|
||
|
|
WxForecast[1].Rainfall = mm_to_inches(WxForecast[1].Rainfall);
|
||
|
|
WxForecast[1].Snowfall = mm_to_inches(WxForecast[1].Snowfall);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool DecodeWeather(WiFiClient& json, String Type) {
|
||
|
|
Serial.print(F("\nCreating object...and "));
|
||
|
|
// allocate the JsonDocument
|
||
|
|
DynamicJsonDocument doc(64 * 1024);
|
||
|
|
// Deserialize the JSON document
|
||
|
|
DeserializationError error = deserializeJson(doc, json);
|
||
|
|
// Test if parsing succeeds.
|
||
|
|
if (error) {
|
||
|
|
Serial.print(F("deserializeJson() failed: "));
|
||
|
|
Serial.println(error.c_str());
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
// convert it to a JsonObject
|
||
|
|
JsonObject root = doc.as<JsonObject>();
|
||
|
|
Serial.println(" Decoding " + Type + " data");
|
||
|
|
if (Type == "weather") {
|
||
|
|
// All Serial.println statements are for diagnostic purposes and not required, remove if not needed
|
||
|
|
WxConditions[0].lon = root["coord"]["lon"].as<float>(); Serial.println(" Lon: "+String(WxConditions[0].lon));
|
||
|
|
WxConditions[0].lat = root["coord"]["lat"].as<float>(); Serial.println(" Lat: "+String(WxConditions[0].lat));
|
||
|
|
WxConditions[0].Main0 = root["weather"][0]["main"].as<char*>(); Serial.println("Main: "+String(WxConditions[0].Main0));
|
||
|
|
WxConditions[0].Forecast0 = root["weather"][0]["description"].as<char*>(); Serial.println("For0: "+String(WxConditions[0].Forecast0));
|
||
|
|
WxConditions[0].Forecast1 = root["weather"][1]["description"].as<char*>(); Serial.println("For1: "+String(WxConditions[0].Forecast1));
|
||
|
|
WxConditions[0].Forecast2 = root["weather"][2]["description"].as<char*>(); Serial.println("For2: "+String(WxConditions[0].Forecast2));
|
||
|
|
WxConditions[0].Icon = root["weather"][0]["icon"].as<char*>(); Serial.println("Icon: "+String(WxConditions[0].Icon));
|
||
|
|
WxConditions[0].Temperature = root["main"]["temp"].as<float>(); Serial.println("Temp: "+String(WxConditions[0].Temperature));
|
||
|
|
WxConditions[0].Pressure = root["main"]["pressure"].as<float>(); Serial.println("Pres: "+String(WxConditions[0].Pressure));
|
||
|
|
WxConditions[0].Humidity = root["main"]["humidity"].as<float>(); Serial.println("Humi: "+String(WxConditions[0].Humidity));
|
||
|
|
WxConditions[0].Low = root["main"]["temp_min"].as<float>(); Serial.println("TLow: "+String(WxConditions[0].Low));
|
||
|
|
WxConditions[0].High = root["main"]["temp_max"].as<float>(); Serial.println("THig: "+String(WxConditions[0].High));
|
||
|
|
WxConditions[0].Windspeed = root["wind"]["speed"].as<float>(); Serial.println("WSpd: "+String(WxConditions[0].Windspeed));
|
||
|
|
WxConditions[0].Winddir = root["wind"]["deg"].as<float>(); Serial.println("WDir: "+String(WxConditions[0].Winddir));
|
||
|
|
WxConditions[0].Cloudcover = root["clouds"]["all"].as<int>(); Serial.println("CCov: "+String(WxConditions[0].Cloudcover)); // in % of cloud cover
|
||
|
|
WxConditions[0].Visibility = root["visibility"].as<int>(); Serial.println("Visi: "+String(WxConditions[0].Visibility)); // in metres
|
||
|
|
WxConditions[0].Rainfall = root["rain"]["1h"].as<float>(); Serial.println("Rain: "+String(WxConditions[0].Rainfall));
|
||
|
|
WxConditions[0].Snowfall = root["snow"]["1h"].as<float>(); Serial.println("Snow: "+String(WxConditions[0].Snowfall));
|
||
|
|
WxConditions[0].Country = root["sys"]["country"].as<char*>(); Serial.println("Ctry: "+String(WxConditions[0].Country));
|
||
|
|
WxConditions[0].Sunrise = root["sys"]["sunrise"].as<int>(); Serial.println("SRis: "+String(WxConditions[0].Sunrise));
|
||
|
|
WxConditions[0].Sunset = root["sys"]["sunset"].as<int>(); Serial.println("SSet: "+String(WxConditions[0].Sunset));
|
||
|
|
WxConditions[0].Timezone = root["timezone"].as<int>(); Serial.println("TZon: "+String(WxConditions[0].Timezone)); }
|
||
|
|
if (Type == "forecast") {
|
||
|
|
//Serial.println(json);
|
||
|
|
Serial.print(F("\nReceiving Forecast period - ")); //------------------------------------------------
|
||
|
|
JsonArray list = root["list"];
|
||
|
|
for (byte r = 0; r < max_readings; r++) {
|
||
|
|
Serial.println("\nPeriod-" + String(r) + "--------------");
|
||
|
|
WxForecast[r].Dt = list[r]["dt"].as<char*>();
|
||
|
|
WxForecast[r].Temperature = list[r]["main"]["temp"].as<float>(); Serial.println("Temp: "+String(WxForecast[r].Temperature));
|
||
|
|
WxForecast[r].Low = list[r]["main"]["temp_min"].as<float>(); Serial.println("TLow: "+String(WxForecast[r].Low));
|
||
|
|
WxForecast[r].High = list[r]["main"]["temp_max"].as<float>(); Serial.println("THig: "+String(WxForecast[r].High));
|
||
|
|
WxForecast[r].Pressure = list[r]["main"]["pressure"].as<float>(); Serial.println("Pres: "+String(WxForecast[r].Pressure));
|
||
|
|
WxForecast[r].Humidity = list[r]["main"]["humidity"].as<float>(); Serial.println("Humi: "+String(WxForecast[r].Humidity));
|
||
|
|
WxForecast[r].Forecast0 = list[r]["weather"][0]["main"].as<char*>(); Serial.println("For0: "+String(WxForecast[r].Forecast0));
|
||
|
|
WxForecast[r].Forecast1 = list[r]["weather"][1]["main"].as<char*>(); Serial.println("For1: "+String(WxForecast[r].Forecast1));
|
||
|
|
WxForecast[r].Forecast2 = list[r]["weather"][2]["main"].as<char*>(); Serial.println("For2: "+String(WxForecast[r].Forecast2));
|
||
|
|
WxForecast[r].Icon = list[r]["weather"][0]["icon"].as<char*>(); Serial.println("Icon: "+String(WxForecast[r].Icon));
|
||
|
|
WxForecast[r].Description = list[r]["weather"][0]["description"].as<char*>(); Serial.println("Desc: "+String(WxForecast[r].Description));
|
||
|
|
WxForecast[r].Cloudcover = list[r]["clouds"]["all"].as<int>(); Serial.println("CCov: "+String(WxForecast[r].Cloudcover)); // in % of cloud cover
|
||
|
|
WxForecast[r].Windspeed = list[r]["wind"]["speed"].as<float>(); Serial.println("WSpd: "+String(WxForecast[r].Windspeed));
|
||
|
|
WxForecast[r].Winddir = list[r]["wind"]["deg"].as<float>(); Serial.println("WDir: "+String(WxForecast[r].Winddir));
|
||
|
|
WxForecast[r].Rainfall = list[r]["rain"]["3h"].as<float>(); Serial.println("Rain: "+String(WxForecast[r].Rainfall));
|
||
|
|
WxForecast[r].Snowfall = list[r]["snow"]["3h"].as<float>(); Serial.println("Snow: "+String(WxForecast[r].Snowfall));
|
||
|
|
WxForecast[r].Period = list[r]["dt_txt"].as<char*>(); Serial.println("Peri: "+String(WxForecast[r].Period));
|
||
|
|
}
|
||
|
|
//------------------------------------------
|
||
|
|
float pressure_trend = WxForecast[0].Pressure - WxForecast[2].Pressure; // Measure pressure slope between ~now and later
|
||
|
|
pressure_trend = ((int)(pressure_trend * 10)) / 10.0; // Remove any small variations less than 0.1
|
||
|
|
WxConditions[0].Trend = "0";
|
||
|
|
if (pressure_trend > 0) WxConditions[0].Trend = "+";
|
||
|
|
if (pressure_trend < 0) WxConditions[0].Trend = "-";
|
||
|
|
if (pressure_trend == 0) WxConditions[0].Trend = "0";
|
||
|
|
|
||
|
|
if (Units == "I") Convert_Readings_to_Imperial();
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
//#########################################################################################
|
||
|
|
String ConvertUnixTime(int unix_time) {
|
||
|
|
// Returns either '21:12 ' or ' 09:12pm' depending on Units mode
|
||
|
|
time_t tm = unix_time;
|
||
|
|
struct tm *now_tm = localtime(&tm);
|
||
|
|
char output[40];
|
||
|
|
if (Units == "M") {
|
||
|
|
strftime(output, sizeof(output), "%H:%M %d/%m/%y", now_tm);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
strftime(output, sizeof(output), "%I:%M%P %m/%d/%y", now_tm);
|
||
|
|
}
|
||
|
|
return output;
|
||
|
|
}
|
||
|
|
//#########################################################################################
|
||
|
|
//WiFiClient client; // wifi client object
|
||
|
|
|
||
|
|
bool decodeImage(WiFiClient& json) {
|
||
|
|
Serial.print(F("\nIMG creating object...and "));
|
||
|
|
// allocate the JsonDocument
|
||
|
|
DynamicJsonDocument doc(1200 * 825);
|
||
|
|
// Deserialize the JSON document
|
||
|
|
DeserializationError error = deserializeJson(doc, json);
|
||
|
|
// Test if parsing succeeds.
|
||
|
|
if (error) {
|
||
|
|
Serial.print(F("IMG deserializeJson() failed: "));
|
||
|
|
Serial.println(error.c_str());
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
// convert it to a JsonObject
|
||
|
|
JsonArray array = doc.as<JsonArray>();
|
||
|
|
Serial.println("IMG Decoding ...");
|
||
|
|
uint8_t img_data[EPD_WIDTH * EPD_HEIGHT / 2];
|
||
|
|
int i = 0;
|
||
|
|
for(JsonVariant v : array) {
|
||
|
|
img_data[i] = v.as<uint16_t>();
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
//img_data = root["data"].as<JsonArray>();
|
||
|
|
|
||
|
|
EpdRect area = {
|
||
|
|
.x = 0,
|
||
|
|
.y = 0,
|
||
|
|
.width = 1200,
|
||
|
|
.height = 825,
|
||
|
|
};
|
||
|
|
epd_copy_to_framebuffer(area, (uint8_t *)img_data, fb);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool getRandomImage(WiFiClient & client) {
|
||
|
|
client.stop(); // close connection before sending a new request
|
||
|
|
HTTPClient http;
|
||
|
|
const char imgServer[] = "bb.org.ua";
|
||
|
|
String uri = "/get_random_image.php";
|
||
|
|
http.begin(client, imgServer, 80, uri);
|
||
|
|
int httpCode = http.GET();
|
||
|
|
if(httpCode == HTTP_CODE_OK) {
|
||
|
|
if (!decodeImage(http.getStream())) return false;
|
||
|
|
client.stop();
|
||
|
|
http.end();
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Serial.printf("connection failed, error: %s", http.errorToString(httpCode).c_str());
|
||
|
|
client.stop();
|
||
|
|
http.end();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
http.end();
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool obtainWeatherData(WiFiClient & client, const String & RequestType) {
|
||
|
|
const String units = (Units == "M" ? "metric" : "imperial");
|
||
|
|
client.stop(); // close connection before sending a new request
|
||
|
|
HTTPClient http;
|
||
|
|
String uri = "/data/2.5/" + RequestType + "?q=" + City + "," + Country + "&APPID=" + apikey + "&mode=json&units=" + units + "&lang=" + Language;
|
||
|
|
if(RequestType != "weather")
|
||
|
|
{
|
||
|
|
uri += "&cnt=" + String(max_readings);
|
||
|
|
}
|
||
|
|
//http.begin(uri,test_root_ca); //HTTPS example connection
|
||
|
|
http.begin(client, server, 80, uri);
|
||
|
|
int httpCode = http.GET();
|
||
|
|
if(httpCode == HTTP_CODE_OK) {
|
||
|
|
if (!DecodeWeather(http.getStream(), RequestType)) return false;
|
||
|
|
client.stop();
|
||
|
|
http.end();
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Serial.printf("connection failed, error: %s", http.errorToString(httpCode).c_str());
|
||
|
|
client.stop();
|
||
|
|
http.end();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
http.end();
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
float mm_to_inches(float value_mm)
|
||
|
|
{
|
||
|
|
return 0.0393701 * value_mm;
|
||
|
|
}
|
||
|
|
|
||
|
|
float hPa_to_inHg(float value_hPa)
|
||
|
|
{
|
||
|
|
return 0.02953 * value_hPa;
|
||
|
|
}
|
||
|
|
|
||
|
|
int JulianDate(int d, int m, int y) {
|
||
|
|
int mm, yy, k1, k2, k3, j;
|
||
|
|
yy = y - (int)((12 - m) / 10);
|
||
|
|
mm = m + 9;
|
||
|
|
if (mm >= 12) mm = mm - 12;
|
||
|
|
k1 = (int)(365.25 * (yy + 4712));
|
||
|
|
k2 = (int)(30.6001 * mm + 0.5);
|
||
|
|
k3 = (int)((int)((yy / 100) + 49) * 0.75) - 38;
|
||
|
|
// 'j' for dates in Julian calendar:
|
||
|
|
j = k1 + k2 + d + 59 + 1;
|
||
|
|
if (j > 2299160) j = j - k3; // 'j' is the Julian date at 12h UT (Universal Time) For Gregorian calendar:
|
||
|
|
return j;
|
||
|
|
}
|
||
|
|
|
||
|
|
float SumOfPrecip(float DataArray[], int readings) {
|
||
|
|
float sum = 0;
|
||
|
|
for (int i = 0; i <= readings; i++) {
|
||
|
|
sum += DataArray[i];
|
||
|
|
}
|
||
|
|
return sum;
|
||
|
|
}
|
||
|
|
|
||
|
|
String TitleCase(String text){
|
||
|
|
if (text.length() > 0) {
|
||
|
|
String temp_text = text.substring(0,1);
|
||
|
|
temp_text.toUpperCase();
|
||
|
|
return temp_text + text.substring(1); // Title-case the string
|
||
|
|
}
|
||
|
|
else return text;
|
||
|
|
}
|
||
|
|
|
||
|
|
double NormalizedMoonPhase(int d, int m, int y) {
|
||
|
|
int j = JulianDate(d, m, y);
|
||
|
|
//Calculate the approximate phase of the moon
|
||
|
|
double Phase = (j + 4.867) / 29.53059;
|
||
|
|
return (Phase - (int) Phase);
|
||
|
|
}
|
||
|
|
|
||
|
|
void DisplayWeather() { // 9.7" e-paper display is 1200x825 resolution
|
||
|
|
DisplayStatusSection(990, 20, wifi_signal); // Wi-Fi signal strength and Battery voltage
|
||
|
|
DisplayGeneralInfoSection(); // Top line of the display
|
||
|
|
|
||
|
|
DisplayDisplayWindSection(1000, 210, WxConditions[0].Winddir, WxConditions[0].Windspeed, 130);
|
||
|
|
DisplayAstronomySection(920, 720); // Astronomy section Sun rise/set, Moon phase and Moon icon
|
||
|
|
DisplayMainWeatherSection(137, 130); // Centre section of display for Location, temperature, Weather report, current Wx Symbol and wind direction
|
||
|
|
DisplayForecastSection(10, 330); // 3hr forecast boxes
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void DisplayGeneralInfoSection() {
|
||
|
|
setFont(OpenSans8B);
|
||
|
|
drawString(4, 2, City, LEFT);
|
||
|
|
// Uncomment the next line if the display of IP- and MAC-Adddress is wanted
|
||
|
|
//drawString(SCREEN_WIDTH - 150, 20, "IP=" + LocalIP + ", MAC=" + WiFi.macAddress() ,RIGHT);
|
||
|
|
drawLine(5, 30, SCREEN_WIDTH - 8, 30, 0xAA);
|
||
|
|
drawString(200, 2, Date_str, LEFT);
|
||
|
|
drawString(400, 2, TXT_UPDATED + Time_str, LEFT);
|
||
|
|
}
|
||
|
|
|
||
|
|
void DisplayMainWeatherSection(int x, int y) { // (x=500, y=190)
|
||
|
|
DisplayConditionsSection(x + 3, y + 50, WxConditions[0].Icon, LargeIcon);
|
||
|
|
DisplayTemperatureSection(x + 230, y - 30, 180, 170);
|
||
|
|
DisplayPressureSection(x + 160, y + 70, 180, 170, WxConditions[0].Pressure, WxConditions[0].Trend);
|
||
|
|
DisplayPrecipitationSection(x + 268, y - 8, 181, 170);
|
||
|
|
//DisplayForecastTextSection(x + 147, y + 22, 548, 90);
|
||
|
|
}
|
||
|
|
|
||
|
|
void DisplayDisplayWindSection(int x, int y, float angle, float windspeed, int Cradius) {
|
||
|
|
arrow(x, y, Cradius - 22, angle, 18, 33); // Show wind direction on outer circle of width and length
|
||
|
|
setFont(OpenSans12);
|
||
|
|
int dxo, dyo, dxi, dyi;
|
||
|
|
drawCircle(x, y, Cradius, GxEPD_BLACK); // Draw compass circle
|
||
|
|
drawCircle(x, y, Cradius + 1, GxEPD_BLACK); // Draw compass circle
|
||
|
|
drawCircle(x, y, Cradius * 0.7, GxEPD_BLACK); // Draw compass inner circle
|
||
|
|
for (float a = 0; a < 360; a = a + 22.5) {
|
||
|
|
dxo = Cradius * cos((a - 90) * PI / 180);
|
||
|
|
dyo = Cradius * sin((a - 90) * PI / 180);
|
||
|
|
if (a == 45) drawString(dxo + x + 27, dyo + y - 20, TXT_NE, CENTER);
|
||
|
|
if (a == 135) drawString(dxo + x + 27, dyo + y - 2, TXT_SE, CENTER);
|
||
|
|
if (a == 225) drawString(dxo + x - 43, dyo + y - 2, TXT_SW, CENTER);
|
||
|
|
if (a == 315) drawString(dxo + x - 43, dyo + y - 20, TXT_NW, CENTER);
|
||
|
|
dxi = dxo * 0.9;
|
||
|
|
dyi = dyo * 0.9;
|
||
|
|
drawLine(dxo + x, dyo + y, dxi + x, dyi + y, GxEPD_BLACK);
|
||
|
|
dxo = dxo * 0.7;
|
||
|
|
dyo = dyo * 0.7;
|
||
|
|
dxi = dxo * 0.9;
|
||
|
|
dyi = dyo * 0.9;
|
||
|
|
drawLine(dxo + x, dyo + y, dxi + x, dyi + y, GxEPD_BLACK);
|
||
|
|
}
|
||
|
|
drawString(x - 3, y - Cradius - 30, TXT_N, CENTER);
|
||
|
|
drawString(x - 5, y + Cradius + 18, TXT_S, CENTER);
|
||
|
|
drawString(x - Cradius - 27, y - 11, TXT_W, CENTER);
|
||
|
|
drawString(x + Cradius + 15, y - 11, TXT_E, CENTER);
|
||
|
|
drawString(x - 12, y - 57, WindDegToDirection(angle), CENTER);
|
||
|
|
drawString(x + 3, y + 50, String(angle, 0) + "°", CENTER);
|
||
|
|
setFont(OpenSans24B);
|
||
|
|
drawString(x + 3, y - 16, String(windspeed, 1), CENTER);
|
||
|
|
//setFont(OpenSans12);
|
||
|
|
//drawString(x + 16, y -12, (Units == "M" ? "m/s" : "mph"), LEFT);
|
||
|
|
}
|
||
|
|
|
||
|
|
String WindDegToDirection(float winddirection) {
|
||
|
|
if (winddirection >= 348.75 || winddirection < 11.25) return TXT_N;
|
||
|
|
if (winddirection >= 11.25 && winddirection < 33.75) return TXT_NNE;
|
||
|
|
if (winddirection >= 33.75 && winddirection < 56.25) return TXT_NE;
|
||
|
|
if (winddirection >= 56.25 && winddirection < 78.75) return TXT_ENE;
|
||
|
|
if (winddirection >= 78.75 && winddirection < 101.25) return TXT_E;
|
||
|
|
if (winddirection >= 101.25 && winddirection < 123.75) return TXT_ESE;
|
||
|
|
if (winddirection >= 123.75 && winddirection < 146.25) return TXT_SE;
|
||
|
|
if (winddirection >= 146.25 && winddirection < 168.75) return TXT_SSE;
|
||
|
|
if (winddirection >= 168.75 && winddirection < 191.25) return TXT_S;
|
||
|
|
if (winddirection >= 191.25 && winddirection < 213.75) return TXT_SSW;
|
||
|
|
if (winddirection >= 213.75 && winddirection < 236.25) return TXT_SW;
|
||
|
|
if (winddirection >= 236.25 && winddirection < 258.75) return TXT_WSW;
|
||
|
|
if (winddirection >= 258.75 && winddirection < 281.25) return TXT_W;
|
||
|
|
if (winddirection >= 281.25 && winddirection < 303.75) return TXT_WNW;
|
||
|
|
if (winddirection >= 303.75 && winddirection < 326.25) return TXT_NW;
|
||
|
|
if (winddirection >= 326.25 && winddirection < 348.75) return TXT_NNW;
|
||
|
|
return "?";
|
||
|
|
}
|
||
|
|
|
||
|
|
void DisplayTemperatureSection(int x, int y, int twidth, int tdepth) {
|
||
|
|
//setFont(OpenSans24/*24b*/);
|
||
|
|
setFont(OpenSans24B);
|
||
|
|
drawString(x, y, String(WxConditions[0].Temperature, 1) + "°C", CENTER); // Show current Temperature
|
||
|
|
setFont(OpenSans16);
|
||
|
|
drawString(x, y + 40, String(WxConditions[0].High, 0) + "° | " + String(WxConditions[0].Low, 0) + "°", CENTER); // Show forecast high and Low
|
||
|
|
}
|
||
|
|
|
||
|
|
void DisplayForecastTextSection(int x, int y , int fwidth, int fdepth) {
|
||
|
|
String Wx_Description;
|
||
|
|
setFont(OpenSans24/*18*/);
|
||
|
|
if (Language == "DE")
|
||
|
|
Wx_Description = WxConditions[0].Forecast0;
|
||
|
|
else {
|
||
|
|
Wx_Description = WxConditions[0].Main0;
|
||
|
|
if (WxConditions[0].Forecast0 != "") Wx_Description += " (" + WxConditions[0].Forecast0;
|
||
|
|
}
|
||
|
|
if (WxConditions[0].Forecast1 != "") Wx_Description += ", " + WxConditions[0].Forecast1;
|
||
|
|
if (WxConditions[0].Forecast2 != "") Wx_Description += ", " + WxConditions[0].Forecast2;
|
||
|
|
if (Wx_Description.indexOf("(") > 0) Wx_Description += ")";
|
||
|
|
int MsgWidth = 43; // Using proportional fonts, so be aware of making it too wide!
|
||
|
|
if (Language == "DE") drawStringMaxWidth(x + 30, y + 40, MsgWidth, Wx_Description, LEFT); // Leave German text in original format, 28 character screen width at this font size
|
||
|
|
else drawStringMaxWidth(x + 30, y + 40, MsgWidth, TitleCase(Wx_Description), LEFT); // 28 character screen width at this font size
|
||
|
|
}
|
||
|
|
|
||
|
|
void DisplayPressureSection(int x, int y, int pwidth, int pdepth, float pressure, String slope) {
|
||
|
|
pressure = pressure * 0.750062; //convert to mmhg
|
||
|
|
setFont(OpenSans12/*24b*/);
|
||
|
|
drawString(x, y, String(pressure, (Units == "M"?0:1)) + (Units == "M" ? "mm" : "in"), LEFT);
|
||
|
|
}
|
||
|
|
|
||
|
|
void DisplayForecastWeather(int x, int y, int index) {
|
||
|
|
int fwidth = 103;
|
||
|
|
x = x + fwidth * (index - 1);
|
||
|
|
DisplayConditionsSection(x + fwidth / 2, y + 90, WxForecast[index].Icon, SmallIcon);
|
||
|
|
setFont(OpenSans8B);
|
||
|
|
drawString(x + fwidth / 2 - 10, y + 30, String(WxForecast[index].Period.substring(11, 16)), CENTER);
|
||
|
|
drawString(x + fwidth / 2 + 0, y + 130, String(WxForecast[index].High, 0) + "°/" + String(WxForecast[index].Low, 0) + "°", CENTER);
|
||
|
|
}
|
||
|
|
|
||
|
|
void DisplayPrecipitationSection(int x, int y, int pwidth, int pdepth) {
|
||
|
|
setFont(OpenSans12);
|
||
|
|
if (WxForecast[1].Rainfall >= 0.005) { // Ignore small amounts
|
||
|
|
drawString(x, y + 80, String(WxForecast[1].Rainfall, 2) + (Units == "M" ? "mm" : "in"), LEFT); // Only display rainfall total today if > 0
|
||
|
|
addraindrop(x + 102, y + 84, 7);
|
||
|
|
}
|
||
|
|
if (WxForecast[1].Snowfall >= 0.005) {// Ignore small amounts
|
||
|
|
drawString(x, y + 110, String(WxForecast[1].Snowfall, 2) + (Units == "M" ? "mm" : "in") + " **", LEFT); // Only display snowfall total today if > 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void DisplayAstronomySection(int x, int y) {
|
||
|
|
setFont(OpenSans12B);
|
||
|
|
drawString(x + 14, y + 34, ConvertUnixTime(WxConditions[0].Sunrise).substring(0, 5) + " " + TXT_SUNRISE, LEFT);
|
||
|
|
drawString(x + 14, y + 64, ConvertUnixTime(WxConditions[0].Sunset).substring(0, 5) + " " + TXT_SUNSET, LEFT);
|
||
|
|
time_t now = time(NULL);
|
||
|
|
struct tm * now_utc = gmtime(&now);
|
||
|
|
const int day_utc = now_utc->tm_mday;
|
||
|
|
const int month_utc = now_utc->tm_mon + 1;
|
||
|
|
const int year_utc = now_utc->tm_year + 1900;
|
||
|
|
//drawString(x + 14, y + 94, MoonPhase(day_utc, month_utc, year_utc, Hemisphere), LEFT);
|
||
|
|
DrawMoon(x + 155, y - 20, day_utc, month_utc, year_utc, Hemisphere);
|
||
|
|
}
|
||
|
|
|
||
|
|
void DrawMoon(int x, int y, int dd, int mm, int yy, String hemisphere) {
|
||
|
|
const int diameter = 75;
|
||
|
|
double Phase = NormalizedMoonPhase(dd, mm, yy);
|
||
|
|
hemisphere.toLowerCase();
|
||
|
|
if (hemisphere == "south") Phase = 1 - Phase;
|
||
|
|
// Draw dark part of moon
|
||
|
|
fillCircle(x + diameter - 1, y + diameter, diameter / 2 + 1, GxEPD_BLACK);
|
||
|
|
const int number_of_lines = 90;
|
||
|
|
for (double Ypos = 0; Ypos <= number_of_lines / 2; Ypos++) {
|
||
|
|
double Xpos = sqrt(number_of_lines / 2 * number_of_lines / 2 - Ypos * Ypos);
|
||
|
|
// Determine the edges of the lighted part of the moon
|
||
|
|
double Rpos = 2 * Xpos;
|
||
|
|
double Xpos1, Xpos2;
|
||
|
|
if (Phase < 0.5) {
|
||
|
|
Xpos1 = -Xpos;
|
||
|
|
Xpos2 = Rpos - 2 * Phase * Rpos - Xpos;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
Xpos1 = Xpos;
|
||
|
|
Xpos2 = Xpos - 2 * Phase * Rpos + Rpos;
|
||
|
|
}
|
||
|
|
// Draw light part of moon
|
||
|
|
double pW1x = (Xpos1 + number_of_lines) / number_of_lines * diameter + x;
|
||
|
|
double pW1y = (number_of_lines - Ypos) / number_of_lines * diameter + y;
|
||
|
|
double pW2x = (Xpos2 + number_of_lines) / number_of_lines * diameter + x;
|
||
|
|
double pW2y = (number_of_lines - Ypos) / number_of_lines * diameter + y;
|
||
|
|
double pW3x = (Xpos1 + number_of_lines) / number_of_lines * diameter + x;
|
||
|
|
double pW3y = (Ypos + number_of_lines) / number_of_lines * diameter + y;
|
||
|
|
double pW4x = (Xpos2 + number_of_lines) / number_of_lines * diameter + x;
|
||
|
|
double pW4y = (Ypos + number_of_lines) / number_of_lines * diameter + y;
|
||
|
|
drawLine(pW1x, pW1y, pW2x, pW2y, GxEPD_WHITE);
|
||
|
|
drawLine(pW3x, pW3y, pW4x, pW4y, GxEPD_WHITE);
|
||
|
|
}
|
||
|
|
drawCircle(x + diameter - 1, y + diameter, diameter / 2, GxEPD_BLACK);
|
||
|
|
}
|
||
|
|
|
||
|
|
String MoonPhase(int d, int m, int y, String hemisphere) {
|
||
|
|
int c, e;
|
||
|
|
double jd;
|
||
|
|
int b;
|
||
|
|
if (m < 3) {
|
||
|
|
y--;
|
||
|
|
m += 12;
|
||
|
|
}
|
||
|
|
++m;
|
||
|
|
c = 365.25 * y;
|
||
|
|
e = 30.6 * m;
|
||
|
|
jd = c + e + d - 694039.09; /* jd is total days elapsed */
|
||
|
|
jd /= 29.53059; /* divide by the moon cycle (29.53 days) */
|
||
|
|
b = jd; /* int(jd) -> b, take integer part of jd */
|
||
|
|
jd -= b; /* subtract integer part to leave fractional part of original jd */
|
||
|
|
b = jd * 8 + 0.5; /* scale fraction from 0-8 and round by adding 0.5 */
|
||
|
|
b = b & 7; /* 0 and 8 are the same phase so modulo 8 for 0 */
|
||
|
|
if (hemisphere == "south") b = 7 - b;
|
||
|
|
if (b == 0) return TXT_MOON_NEW; // New; 0% illuminated
|
||
|
|
if (b == 1) return TXT_MOON_WAXING_CRESCENT; // Waxing crescent; 25% illuminated
|
||
|
|
if (b == 2) return TXT_MOON_FIRST_QUARTER; // First quarter; 50% illuminated
|
||
|
|
if (b == 3) return TXT_MOON_WAXING_GIBBOUS; // Waxing gibbous; 75% illuminated
|
||
|
|
if (b == 4) return TXT_MOON_FULL; // Full; 100% illuminated
|
||
|
|
if (b == 5) return TXT_MOON_WANING_GIBBOUS; // Waning gibbous; 75% illuminated
|
||
|
|
if (b == 6) return TXT_MOON_THIRD_QUARTER; // Third quarter; 50% illuminated
|
||
|
|
if (b == 7) return TXT_MOON_WANING_CRESCENT; // Waning crescent; 25% illuminated
|
||
|
|
return "";
|
||
|
|
}
|
||
|
|
|
||
|
|
void DisplayForecastSection(int x, int y) {
|
||
|
|
setFont(OpenSans12/*9*/);
|
||
|
|
int f = 1;
|
||
|
|
do {
|
||
|
|
DisplayForecastWeather(x, y, f);
|
||
|
|
f++;
|
||
|
|
} while (f < max_readings);
|
||
|
|
// Pre-load temporary arrays with with data - because C parses by reference
|
||
|
|
int r = 1;
|
||
|
|
do {
|
||
|
|
if (Units == "I") pressure_readings[r] = WxForecast[r].Pressure * 0.02953; else pressure_readings[r] = WxForecast[r].Pressure;
|
||
|
|
if (Units == "I") rain_readings[r] = WxForecast[r].Rainfall * 0.0393701; else rain_readings[r] = WxForecast[r].Rainfall;
|
||
|
|
if (Units == "I") snow_readings[r] = WxForecast[r].Snowfall * 0.0393701; else snow_readings[r] = WxForecast[r].Snowfall;
|
||
|
|
temperature_readings[r] = WxForecast[r].Temperature;
|
||
|
|
humidity_readings[r] = WxForecast[r].Humidity;
|
||
|
|
r++;
|
||
|
|
} while (r <= max_readings);
|
||
|
|
|
||
|
|
int gwidth = 230, gheight = 150;
|
||
|
|
int gx = (SCREEN_WIDTH - gwidth * 4) / 5 + 7;
|
||
|
|
int gy = (SCREEN_HEIGHT - gheight - 50);
|
||
|
|
int gap = gwidth + gx;
|
||
|
|
//setFont(OpenSans12/*18*/);
|
||
|
|
//drawString(SCREEN_WIDTH / 2 - 50, gy - 50, TXT_FORECAST_VALUES, CENTER); // Based on a graph height of 60
|
||
|
|
//setFont(OpenSans12);
|
||
|
|
// (x,y,width,height,MinValue, MaxValue, Title, Data Array, AutoScale, ChartMode)
|
||
|
|
//DrawGraph(gx + 0 * gap, gy, gwidth, gheight, 900, 1050, Units == "M" ? TXT_PRESSURE_HPA : TXT_PRESSURE_IN, pressure_readings, max_readings, autoscale_on, barchart_off);
|
||
|
|
DrawGraph(gx + 0 * gap, gy, gwidth, gheight, 10, 30, Units == "M" ? TXT_TEMPERATURE_C : TXT_TEMPERATURE_F, temperature_readings, max_readings, autoscale_on, barchart_off);
|
||
|
|
//DrawGraph(gx + 1 * gap, gy, gwidth, gheight, 0, 100, TXT_HUMIDITY_PERCENT, humidity_readings, max_readings, autoscale_off, barchart_off);
|
||
|
|
if (SumOfPrecip(rain_readings, max_readings) >= SumOfPrecip(snow_readings, max_readings))
|
||
|
|
DrawGraph(gx + 1 * gap + 5, gy, gwidth, gheight, 0, 30, Units == "M" ? TXT_RAINFALL_MM : TXT_RAINFALL_IN, rain_readings, max_readings, autoscale_on, barchart_on);
|
||
|
|
else DrawGraph(gx + 1 * gap + 5, gy, gwidth, gheight, 0, 30, Units == "M" ? TXT_SNOWFALL_MM : TXT_SNOWFALL_IN, snow_readings, max_readings, autoscale_on, barchart_on);
|
||
|
|
}
|
||
|
|
|
||
|
|
void DisplayConditionsSection(int x, int y, String IconName, bool IconSize) {
|
||
|
|
Serial.println("Icon name: " + IconName);
|
||
|
|
if (IconName == "01d" || IconName == "01n") Sunny(x, y, IconSize, IconName);
|
||
|
|
else if (IconName == "02d" || IconName == "02n") MostlySunny(x, y, IconSize, IconName);
|
||
|
|
else if (IconName == "03d" || IconName == "03n") Cloudy(x, y, IconSize, IconName);
|
||
|
|
else if (IconName == "04d" || IconName == "04n") MostlySunny(x, y, IconSize, IconName);
|
||
|
|
else if (IconName == "09d" || IconName == "09n") ChanceRain(x, y, IconSize, IconName);
|
||
|
|
else if (IconName == "10d" || IconName == "10n") Rain(x, y, IconSize, IconName);
|
||
|
|
else if (IconName == "11d" || IconName == "11n") Tstorms(x, y, IconSize, IconName);
|
||
|
|
else if (IconName == "13d" || IconName == "13n") Snow(x, y, IconSize, IconName);
|
||
|
|
else if (IconName == "50d") Haze(x, y, IconSize, IconName);
|
||
|
|
else if (IconName == "50n") Fog(x, y, IconSize, IconName);
|
||
|
|
else Nodata(x, y, IconSize, IconName);
|
||
|
|
if (IconSize == LargeIcon) {
|
||
|
|
setFont(OpenSans16B/*18*/);
|
||
|
|
drawString(x + 360, y - 74, String(WxConditions[0].Humidity, 0) + "%", CENTER);
|
||
|
|
if (WxConditions[0].Visibility > 0) Visibility(x - 100, y + 130, String(WxConditions[0].Visibility) + "M");
|
||
|
|
if (WxConditions[0].Cloudcover > 0) CloudCover(x + 60, y + 130, WxConditions[0].Cloudcover);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void arrow(int x, int y, int asize, float aangle, int pwidth, int plength) {
|
||
|
|
float dx = (asize - 10) * cos((aangle - 90) * PI / 180) + x; // calculate X position
|
||
|
|
float dy = (asize - 10) * sin((aangle - 90) * PI / 180) + y; // calculate Y position
|
||
|
|
float x1 = 0; float y1 = plength;
|
||
|
|
float x2 = pwidth / 2; float y2 = pwidth / 2;
|
||
|
|
float x3 = -pwidth / 2; float y3 = pwidth / 2;
|
||
|
|
float angle = aangle * PI / 180 - 135;
|
||
|
|
float xx1 = x1 * cos(angle) - y1 * sin(angle) + dx;
|
||
|
|
float yy1 = y1 * cos(angle) + x1 * sin(angle) + dy;
|
||
|
|
float xx2 = x2 * cos(angle) - y2 * sin(angle) + dx;
|
||
|
|
float yy2 = y2 * cos(angle) + x2 * sin(angle) + dy;
|
||
|
|
float xx3 = x3 * cos(angle) - y3 * sin(angle) + dx;
|
||
|
|
float yy3 = y3 * cos(angle) + x3 * sin(angle) + dy;
|
||
|
|
fillTriangle(xx1, yy1, xx3, yy3, xx2, yy2, GxEPD_BLACK);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void DisplayStatusSection(int x, int y, int rssi) {
|
||
|
|
setFont(OpenSans8B);
|
||
|
|
DrawRSSI(x, y + 4, rssi);
|
||
|
|
//DrawBattery(x + 100, y + 4);
|
||
|
|
}
|
||
|
|
|
||
|
|
void DrawRSSI(int x, int y, int rssi) {
|
||
|
|
int WIFIsignal = 0;
|
||
|
|
int xpos = 1;
|
||
|
|
for (int _rssi = -100; _rssi <= rssi; _rssi = _rssi + 20) {
|
||
|
|
if (_rssi <= -20) WIFIsignal = 30; // <-20dbm displays 5-bars
|
||
|
|
if (_rssi <= -40) WIFIsignal = 24; // -40dbm to -21dbm displays 4-bars
|
||
|
|
if (_rssi <= -60) WIFIsignal = 18; // -60dbm to -41dbm displays 3-bars
|
||
|
|
if (_rssi <= -80) WIFIsignal = 12; // -80dbm to -61dbm displays 2-bars
|
||
|
|
if (_rssi <= -100) WIFIsignal = 6; // -100dbm to -81dbm displays 1-bar
|
||
|
|
fillRect(x + xpos * 8, y - WIFIsignal, 7, WIFIsignal, GxEPD_BLACK);
|
||
|
|
xpos++;
|
||
|
|
}
|
||
|
|
//fillRect(x, y - 1, 5, 1, GxEPD_BLACK);
|
||
|
|
//drawString(x + 6, y + 10, String(rssi) + "dBm", CENTER);
|
||
|
|
}
|
||
|
|
|
||
|
|
boolean UpdateLocalTime() {
|
||
|
|
struct tm timeinfo;
|
||
|
|
char time_output[30], day_output[30], update_time[30];
|
||
|
|
while (!getLocalTime(&timeinfo, 5000)) { // Wait for 5-sec for time to synchronise
|
||
|
|
Serial.println("Failed to obtain time");
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
CurrentHour = timeinfo.tm_hour;
|
||
|
|
CurrentMin = timeinfo.tm_min;
|
||
|
|
CurrentSec = timeinfo.tm_sec;
|
||
|
|
//See http://www.cplusplus.com/reference/ctime/strftime/
|
||
|
|
Serial.println("***Current time***");
|
||
|
|
Serial.println(&timeinfo, "%a %b %d %Y %H:%M:%S"); // Displays: Saturday, June 24 2017 14:05:49
|
||
|
|
if (Units == "M") {
|
||
|
|
if ((Language == "CZ") || (Language == "DE") || (Language == "NL") || (Language == "PL")) {
|
||
|
|
sprintf(day_output, "%s, %02u. %s %04u", weekday_D[timeinfo.tm_wday], timeinfo.tm_mday, month_M[timeinfo.tm_mon], (timeinfo.tm_year) + 1900); // day_output >> So., 23. Juni 2019 <<
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
sprintf(day_output, "%s, %02u %s %04u", weekday_D[timeinfo.tm_wday], timeinfo.tm_mday, month_M[timeinfo.tm_mon], (timeinfo.tm_year) + 1900);
|
||
|
|
}
|
||
|
|
strftime(update_time, sizeof(update_time), "%H:%M:%S", &timeinfo); // Creates: '@ 14:05:49' and change from 30 to 8 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||
|
|
sprintf(time_output, "%s", update_time);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
strftime(day_output, sizeof(day_output), "%a %b-%d-%Y", &timeinfo); // Creates 'Sat May-31-2019'
|
||
|
|
strftime(update_time, sizeof(update_time), "%r", &timeinfo); // Creates: '@ 02:05:49pm'
|
||
|
|
sprintf(time_output, "%s", update_time);
|
||
|
|
}
|
||
|
|
Date_str = day_output;
|
||
|
|
Time_str = time_output;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void DrawBattery(int x, int y) {
|
||
|
|
uint8_t percentage = 100;
|
||
|
|
float voltage = analogRead(35) / 4096.0 * 7.46;
|
||
|
|
if (voltage > 1 ) { // Only display if there is a valid reading
|
||
|
|
Serial.println("Voltage = " + String(voltage));
|
||
|
|
percentage = 2836.9625 * pow(voltage, 4) - 43987.4889 * pow(voltage, 3) + 255233.8134 * pow(voltage, 2) - 656689.7123 * voltage + 632041.7303;
|
||
|
|
if (voltage >= 4.20) percentage = 100;
|
||
|
|
if (voltage <= 3.20) percentage = 0; // orig 3.5
|
||
|
|
drawRect(x + 25, y - 20, 40, 15, GxEPD_BLACK);
|
||
|
|
fillRect(x + 65, y - 16, 4, 6, GxEPD_BLACK);
|
||
|
|
fillRect(x + 27, y - 18, 36 * percentage / 100.0, 11, GxEPD_BLACK);
|
||
|
|
setFont(OpenSans8B/*9*/);
|
||
|
|
drawString(x + 5, y - 15, String(percentage) + "%", RIGHT);
|
||
|
|
//drawString(x + 13, y + 5, String(voltage, 2) + "v", CENTER);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Symbols are drawn on a relative 10x10grid and 1 scale unit = 1 drawing unit
|
||
|
|
void addcloud(int x, int y, int scale, int linesize) {
|
||
|
|
//Draw cloud outer
|
||
|
|
fillCircle(x - scale * 3, y, scale, GxEPD_BLACK); // Left most circle
|
||
|
|
fillCircle(x + scale * 3, y, scale, GxEPD_BLACK); // Right most circle
|
||
|
|
fillCircle(x - scale, y - scale, scale * 1.4, GxEPD_BLACK); // left middle upper circle
|
||
|
|
fillCircle(x + scale * 1.5, y - scale * 1.3, scale * 1.75, GxEPD_BLACK); // Right middle upper circle
|
||
|
|
fillRect(x - scale * 3 - 1, y - scale, scale * 6, scale * 2 + 1, GxEPD_BLACK); // Upper and lower lines
|
||
|
|
//Clear cloud inner
|
||
|
|
fillCircle(x - scale * 3, y, scale - linesize, GxEPD_WHITE); // Clear left most circle
|
||
|
|
fillCircle(x + scale * 3, y, scale - linesize, GxEPD_WHITE); // Clear right most circle
|
||
|
|
fillCircle(x - scale, y - scale, scale * 1.4 - linesize, GxEPD_WHITE); // left middle upper circle
|
||
|
|
fillCircle(x + scale * 1.5, y - scale * 1.3, scale * 1.75 - linesize, GxEPD_WHITE); // Right middle upper circle
|
||
|
|
fillRect(x - scale * 3 + 2, y - scale + linesize - 1, scale * 5.9, scale * 2 - linesize * 2 + 2, GxEPD_WHITE); // Upper and lower lines
|
||
|
|
}
|
||
|
|
|
||
|
|
void addraindrop(int x, int y, int scale) {
|
||
|
|
fillCircle(x, y, scale / 2, GxEPD_BLACK);
|
||
|
|
fillTriangle(x - scale / 2, y, x, y - scale * 1.2, x + scale / 2, y , GxEPD_BLACK);
|
||
|
|
x = x + scale * 1.6; y = y + scale / 3;
|
||
|
|
fillCircle(x, y, scale / 2, GxEPD_BLACK);
|
||
|
|
fillTriangle(x - scale / 2, y, x, y - scale * 1.2, x + scale / 2, y , GxEPD_BLACK);
|
||
|
|
}
|
||
|
|
|
||
|
|
void addrain(int x, int y, int scale, bool IconSize) {
|
||
|
|
if (IconSize == SmallIcon) scale *= 1.34;
|
||
|
|
for (int d = 0; d < 4; d++) {
|
||
|
|
addraindrop(x + scale * (7.8 - d * 1.95) - scale * 5.2, y + scale * 2.1 - scale / 6, scale / 1.6);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void addsnow(int x, int y, int scale, bool IconSize) {
|
||
|
|
int dxo, dyo, dxi, dyi;
|
||
|
|
for (int flakes = 0; flakes < 5; flakes++) {
|
||
|
|
for (int i = 0; i < 360; i = i + 45) {
|
||
|
|
dxo = 0.5 * scale * cos((i - 90) * 3.14 / 180); dxi = dxo * 0.1;
|
||
|
|
dyo = 0.5 * scale * sin((i - 90) * 3.14 / 180); dyi = dyo * 0.1;
|
||
|
|
drawLine(dxo + x + flakes * 1.5 * scale - scale * 3, dyo + y + scale * 2, dxi + x + 0 + flakes * 1.5 * scale - scale * 3, dyi + y + scale * 2, GxEPD_BLACK);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void addtstorm(int x, int y, int scale) {
|
||
|
|
y = y + scale / 2;
|
||
|
|
for (int i = 0; i < 5; i++) {
|
||
|
|
drawLine(x - scale * 4 + scale * i * 1.5 + 0, y + scale * 1.5, x - scale * 3.5 + scale * i * 1.5 + 0, y + scale, GxEPD_BLACK);
|
||
|
|
if (scale != Small) {
|
||
|
|
drawLine(x - scale * 4 + scale * i * 1.5 + 1, y + scale * 1.5, x - scale * 3.5 + scale * i * 1.5 + 1, y + scale, GxEPD_BLACK);
|
||
|
|
drawLine(x - scale * 4 + scale * i * 1.5 + 2, y + scale * 1.5, x - scale * 3.5 + scale * i * 1.5 + 2, y + scale, GxEPD_BLACK);
|
||
|
|
}
|
||
|
|
drawLine(x - scale * 4 + scale * i * 1.5, y + scale * 1.5 + 0, x - scale * 3 + scale * i * 1.5 + 0, y + scale * 1.5 + 0, GxEPD_BLACK);
|
||
|
|
if (scale != Small) {
|
||
|
|
drawLine(x - scale * 4 + scale * i * 1.5, y + scale * 1.5 + 1, x - scale * 3 + scale * i * 1.5 + 0, y + scale * 1.5 + 1, GxEPD_BLACK);
|
||
|
|
drawLine(x - scale * 4 + scale * i * 1.5, y + scale * 1.5 + 2, x - scale * 3 + scale * i * 1.5 + 0, y + scale * 1.5 + 2, GxEPD_BLACK);
|
||
|
|
}
|
||
|
|
drawLine(x - scale * 3.5 + scale * i * 1.4 + 0, y + scale * 2.5, x - scale * 3 + scale * i * 1.5 + 0, y + scale * 1.5, GxEPD_BLACK);
|
||
|
|
if (scale != Small) {
|
||
|
|
drawLine(x - scale * 3.5 + scale * i * 1.4 + 1, y + scale * 2.5, x - scale * 3 + scale * i * 1.5 + 1, y + scale * 1.5, GxEPD_BLACK);
|
||
|
|
drawLine(x - scale * 3.5 + scale * i * 1.4 + 2, y + scale * 2.5, x - scale * 3 + scale * i * 1.5 + 2, y + scale * 1.5, GxEPD_BLACK);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void addsun(int x, int y, int scale, bool IconSize) {
|
||
|
|
int linesize = 3;
|
||
|
|
if (IconSize == SmallIcon) linesize = 1;
|
||
|
|
fillRect(x - scale * 2, y, scale * 4, linesize, GxEPD_BLACK);
|
||
|
|
fillRect(x, y - scale * 2, linesize, scale * 4, GxEPD_BLACK);
|
||
|
|
drawLine(x - scale * 1.3, y - scale * 1.3, x + scale * 1.3, y + scale * 1.3, GxEPD_BLACK);
|
||
|
|
drawLine(x - scale * 1.3, y + scale * 1.3, x + scale * 1.3, y - scale * 1.3, GxEPD_BLACK);
|
||
|
|
if (IconSize == LargeIcon) {
|
||
|
|
drawLine(1 + x - scale * 1.3, y - scale * 1.3, 1 + x + scale * 1.3, y + scale * 1.3, GxEPD_BLACK);
|
||
|
|
drawLine(2 + x - scale * 1.3, y - scale * 1.3, 2 + x + scale * 1.3, y + scale * 1.3, GxEPD_BLACK);
|
||
|
|
drawLine(3 + x - scale * 1.3, y - scale * 1.3, 3 + x + scale * 1.3, y + scale * 1.3, GxEPD_BLACK);
|
||
|
|
drawLine(1 + x - scale * 1.3, y + scale * 1.3, 1 + x + scale * 1.3, y - scale * 1.3, GxEPD_BLACK);
|
||
|
|
drawLine(2 + x - scale * 1.3, y + scale * 1.3, 2 + x + scale * 1.3, y - scale * 1.3, GxEPD_BLACK);
|
||
|
|
drawLine(3 + x - scale * 1.3, y + scale * 1.3, 3 + x + scale * 1.3, y - scale * 1.3, GxEPD_BLACK);
|
||
|
|
}
|
||
|
|
fillCircle(x, y, scale * 1.3, GxEPD_WHITE);
|
||
|
|
fillCircle(x, y, scale, GxEPD_BLACK);
|
||
|
|
fillCircle(x, y, scale - linesize, GxEPD_WHITE);
|
||
|
|
}
|
||
|
|
|
||
|
|
void addfog(int x, int y, int scale, int linesize, bool IconSize) {
|
||
|
|
if (IconSize == SmallIcon) {
|
||
|
|
y -= 10;
|
||
|
|
linesize = 1;
|
||
|
|
}
|
||
|
|
for (int i = 0; i < 6; i++) {
|
||
|
|
fillRect(x - scale * 3, y + scale * 1.5, scale * 6, linesize, GxEPD_BLACK);
|
||
|
|
fillRect(x - scale * 3, y + scale * 2.0, scale * 6, linesize, GxEPD_BLACK);
|
||
|
|
fillRect(x - scale * 3, y + scale * 2.5, scale * 6, linesize, GxEPD_BLACK);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void Sunny(int x, int y, bool IconSize, String IconName) {
|
||
|
|
int scale = Small;
|
||
|
|
if (IconSize == LargeIcon) scale = Large;
|
||
|
|
else y = y - 3; // Shift up small sun icon
|
||
|
|
if (IconName.endsWith("n")) addmoon(x, y + 3, scale, IconSize);
|
||
|
|
scale = scale * 1.6;
|
||
|
|
addsun(x, y, scale, IconSize);
|
||
|
|
}
|
||
|
|
|
||
|
|
void MostlySunny(int x, int y, bool IconSize, String IconName) {
|
||
|
|
int scale = Small, linesize = 3, offset = 5;
|
||
|
|
if (IconSize == LargeIcon) {
|
||
|
|
scale = Large;
|
||
|
|
offset = 10;
|
||
|
|
}
|
||
|
|
if (scale == Small) linesize = 1;
|
||
|
|
if (IconName.endsWith("n")) addmoon(x, y + offset, scale, IconSize);
|
||
|
|
addcloud(x, y + offset, scale, linesize);
|
||
|
|
addsun(x - scale * 1.8, y - scale * 1.8 + offset, scale, IconSize);
|
||
|
|
}
|
||
|
|
|
||
|
|
void MostlyCloudy(int x, int y, bool IconSize, String IconName) {
|
||
|
|
int scale = Small, linesize = 3;
|
||
|
|
if (IconSize == LargeIcon) {
|
||
|
|
scale = Large;
|
||
|
|
linesize = 1;
|
||
|
|
}
|
||
|
|
if (IconName.endsWith("n")) addmoon(x, y, scale, IconSize);
|
||
|
|
addcloud(x, y, scale, linesize);
|
||
|
|
addsun(x - scale * 1.8, y - scale * 1.8, scale, IconSize);
|
||
|
|
addcloud(x, y, scale, linesize);
|
||
|
|
}
|
||
|
|
|
||
|
|
void Cloudy(int x, int y, bool IconSize, String IconName) {
|
||
|
|
int scale = Large, linesize = 3;
|
||
|
|
if (IconSize == SmallIcon) {
|
||
|
|
scale = Small;
|
||
|
|
if (IconName.endsWith("n")) addmoon(x, y, scale, IconSize);
|
||
|
|
linesize = 1;
|
||
|
|
addcloud(x, y, scale, linesize);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
y += 10;
|
||
|
|
if (IconName.endsWith("n")) addmoon(x, y, scale, IconSize);
|
||
|
|
addcloud(x + 30, y - 45, 5, linesize); // Cloud top right
|
||
|
|
addcloud(x - 20, y - 30, 7, linesize); // Cloud top left
|
||
|
|
addcloud(x, y, scale, linesize); // Main cloud
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void Rain(int x, int y, bool IconSize, String IconName) {
|
||
|
|
int scale = Large, linesize = 3;
|
||
|
|
if (IconSize == SmallIcon) {
|
||
|
|
scale = Small;
|
||
|
|
linesize = 1;
|
||
|
|
}
|
||
|
|
if (IconName.endsWith("n")) addmoon(x, y, scale, IconSize);
|
||
|
|
addcloud(x, y, scale, linesize);
|
||
|
|
addrain(x, y, scale, IconSize);
|
||
|
|
}
|
||
|
|
|
||
|
|
void ExpectRain(int x, int y, bool IconSize, String IconName) {
|
||
|
|
int scale = Large, linesize = 3;
|
||
|
|
if (IconSize == SmallIcon) {
|
||
|
|
scale = Small;
|
||
|
|
linesize = 1;
|
||
|
|
}
|
||
|
|
if (IconName.endsWith("n")) addmoon(x, y, scale, IconSize);
|
||
|
|
addsun(x - scale * 1.8, y - scale * 1.8, scale, IconSize);
|
||
|
|
addcloud(x, y, scale, linesize);
|
||
|
|
addrain(x, y, scale, IconSize);
|
||
|
|
}
|
||
|
|
|
||
|
|
void ChanceRain(int x, int y, bool IconSize, String IconName) {
|
||
|
|
int scale = Large, linesize = 3;
|
||
|
|
if (IconSize == SmallIcon) {
|
||
|
|
scale = Small;
|
||
|
|
linesize = 1;
|
||
|
|
}
|
||
|
|
if (IconName.endsWith("n")) addmoon(x, y, scale, IconSize);
|
||
|
|
addsun(x - scale * 1.8, y - scale * 1.8, scale, IconSize);
|
||
|
|
addcloud(x, y, scale, linesize);
|
||
|
|
addrain(x, y, scale, IconSize);
|
||
|
|
}
|
||
|
|
|
||
|
|
void Tstorms(int x, int y, bool IconSize, String IconName) {
|
||
|
|
int scale = Large, linesize = 3;
|
||
|
|
if (IconSize == SmallIcon) {
|
||
|
|
scale = Small;
|
||
|
|
linesize = 1;
|
||
|
|
}
|
||
|
|
if (IconName.endsWith("n")) addmoon(x, y, scale, IconSize);
|
||
|
|
addcloud(x, y, scale, linesize);
|
||
|
|
addtstorm(x, y, scale);
|
||
|
|
}
|
||
|
|
|
||
|
|
void Snow(int x, int y, bool IconSize, String IconName) {
|
||
|
|
int scale = Large, linesize = 3;
|
||
|
|
if (IconSize == SmallIcon) {
|
||
|
|
scale = Small;
|
||
|
|
linesize = 1;
|
||
|
|
}
|
||
|
|
if (IconName.endsWith("n")) addmoon(x, y, scale, IconSize);
|
||
|
|
addcloud(x, y, scale, linesize);
|
||
|
|
addsnow(x, y, scale, IconSize);
|
||
|
|
}
|
||
|
|
|
||
|
|
void Fog(int x, int y, bool IconSize, String IconName) {
|
||
|
|
int linesize = 3, scale = Large;
|
||
|
|
if (IconSize == SmallIcon) {
|
||
|
|
scale = Small;
|
||
|
|
linesize = 1;
|
||
|
|
}
|
||
|
|
if (IconName.endsWith("n")) addmoon(x, y, scale, IconSize);
|
||
|
|
addcloud(x, y - 5, scale, linesize);
|
||
|
|
addfog(x, y - 5, scale, linesize, IconSize);
|
||
|
|
}
|
||
|
|
|
||
|
|
void Haze(int x, int y, bool IconSize, String IconName) {
|
||
|
|
int linesize = 3, scale = Large;
|
||
|
|
if (IconSize == SmallIcon) {
|
||
|
|
scale = Small;
|
||
|
|
linesize = 1;
|
||
|
|
}
|
||
|
|
if (IconName.endsWith("n")) addmoon(x, y, scale, IconSize);
|
||
|
|
addsun(x, y - 5, scale * 1.4, IconSize);
|
||
|
|
addfog(x, y - 5, scale * 1.4, linesize, IconSize);
|
||
|
|
}
|
||
|
|
|
||
|
|
void CloudCover(int x, int y, int CCover) {
|
||
|
|
addcloud(x - 9, y - 3, Small * 0.8, 2); // Cloud top left
|
||
|
|
addcloud(x + 3, y - 3, Small * 0.8, 2); // Cloud top right
|
||
|
|
addcloud(x, y, Small * 0.8, 2); // Main cloud
|
||
|
|
setFont(OpenSans12);
|
||
|
|
drawString(x + 44, y - 14, String(CCover) + "%", LEFT);
|
||
|
|
}
|
||
|
|
|
||
|
|
void Visibility(int x, int y, String Visi) {
|
||
|
|
y = y - 3; //
|
||
|
|
float start_angle = 0.52, end_angle = 2.61;
|
||
|
|
int r = 14;
|
||
|
|
for (float i = start_angle; i < end_angle; i = i + 0.05) {
|
||
|
|
drawPixel(x + r * cos(i), y - r / 2 + r * sin(i), GxEPD_BLACK);
|
||
|
|
drawPixel(x + r * cos(i), 1 + y - r / 2 + r * sin(i), GxEPD_BLACK);
|
||
|
|
}
|
||
|
|
start_angle = 3.61; end_angle = 5.78;
|
||
|
|
for (float i = start_angle; i < end_angle; i = i + 0.05) {
|
||
|
|
drawPixel(x + r * cos(i), y + r / 2 + r * sin(i), GxEPD_BLACK);
|
||
|
|
drawPixel(x + r * cos(i), 1 + y + r / 2 + r * sin(i), GxEPD_BLACK);
|
||
|
|
}
|
||
|
|
fillCircle(x, y, r / 4, GxEPD_BLACK);
|
||
|
|
setFont(OpenSans12);
|
||
|
|
drawString(x + 14, y - 12, Visi, LEFT);
|
||
|
|
}
|
||
|
|
|
||
|
|
void addmoon(int x, int y, int scale, bool IconSize) {
|
||
|
|
if (IconSize == LargeIcon) {
|
||
|
|
fillCircle(x - 85, y - 100, uint16_t(scale * 0.8), GxEPD_BLACK);
|
||
|
|
fillCircle(x - 57, y - 100, uint16_t(scale * 1.6), GxEPD_WHITE);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
fillCircle(x - 28, y - 37, uint16_t(scale * 1.0), GxEPD_BLACK);
|
||
|
|
fillCircle(x - 20, y - 37, uint16_t(scale * 1.6), GxEPD_WHITE);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void Nodata(int x, int y, bool IconSize, String IconName) {
|
||
|
|
if (IconSize == LargeIcon) setFont(OpenSans24); else setFont(OpenSans12/*9*/);
|
||
|
|
drawString(x - 3, y - 10, "?", CENTER);
|
||
|
|
setFont(OpenSans12/*9*/);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* (C) D L BIRD
|
||
|
|
This function will draw a graph on a ePaper/TFT/LCD display using data from an array containing data to be graphed.
|
||
|
|
The variable 'max_readings' determines the maximum number of data elements for each array. Call it with the following parametric data:
|
||
|
|
x_pos-the x axis top-left position of the graph
|
||
|
|
y_pos-the y-axis top-left position of the graph, e.g. 100, 200 would draw the graph 100 pixels along and 200 pixels down from the top-left of the screen
|
||
|
|
width-the width of the graph in pixels
|
||
|
|
height-height of the graph in pixels
|
||
|
|
Y1_Max-sets the scale of plotted data, for example 5000 would scale all data to a Y-axis of 5000 maximum
|
||
|
|
data_array1 is parsed by value, externally they can be called anything else, e.g. within the routine it is called data_array1, but externally could be temperature_readings
|
||
|
|
auto_scale-a logical value (TRUE or FALSE) that switches the Y-axis autoscale On or Off
|
||
|
|
barchart_on-a logical value (TRUE or FALSE) that switches the drawing mode between barhcart and line graph
|
||
|
|
barchart_colour-a sets the title and graph plotting colour
|
||
|
|
If called with Y!_Max value of 500 and the data never goes above 500, then autoscale will retain a 0-500 Y scale, if on, the scale increases/decreases to match the data.
|
||
|
|
auto_scale_margin, e.g. if set to 1000 then autoscale increments the scale by 1000 steps.
|
||
|
|
*/
|
||
|
|
void DrawGraph(int x_pos, int y_pos, int gwidth, int gheight, float Y1Min, float Y1Max, String title, float DataArray[], int readings, boolean auto_scale, boolean barchart_mode) {
|
||
|
|
#define auto_scale_margin 0 // Sets the autoscale increment, so axis steps up in units of e.g. 3
|
||
|
|
#define y_minor_axis 5 // 5 y-axis division markers
|
||
|
|
int maxYscale = -10000;
|
||
|
|
int minYscale = 10000;
|
||
|
|
int last_x, last_y;
|
||
|
|
float x2, y2;
|
||
|
|
if (auto_scale == true) {
|
||
|
|
for (int i = 1; i < readings; i++ ) {
|
||
|
|
if (DataArray[i] >= maxYscale) maxYscale = DataArray[i];
|
||
|
|
if (DataArray[i] <= minYscale) minYscale = DataArray[i];
|
||
|
|
}
|
||
|
|
maxYscale = round(maxYscale + auto_scale_margin); // Auto scale the graph and round to the nearest value defined, default was Y1Max
|
||
|
|
Y1Max = round(maxYscale + 0.5);
|
||
|
|
if (minYscale != 0) minYscale = round(minYscale - auto_scale_margin); // Auto scale the graph and round to the nearest value defined, default was Y1Min
|
||
|
|
Y1Min = round(minYscale);
|
||
|
|
}
|
||
|
|
// Draw the graph
|
||
|
|
last_x = x_pos + 1;
|
||
|
|
last_y = y_pos + (Y1Max - constrain(DataArray[1], Y1Min, Y1Max)) / (Y1Max - Y1Min) * gheight;
|
||
|
|
drawRect(x_pos, y_pos, gwidth + 3, gheight + 2, GRAY);
|
||
|
|
drawString(x_pos - 20 + gwidth / 2, y_pos - 32, title, CENTER);
|
||
|
|
// Draw the data
|
||
|
|
// x_pos = x_pos + 10;
|
||
|
|
for (int gx = 1; gx < readings; gx++) {
|
||
|
|
x2 = x_pos + gx * gwidth / (readings - 1) - 1 ; // max_readings is the global variable that sets the maximum data that can be plotted
|
||
|
|
y2 = y_pos + (Y1Max - constrain(DataArray[gx], Y1Min, Y1Max)) / (Y1Max - Y1Min) * gheight + 1;
|
||
|
|
if (barchart_mode) {
|
||
|
|
fillRect(last_x + 2, y2, (gwidth / readings) - 1, y_pos + gheight - y2 + 2, GxEPD_BLACK);
|
||
|
|
} else {
|
||
|
|
drawLine(last_x, last_y, x2, y2, GxEPD_BLACK);
|
||
|
|
}
|
||
|
|
last_x = x2;
|
||
|
|
last_y = y2;
|
||
|
|
}
|
||
|
|
//Draw the Y-axis scale
|
||
|
|
#define number_of_dashes 20
|
||
|
|
for (int spacing = 0; spacing <= y_minor_axis; spacing++) {
|
||
|
|
for (int j = 0; j < number_of_dashes; j++) { // Draw dashed graph grid lines
|
||
|
|
if (spacing < y_minor_axis) drawFastHLine((x_pos + 3 + j * gwidth / number_of_dashes), y_pos + (gheight * spacing / y_minor_axis), gwidth / (2 * number_of_dashes), GRAY);
|
||
|
|
}
|
||
|
|
if ((Y1Max - (float)(Y1Max - Y1Min) / y_minor_axis * spacing) < 5 || title == TXT_PRESSURE_IN) {
|
||
|
|
drawString(x_pos - 10, y_pos + gheight * spacing / y_minor_axis - 5, String((Y1Max - (float)(Y1Max - Y1Min) / y_minor_axis * spacing + 0.01), 1), RIGHT);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (Y1Min < 1 && Y1Max < 10) {
|
||
|
|
drawString(x_pos - 10, y_pos + gheight * spacing / y_minor_axis - 5, String((Y1Max - (float)(Y1Max - Y1Min) / y_minor_axis * spacing + 0.01), 1), RIGHT);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
drawString(x_pos - 18, y_pos + gheight * spacing / y_minor_axis - 5, String((Y1Max - (float)(Y1Max - Y1Min) / y_minor_axis * spacing + 0.01), 0), RIGHT);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (int i = 0; i <= 2; i++) {
|
||
|
|
drawString(5 + x_pos + gwidth / 3 * i, y_pos + gheight + 10, String(i)+"d", LEFT);
|
||
|
|
}
|
||
|
|
//drawString(x_pos + gwidth / 2, y_pos + gheight + 25, TXT_DAYS, CENTER);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void drawString(int x, int y, String text, alignment align) {
|
||
|
|
char * data = const_cast<char*>(text.c_str());
|
||
|
|
int x1, y1; //the bounds of x,y and w and h of the variable 'text' in pixels.
|
||
|
|
int w, h;
|
||
|
|
int xx = x, yy = y;
|
||
|
|
EpdFontProperties fp = epd_font_properties_default();
|
||
|
|
epd_get_text_bounds(¤tFont, data, &xx, &yy, &x1, &y1, &w, &h, &fp);
|
||
|
|
|
||
|
|
if (align == RIGHT) x = x - w;
|
||
|
|
if (align == CENTER) x = x - w / 2;
|
||
|
|
|
||
|
|
int cursor_y = y + h;
|
||
|
|
epd_write_default(¤tFont, data, &x, &cursor_y, fb);
|
||
|
|
}
|
||
|
|
|
||
|
|
void drawStringMaxWidth(int x, int y, unsigned int text_width, String text, alignment align) {
|
||
|
|
char * data = const_cast<char*>(text.c_str());
|
||
|
|
int x1, y1; //the bounds of x,y and w and h of the variable 'text' in pixels.
|
||
|
|
int w, h;
|
||
|
|
int xx = x, yy = y;
|
||
|
|
|
||
|
|
EpdFontProperties fp = epd_font_properties_default();
|
||
|
|
epd_get_text_bounds(¤tFont, data, &xx, &yy, &x1, &y1, &w, &h, &fp);
|
||
|
|
if (align == RIGHT) x = x - w;
|
||
|
|
if (align == CENTER) x = x - w / 2;
|
||
|
|
|
||
|
|
if (text.length() > text_width * 2) {
|
||
|
|
setFont(OpenSans12/*9*/);
|
||
|
|
text_width = 42;
|
||
|
|
y = y - 3;
|
||
|
|
}
|
||
|
|
epd_write_default(¤tFont, data, &x, &y, fb);
|
||
|
|
|
||
|
|
if (text.length() > text_width) {
|
||
|
|
y += h + 15;
|
||
|
|
String secondLine = text.substring(text_width);
|
||
|
|
secondLine.trim(); // Remove any leading spac
|
||
|
|
epd_write_default(¤tFont, data, &x, &y, fb);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void ReportEvent(String EventMessage[]) {
|
||
|
|
int y = int(SCREEN_HEIGHT - 40 * (EventCnt + 1) - 2 * 40);
|
||
|
|
int wx = int (SCREEN_WIDTH * 0.1);
|
||
|
|
int wy = y + int (SCREEN_WIDTH * 0.1);
|
||
|
|
int tbw = int (SCREEN_WIDTH * 0.8);
|
||
|
|
int tbh = int ((EventCnt + 1) * 40);
|
||
|
|
if (EventCnt > EventThreshold) {
|
||
|
|
//display.setPartialWindow(wx, wy, tbw, tbh);
|
||
|
|
|
||
|
|
EpdRect to_clear = {
|
||
|
|
.x = wx,
|
||
|
|
.y = wy,
|
||
|
|
.width = tbw,
|
||
|
|
.height = tbh,
|
||
|
|
};
|
||
|
|
epd_poweron();
|
||
|
|
epd_clear_area(to_clear);
|
||
|
|
|
||
|
|
fillRect(wx, wy, tbw, tbh, GxEPD_WHITE);
|
||
|
|
drawRect(wx, wy, tbw, tbh, GxEPD_BLACK);
|
||
|
|
}
|
||
|
|
setFont(OpenSans12/*18*/);
|
||
|
|
for (byte Event = 1; Event <= EventCnt; Event++) {
|
||
|
|
if (EventCnt > EventThreshold) drawString(wx + 3, wy + 20 + (Event - 1) * 30,
|
||
|
|
"Evt#" + String(Event < 10 ? "0" : "") + String(Event) + " : " + EventMessage[Event], LEFT);
|
||
|
|
Serial.println("Evnt#" + String(Event < 10 ? "0" : "") + String(Event) + " : " + EventMessage[Event]);
|
||
|
|
}
|
||
|
|
epd_poweroff();
|
||
|
|
}
|
||
|
|
|
||
|
|
/*void VerboseRecordOfResetReason(RESET_REASON reason) {
|
||
|
|
switch ( reason) {
|
||
|
|
case 1 : AddToEventLog("Vbat power on reset"); break;
|
||
|
|
case 3 : AddToEventLog("Software reset digital core"); break;
|
||
|
|
case 4 : AddToEventLog("Legacy watch dog reset digital core"); break;
|
||
|
|
case 5 : AddToEventLog("Deep Sleep reset digital core"); break;
|
||
|
|
case 6 : AddToEventLog("Reset by SLC module, reset digital core"); break;
|
||
|
|
case 7 : AddToEventLog("Timer Group0 Watch dog reset digital core"); break;
|
||
|
|
case 8 : AddToEventLog("Timer Group1 Watch dog reset digital core"); break;
|
||
|
|
case 9 : AddToEventLog("RTC Watch dog Reset digital core"); break;
|
||
|
|
case 10 : AddToEventLog("Instrusion tested to reset CPU"); break;
|
||
|
|
case 11 : AddToEventLog("Time Group reset CPU"); break;
|
||
|
|
case 12 : AddToEventLog("Software reset CPU"); break;
|
||
|
|
case 13 : AddToEventLog("RTC Watch dog Reset CPU"); break;
|
||
|
|
case 14 : AddToEventLog("APP CPU reset by PRO CPU"); break;
|
||
|
|
case 15 : AddToEventLog("Reset when Vdd voltage is not stable"); break;
|
||
|
|
case 16 : AddToEventLog("RTC Watch dog reset digital core and rtc module"); break;
|
||
|
|
default : AddToEventLog("Unknown reason");
|
||
|
|
}
|
||
|
|
}*/
|
||
|
|
|
||
|
|
void DisplayTime() {
|
||
|
|
drawString(850, 510, "16:00", CENTER);
|
||
|
|
}
|
||
|
|
|
||
|
|
void fillCircle(int x, int y, int r, uint8_t color) {
|
||
|
|
epd_fill_circle(x, y, r, color, fb);
|
||
|
|
}
|
||
|
|
|
||
|
|
void drawFastHLine(int16_t x0, int16_t y0, int length, uint16_t color) {
|
||
|
|
epd_draw_hline(x0, y0, length, color, fb);
|
||
|
|
}
|
||
|
|
|
||
|
|
void drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color) {
|
||
|
|
epd_draw_line(x0, y0, x1, y1, color, fb);
|
||
|
|
}
|
||
|
|
|
||
|
|
void drawCircle(int x0, int y0, int r, uint8_t color) {
|
||
|
|
epd_draw_circle(x0, y0, r, color, fb);
|
||
|
|
}
|
||
|
|
|
||
|
|
void drawRect(int16_t x, int16_t y, int16_t w, int16_t h,uint16_t color) {
|
||
|
|
EpdRect rect = {
|
||
|
|
.x = x,
|
||
|
|
.y = y,
|
||
|
|
.width = w,
|
||
|
|
.height = h
|
||
|
|
};
|
||
|
|
epd_draw_rect(rect, color, fb);
|
||
|
|
}
|
||
|
|
|
||
|
|
void fillRect(int16_t x, int16_t y, int16_t w, int16_t h,uint16_t color) {
|
||
|
|
EpdRect rect = {
|
||
|
|
.x = x,
|
||
|
|
.y = y,
|
||
|
|
.width = w,
|
||
|
|
.height = h
|
||
|
|
};
|
||
|
|
epd_fill_rect(rect, color, fb);
|
||
|
|
}
|
||
|
|
|
||
|
|
void fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
|
||
|
|
int16_t x2, int16_t y2, uint16_t color) {
|
||
|
|
epd_fill_triangle(x0, y0, x1, y1, x2, y2, color,fb);
|
||
|
|
}
|
||
|
|
|
||
|
|
void drawPixel(int x, int y, uint8_t color) {
|
||
|
|
epd_draw_pixel(x, y, color, fb);
|
||
|
|
}
|
||
|
|
|
||
|
|
void setFont(EpdFont const &font) {
|
||
|
|
currentFont = font;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|