ESP32Time-Starter v1.0

// ----------------------------------------------------------------------------------------------------------------------------------------------- //
// --- L A N G U A G E   S E T U P --------------------------------------------------------------------------------------------------------------- //
// ----------------------------------------------------------------------------------------------------------------------------------------------- //

#define LANGUAGE 0                                            // 0 (Polish), 1 (English)

#if LANGUAGE == 0
    #define POLISH 1
    #define ENGLISH 0
#endif

#if LANGUAGE == 1
    #define POLISH 0
    #define ENGLISH 1
#endif

// ----------------------------------------------------------------------------------------------------------------------------------------------- //
// --- D E F I N E   S E C T I O N  -------------------------------------------------------------------------------------------------------------- //
// ----------------------------------------------------------------------------------------------------------------------------------------------- //

#define   SERIAL  1
#define   DEBUG1  1                       // show struct psTIME

// ----------------------------------------------------------------------------------------------------------------------------------------------- //
// --- PS RAM ------------------------------------------------------------------------------------------------------------------------------------ //
// ----------------------------------------------------------------------------------------------------------------------------------------------- //

#include "esp_system.h"
#include "esp32-hal-psram.h"

extern "C"
{
    #include <esp_spiram.h>
    #include <esp_himem.h>
}

// ----------------------------------------------------------------------------------------------------------------------------------------------- //
// --- WiFi Settings ----------------------------------------------------------------------------------------------------------------------------- //
// ----------------------------------------------------------------------------------------------------------------------------------------------- //

#include <WiFi.h>
#define   SSID        "XXXXXX"                                              // nazwa sieci Wi-Fi
#define   PASSWORD    "XXXXXXXXXXX"                                         // hasło sieci Wi-Fi

// ----------------------------------------------------------------------------------------------------------------------------------------------- //
// --- NTP Settings ------------------------------------------------------------------------------------------------------------------------------ //
// ----------------------------------------------------------------------------------------------------------------------------------------------- //

#include <ESP32Time.h>
#include <WiFiClient.h>
#include <NTPClient.h>

WiFiUDP ntpUDP;                                                     // dla NTP (pobieranie czasu z internetu)
NTPClient timeClient(ntpUDP, "pool.ntp.org", 7200);                 // dla NTP (pobieranie czasu z internetu)
WiFiClient wifiClient;                                              // obiekt WiFi
ESP32Time RTC;                                                      // zegar RTC

// ----------------------------------------------------------------------------------------------------------------------------------------------- //
// --- P R O T O T Y P Y    M U L T I - C O R E -------------------------------------------------------------------------------------------------- //
// ----------------------------------------------------------------------------------------------------------------------------------------------- //

TaskHandle_t CPU_Core_0;                                            // rdzeń nr. 0 CPU - ESP32
TaskHandle_t CPU_Core_1;                                            // rdzeń nr. 1 CPU - ESP32

void Core0_Task1( void * pvParameters );                            // funkcja Task1 dla rdzenia nr. 0 CPU
void Core0_Task2( void * pvParameters );                            // funkcja Task2 dla rdzenia nr. 0 CPU
void Core0_Task3( void * pvParameters );                            // funkcja Task1 dla rdzenia nr. 0 CPU

#define T01    60000                                                //  1 minute
#define T02   120000                                                //  2 minutes
#define T05   300000                                                //  5 minutes
#define T10   600000                                                // 10 minutes
#define T15   900000                                                // 15 minutes
#define T30  1800000                                                // 30 minutes
#define T60  3600000                                                // 60 minutes
#define T90  5400000                                                // 90 minutes

// ----------------------------------------------------------------------------------------------------------------------------------------------- //
// --- S T U C T U R E   S E C T I O N ----------------------------------------------------------------------------------------------------------- //
// ----------------------------------------------------------------------------------------------------------------------------------------------- //
//
//
//
//
//
// ----------------------------------------------------------------------------------------------------------------------------------------------- //
// --- s t r u c t u r e   T I M E & D A T E   s t o r e   i n   P S R A M ( n o t   u s e   d y n a m i c   m e m o r y )                     --- //
// ----------------------------------------------------------------------------------------------------------------------------------------------- //

bool F_ptrTIME = false;                  // false if ptrTime is not allocate

struct psTIME
{
    uint Hour = 0;                       // hour (godzina)
    uint Minute = 0;                     // minute (minuta)
    uint Second = 0;                     // second (sekunda)
    uint Day = 0;                        // day of month (dzień miesiąca 1-31)
    uint DayOfWeek = 0;                  // day of week (dzień tygodnia 1-7)
    uint Month = 0;                      // month (miesiąc 1-12)
    uint Year = 0;                       // year (rok)

    char sDayOfWeek[20];                 // day of week (char tab)
    char sMonth[20];                     // month (char tab)
};

struct psTIME *ptrTime;                  // ptr to struct psTIME 40156 - 724838

#if POLISH
    const char Day_0 [] = "Niedziela";
    const char Day_1 [] = "Poniedzialek";
    const char Day_2 [] = "Wtorek";
    const char Day_3 [] = "Sroda";
    const char Day_4 [] = "Czwartek";
    const char Day_5 [] = "Piatek";
    const char Day_6 [] = "Sobota";
#endif

#if ENGLISH
    const char Day_0 [] = "Sunday";
    const char Day_1 [] = "Monday";
    const char Day_2 [] = "Tuesday";
    const char Day_3 [] = "Wednesday";
    const char Day_4 [] = "Thursday";
    const char Day_5 [] = "Friday";
    const char Day_6 [] = "Saturday";
#endif

const char * const DAY[] = { Day_0, Day_1, Day_2, Day_3, Day_4, Day_5, Day_6 }; // dni tygodnia [0..6]

#if POLISH
    const char MONTH_0  [] = "NULL";
    const char MONTH_1  [] = "Styczen";
    const char MONTH_2  [] = "Luty";
    const char MONTH_3  [] = "Marzec";
    const char MONTH_4  [] = "Kwiecien";
    const char MONTH_5  [] = "Maj";
    const char MONTH_6  [] = "Czerwiec";
    const char MONTH_7  [] = "Lipiec";
    const char MONTH_8  [] = "Sierpien";
    const char MONTH_9  [] = "Wrzesien";
    const char MONTH_10 [] = "Pazdziernik";
    const char MONTH_11 [] = "Listopad";
    const char MONTH_12 [] = "Grudzien";
#endif

#if ENGLISH
    const char MONTH_0  [] = "NULL";
    const char MONTH_1  [] = "January";
    const char MONTH_2  [] = "February";
    const char MONTH_3  [] = "March";
    const char MONTH_4  [] = "April";
    const char MONTH_5  [] = "May";
    const char MONTH_6  [] = "June";
    const char MONTH_7  [] = "July";
    const char MONTH_8  [] = "August";
    const char MONTH_9  [] = "September";
    const char MONTH_10 [] = "October";
    const char MONTH_11 [] = "November";
    const char MONTH_12 [] = "December";
#endif

const char * const MONTH[] = { MONTH_0, MONTH_1, MONTH_2, MONTH_3, MONTH_4, MONTH_5, MONTH_6, MONTH_7, MONTH_8, MONTH_9, MONTH_10, MONTH_11, MONTH_12 };

// --- create in PSRAM struct psTIME ------------------------------------------------------------------------------------------------------------- //

void psTIMEcreate()
{
    ptrTime = ( struct psTIME * ) ps_malloc ( sizeof (struct psTIME) );                           // allocate memory for struct psTIME in PSRAM
    F_ptrTIME = true;                                                                             // set flag prtTIME : true

    #if SERIAL
        #if ENGLISH
            Serial.printf("\n[ESP] [psRAM] [ptrTime] memory for struct psTIME has been allocated in PSRAM... ");
        #endif
        #if POLISH
            Serial.printf("\n[ESP] [psRAM] [ptrTime] pamiec dla struct psTIME zostala pomyslnie alokowana w pamieci PSRAM...");
        #endif
    #endif
}

// --- delete from PSRAM struct psTIME ----------------------------------------------------------------------------------------------------------- //

void psTIMEdelete()
{
    free ( ptrTime );                                                                              // free memory (ptrTime)
    F_ptrTIME = false;                                                                             // set flag prtTIME : false

    #if SERIAL
        Serial.printf("\n[ESP] [psRAM] [ptrTime] memory for struct psTIME has been free... ");
    #endif
}

// --- update time in structure psTIME ----------------------------------------------------------------------------------------------------------- //

void psTIMEupdate()
{

    timeClient.update();

    unsigned long epochTime = timeClient.getEpochTime();
    struct tm *ptm = gmtime ((time_t *)&epochTime);

    RTC.setTime(timeClient.getSeconds(), timeClient.getMinutes(), timeClient.getHours(), ptm->tm_mday, ptm->tm_mon+1, ptm->tm_year+1900);

    if (F_ptrTIME)                                                        // is Flag is true (memory in PSRAM allocated)
    {
        ptrTime -> Hour = timeClient.getHours();                          // copy to PSRAM
        ptrTime -> Minute =  timeClient.getMinutes();                     // copy to PSRAM
        ptrTime -> Second =  timeClient.getSeconds();                     // copy to PSRAM
        ptrTime -> Day = ptm -> tm_mday;                                  // copy to PSRAM
        ptrTime -> DayOfWeek = timeClient.getDay();                       // copy to PSRAM
        ptrTime -> Month = ptm -> tm_mon+1;                               // copy to PSRAM
        ptrTime -> Year = ptm -> tm_year+1900;                            // copy to PSRAM

        strcpy (ptrTime -> sDayOfWeek, DAY[ptrTime -> DayOfWeek]);        // copy to char tab name of day of week (PSRAM)
        strcpy (ptrTime -> sMonth, MONTH[ptrTime -> Month]);              // copy to char tab name of month (PSRAM)

        #if SERIAL
            #if ENGLISH
                Serial.printf("\n[ESP] [psRAM] [ptrTime] update psTIME success... ");
                #if DEBUG1
                    Serial.printf("\n\n[STRUCT psTIME] Hour = %d", ptrTime -> Hour);
                    Serial.printf("\n[STRUCT psTIME] Minute = %d", ptrTime -> Minute);
                    Serial.printf("\n[STRUCT psTIME] Second = %d", ptrTime -> Second);
                    Serial.printf("\n[STRUCT psTIME] Day = %d", ptrTime -> Day);
                    Serial.printf("\n[STRUCT psTIME] DayOfWeek = %d", ptrTime -> DayOfWeek);
                    Serial.printf("\n[STRUCT psTOME] DayOfweek = %s", ptrTime -> sDayOfWeek);
                    Serial.printf("\n[STRUCT psTIME] Month = %d", ptrTime -> Month);
                    Serial.printf("\n[STRUCT psTIME] Month = %s", ptrTime -> sMonth);
                    Serial.printf("\n[STRUCT psTIME] Year = %d\n", ptrTime -> Year);
                #endif
            #endif
            #if POLISH
                Serial.printf("\n[ESP] [psRAM] [ptrTime] aktualizacja struktury psTIME zakonczona sukcesem... ");
                #if DEBUG1
                    Serial.printf("\n\n[STRUCT psTIME] Godzina = %d", ptrTime -> Hour);
                    Serial.printf("\n[STRUCT psTIME] Minuta = %d", ptrTime -> Minute);
                    Serial.printf("\n[STRUCT psTIME] Sekunda = %d", ptrTime -> Second);
                    Serial.printf("\n[STRUCT psTIME] Dzien = %d", ptrTime -> Day);
                    Serial.printf("\n[STRUCT psTIME] Dzien tygodnia = %d", ptrTime -> DayOfWeek);
                    Serial.printf("\n[STRUCT psTOME] Dzien tygodnia = %s", ptrTime -> sDayOfWeek);
                    Serial.printf("\n[STRUCT psTIME] Miesiac = %d", ptrTime -> Month);
                    Serial.printf("\n[STRUCT psTIME] Miesiac = %s", ptrTime -> sMonth);
                    Serial.printf("\n[STRUCT psTIME] Rok = %d\n", ptrTime -> Year);
                #endif
            #endif
        #endif
    }
    else
    {
        #if SERIAL
            #if ENGLISH
                Serial.printf("\n[ESP] [psRAM] [ptrTime] struct psTIME not update !!! memory is not-allocated... ");
            #endif
            #if POLISH
                Serial.printf("\n[ESP] [psRAM] [ptrTime] struct psTIME nie zostala zaktualizowana !!! pamiec nie jest alowana dla wskaznika ptrTIME ");
            #endif
        #endif
    }
}

//
// ------------------------------------------------------------------------------------------------------------ //
// --- W i F i   R E C O N E C T ------------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------------------------ //
//

void WiFiEvent(WiFiEvent_t event)
{
    switch (event)
    {
        case SYSTEM_EVENT_STA_GOT_IP:
                                              #if SERIAL
                                                  Serial.printf("\n[ESP] [WiFiEvent] [Connect to Wi-Fi] ");
                                              #endif
                                              break;

        case SYSTEM_EVENT_STA_DISCONNECTED:
                                              #if SERIAL
                                                  Serial.printf("\n[ESP] [WiFiEvent] [Utracono połączenie z Wi-Fi] ");
                                              #endif

                                              WiFi.setAutoReconnect(true);
                                              break;
        default:                              break;
  }
}

//
// ------------------------------------------------------------------------------------------------------------ //
// --- CORE 0 TASK 1 ------------------------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------------------------ //
//

void Core0_Task1( void * pvParameters )
{
    for(;;)                                                                       // for for Core0_Task1
    {
        if (WiFi.status() == WL_CONNECTED)                                        // if WiFi is O.K.
        {
            if ( !F_ptrTIME ) psTIMEcreate();                                     // create memory in PSRAM for struct psTIME

            if ( F_ptrTIME )                                                      // if memory in PSRAM for struct is allocated
            {
                psTIMEupdate();                                                   // update RTC-ESP clock if PSRAM is allocated

                #if SERIAL
                    Serial.printf("\n[CORE0] [TASK1] [RTC Time] ");
                    Serial.print(RTC.getTime());
                    Serial.printf("\n[CORE0] [TASK1] [RTC Date] ");
                    Serial.print(RTC.getDate());
                    Serial.printf("\n[CORE0] [TASK1] [FREE RAM] ");
                    Serial.println(ESP.getFreeHeap());
                    Serial.printf("[CORE0] [TASK1] [FREE PSRAM] : %d\n", ESP.getFreePsram());
                #endif
            }
        }
        else
        {
            #if SERIAL
                Serial.printf("\n[CORE0] [TASK1] [WiFi] not conected, time is not update ... ");
            #endif
        }

        delay(T01);
    }
}

//
// ------------------------------------------------------------------------------------------------------------ //
// --- CORE 0 TASK 2 ------------------------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------------------------ //
//

void Core0_Task2( void * pvParameters )
{
    for(;;)
    {
        delay(T30);
    }
}

//
// ------------------------------------------------------------------------------------------------------------ //
// --- CORE 0 TASK 1 ------------------------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------------------------ //
//

void Core0_Task3( void * pvParameters )
{
    for(;;)
    {
        delay(T60);
    }
}


//
// ----------------------------------------------------------------------------------------------------------------------------------------------- //
// ---      P S R A M   I N F O                                                                                                                --- //
// ----------------------------------------------------------------------------------------------------------------------------------------------- //
//

void PSRAM_Info()
{
    log_d("Total PSRAM: %d", ESP.getPsramSize());
    log_d("Free PSRAM: %d", ESP.getFreePsram());
}

//
// ----------------------------------------------------------------------------------------------------------------------------------------------- //
// --- S E T U P --------------------------------------------------------------------------------------------------------------------------------- //
// ----------------------------------------------------------------------------------------------------------------------------------------------- //
//

void setup()
{
    psramInit();                            // PSRAM memory init
    PSRAM_Info();                           // PSRAM check & info

    #if SERIAL
        Serial.begin(115200);
    #endif

    WiFi.onEvent(WiFiEvent);                // funkcja zdarzenie Event
    WiFi.setAutoConnect(true);              // auto-reconnect
    WiFi.mode(WIFI_STA);                    // tryb pracy WiFi
    WiFi.begin(SSID, PASSWORD);             // WiFi start

    while ( WiFi.status() != WL_CONNECTED )
    {
        #if SERIAL
            Serial.print(".");
        #endif

        delay(50);
    }

    Serial.println(WiFi.localIP());

    timeClient.begin();                     // start NTP


    // --- CPU_Core_0 ----------------------------------------------------------------------------------

    xTaskCreatePinnedToCore(Core0_Task1, "CPU_Core_0", 15000, NULL, 1, &CPU_Core_0, 0);
    vTaskDelay(500 / portTICK_PERIOD_MS);

    xTaskCreatePinnedToCore(Core0_Task2, "CPU_Core_0", 7000, NULL, 1, &CPU_Core_0, 0);
    vTaskDelay(500 / portTICK_PERIOD_MS);

    xTaskCreatePinnedToCore(Core0_Task3, "CPU_Core_0", 7000, NULL, 1, &CPU_Core_0, 1);
    vTaskDelay(500 / portTICK_PERIOD_MS);


}

//
// ----------------------------------------------------------------------------------------------------------------------------------------------- //
// --- M A I N   L O O P ------------------------------------------------------------------------------------------------------------------------- //
// ----------------------------------------------------------------------------------------------------------------------------------------------- //
//

void loop()
{

}