API tools faq
paste
PowerTGS440

ESP32-WeatherStation_v012

PowerTGS440
Mar 27th, 2021
352
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 43.53 KB | None | 0 0
raw download clone embed print report
  1. // ------------------------------------------------------------------------------------------ //
  2. //
  3. //  My Home E-Station by Tomasz Majcher
  4. //
  5. //
  6. //
  7. // ------------------------------------------------------------------------------------------ //
  8. // --- HISTORIA WERSJI ---------------------------------------------------------------------- //
  9. //
  10. // (27.03.2021) My Home E-Station core v0.012 - dodano obsługę Multi-Switch TFT
  11. // (27.03.2021) My Home E-Station core v0.011 - optymalizacja
  12. // (27.03.2021) My Home E-Station core v0.010 - dodano obsługę Zegara RTC na TFT
  13. // (23.03.2021) My Home E-Station core v0.009 - dodano obsługę Temp i Wilg na TFT
  14. // (20.03.2021) My Home E-Station core v0.008 - dodano obsługę wyświetlacza TFT
  15. // (19.03.2021) My Home E-Station core v0.007 - dodano funkcje budowy tablicy WEATHER
  16. // (19.03.2021) My Home E-Station core v0.006 - dodano obsługę Archiwizacji odczytów
  17. // (18.03.2021) My Home E-Station core v0.005 - dodano obsługę czytnika kart SD i SPIFFS
  18. // (17.03.2021) My Home E-Station core v0.004 - dodano obsługę zadań Scheluder
  19. // (16.03.2021) My Home E-Station core v0.003 - dodano obsługę rdzenie procesora ESP32
  20. // (15.03.2021) My Home E-Station core v0.002 - dodano obsługę Open Weather Map
  21. // (14.03.2021) My Home E-Station core v0.001 - dodano obsługę NTP
  22. // (13.03.2021) My Home E-Station core v0.000 - początek budowy systemu głównego
  23. //
  24. // --- PROTOTYPY------------------------------------------------------------------------------ //
  25.  
  26. void Core_0_Task1( void * pvParameters );                 // funkcja Task1 dla rdzenia nr. 0 CPU        
  27. void Core_0_Task2( void * pvParameters );                 // funkcja Task2 dla rdzenia nr. 0 CPU        
  28. void Core_0_Task3( void * pvParameters );                 // funkcja Task3 dla rdzenia nr. 0 CPU        
  29. void Core_0_Task4( void * pvParameters );                 // funkcja Task4 dla rdzenia nr. 0 CPU        
  30. void Core_0_Task5( void * pvParameters );                 // funkcja Task5 dla rdzenia nr. 0 CPU        
  31.  
  32. void Core_1_Task1( void * pvParameters );                 // funkcja Task1 dla rdzenia nr. 1 CPU        
  33. void Core_1_Task2( void * pvParameters );                 // funkcja Tasl2 dla rdzenia nr. 1 CPU    
  34. void Core_1_Task3( void * pvParameters );                 // funkcja Tasl2 dla rdzenia nr. 1 CPU
  35.  
  36. void Task0Callback();                                     // funkcja dla task_0
  37. void Task1Callback();                                     // funkcja dla task_1
  38. void Task2Callback();                                     // funkcja dla task_2
  39. void Task3Callback();                                     // funkcja dla task_2
  40.  
  41. // --- TYPEDEF ------------------------------------------------------------------------------ //
  42.  
  43.  
  44. // --- DEFINE ------------------------------------------------------------------------------- //
  45.  
  46. #define SerialSpeed 115200          // prędkość komunikacji szeregowej
  47. #define RxTxSpeed    19200          // prędkość transmisji RxTx
  48. #define true        1               // True   - prawda
  49. #define false       0               // False  - fałsz
  50. #define Terminal    true            // Terminal jest True
  51. #define RamDebug    false            // Debuger wolnej pamięci RAM
  52.  
  53. // --- INCLUDE ------------------------------------------------------------------------------ //
  54.  
  55. #include <WiFi.h>                   // biblioteka obsługi Wi-Fi
  56. #include <NTPClient.h>              // dla serwera NTP
  57. #include <ESP32Time.h>              // zegar RTC ESP32
  58. #include <SPIFFS.h>                 // system plików SPIFFS
  59. #include <FTPServer.h>              // Serwer FTP
  60. #include "SoftwareSerial.h"         // RX TX - jeszcze nie zaimplementowano
  61. #include <TFT_eSPI.h>               // Sprzętowa biblioteka TFT
  62. #include <SPI.h>
  63.  
  64. #if Terminal                          
  65.     #include "tools.h"              // moje narzędzia dla Serial jeśli Terminal True    
  66. #endif                                
  67.  
  68. #include "pogoda.h"                 // moja biblioteka do obsługi serwera pogodowego
  69. #include "kartaSD.h"                // moja biblioteka do obsługi SD i SPIFFS
  70.  
  71. // --- STAŁE GLOBALNE ------------------------------------------------------------------------ //
  72.  
  73. const char *ssid     = "DIABLO";                          // wifi ssid sieci  
  74. const char *password = "XXX";                     // wifi hasło sieci
  75.  
  76. struct SCzas
  77. {
  78.     String SformatowanaData;
  79.     int    DzienTygodnia;
  80.     int    DzienMiesiaca;
  81.     int    Miesiac;
  82.     int    Rok;
  83.     String SformatowanyCzas;
  84.     int    Godzina;
  85.     int    Minuta;
  86.     int    Sekunda;
  87. }
  88. zegar;
  89.  
  90. // --- obsługa zapisu temperatur i obliczanie średniej dziennej ------------
  91.  
  92. double    TabTemperatura[24];          // tablica do przechowywanie temperatur
  93. String    SrednieTemperatury = "";     // łańcuch String ze średnimi temperaturami
  94. uint8_t   TabTemperaturaIndex = 0;     // index zapisanych danych
  95.  
  96. int       TabCisnienie[24];            // tablica do przechowywania cisnienia
  97. String    SrednieCisnienie = "";       // łańcuch String ze średnimi cisnieniami
  98. uint8_t   TabCisnienieIndex = 0;       // index zapisanych danych
  99.  
  100. int       TabWilgotnosc[24];           // tablica do przechowywania wilgotnosci
  101. String    SredniaWilgotnosc = "";      // łańcuch String ze średnimi wilgotnościami
  102. uint8_t   TabWilgotnoscIndex = 0;      // index zapisanych danych
  103.  
  104. int       TabZachmurzenie[24];         // tablica do przechowywania zachmurzenia
  105. String    SrednieZachmurzenie = "";    // łańcuch String ze średnim zachmurzeniem
  106. uint8_t   TabZachmurzenieIndex = 0;    // index zapisanych danych
  107.  
  108. double    TabPredkoscWiatru[24];       // tablica do przechowywania prędkości wiatru
  109. String    SredniaPredkoscWiatru;       // łańcuch String ze średnimi prędkościami wiatru
  110. uint8_t   TabWiatrIndex = 0;           // index zapisanych danych
  111.  
  112. String    WschodSlonca = "";           // łańcuch String do przechowywania wschodu słońca
  113. String    ZachodSlonca = "";           // łańcuch String do przechowywania zachodu słońca
  114. bool      Flaga_Sloneczko = false;     // pobieramy tylko raz na dobę, głupie nazwy :-) słoneczko
  115.  
  116. bool      Flaga_NowyDzien = false;     // czy nowy dzień   ?  TAK/NIE True/False
  117. bool      Flaga_NowaGodzina = false;   // czy nowa godzina ?  TAK/NIE True/False
  118. bool      Flaga_NowaMinuta = false;    // czy nowa minuta  ?  TAK/NIE True/False
  119.  
  120. int       czyNowyDzien = 0;            // zmienna globalna do porównania
  121. int       czyNowaGodzina = 0;          // zmienna globalna do porównania
  122. int       czyNowaMinuta =  0;          // zmienna globalna do porównania
  123.  
  124. #define LOOP_PERIOD 35 // Display updates every 35 ms
  125.  
  126. bool Flaga_TFT_Panel_1  = false;
  127.  
  128.  
  129. // --- OBIEKTY ------------------------------------------------------------------------------ //
  130.  
  131. #if Terminal
  132.     Tools tools;                                          // obiekt tools jeśli Terminal True
  133. #endif
  134.  
  135. TaskHandle_t CPU_Core_0;                                  // rdzeń nr. 0 CPU - ESP32
  136. TaskHandle_t CPU_Core_1;                                  // rdzeń nr. 1 CPU - ESP32
  137. WiFiUDP ntpUDP;                                           // ntp                      
  138. NTPClient timeClient(ntpUDP, "pool.ntp.org", 3600);       // ntp client
  139. ESP32Time rtc;                                            // zegar wewnętrznyRTC ESP32
  140. TPogoda pogoda("Lubin","Pl");                             // pseudo-obiekt pogoda (miasto,kraj)
  141. FTPServer ftpSrv(SPIFFS);                                 // serwer FTP na systemie plików SPIFFS
  142. SoftwareSerial RxTx( 4, 5);                               // RX = pinD1, TX = pinD2 na ESP2886
  143.  
  144. TFT_eSPI tft = TFT_eSPI();                                // wyświetlacz TFT
  145. #include "tft.h"
  146.  
  147. TFTPanel Panel(tft);
  148.  
  149. // --- SETUP INIT --------------------------------------------------------------------------- //
  150.  
  151. void Terminal_Start()
  152. {
  153.     #if Terminal
  154.         Serial.begin(SerialSpeed);    
  155.         tools.TypeWriter(" Tomek Home System v0.08 Beta for ESP32 ");
  156.         tools.PokazZasobySystemowe(false, true);
  157.     #endif
  158. }
  159.  
  160. void SPIFFS_Start()
  161. {    
  162.     //SPIFFS_Format();
  163.     if (SPIFFS.begin())    
  164.     {        
  165.         #if Terminal        
  166.             tools.PokazWiadomosc("SETUP","SPIFFS","Pomyslnie zamontowano SPIFFS");
  167.         #endif
  168.  
  169.         #if Terminal
  170.             #if RamDebug
  171.                 tools.PokazWolnyRAM(true, true, 60);
  172.             #endif
  173.         #endif
  174.     }
  175.     else
  176.     {
  177.         #if Terminal        
  178.             tools.PokazWiadomosc("SETUP","SPIFFS","Blad. Nie zamontowano SPIFFS");
  179.         #endif
  180.  
  181.         #if Terminal
  182.             #if RamDebug
  183.                 tools.PokazWolnyRAM(true, true, 60);
  184.             #endif
  185.         #endif
  186.     }        
  187. }
  188.  
  189. void WiFi_Start()
  190. {
  191.     WiFi.begin(ssid, password);
  192.  
  193.     #if Terminal                                                                                
  194.         tools.PokazWiadomosc("SETUP","Nawiazuje polaczenie z siecia Wi-Fi");                    
  195.     #endif                                                                                      
  196.                                                                                                
  197.     while ( WiFi.status() != WL_CONNECTED )                                                    
  198.     {                                                                                          
  199.         #if Terminal                                                                            
  200.             tools.PokazWiadomosc(".",150);                                                      
  201.         #endif                                                                                  
  202.     }                  
  203.  
  204.     #if Terminal                                                                                              
  205.         tools.PokazWiadomosc("SETUP","Polaczono z siecia WiFI");                                          
  206.         tools.PokazWiadomosc("SETUP","Twoj adres IP",WiFi.localIP().toString().c_str());                      
  207.     #endif  
  208. }
  209.  
  210. void FTP_Start()
  211. {
  212.     ftpSrv.begin(F("ESP32"), F("ESP32"));
  213.    
  214.     #if Terminal                                                                            
  215.             tools.PokazWiadomosc("SETUP", "FTP", "Uruchomiono serwer FTP");                                                      
  216.             tools.PokazWiadomosc("SETUP", "Login FTP", "ESP32");
  217.             tools.PokazWiadomosc("SETUP", "Haslo FTP", "ESP32");
  218.     #endif  
  219. }
  220.  
  221. void TimeCLient_Start()
  222. {
  223.     timeClient.begin();        
  224.     AktualizujCzas();    
  225.  
  226.     #if Terminal
  227.         tools.PokazWiadomosc("SETUP", "TimeClient","Uruchomiono klienta");
  228.     #endif
  229. }
  230.  
  231. void Reboot_Start()
  232. {
  233.     ArchiwizujReboot();
  234.  
  235.     #if Terminal
  236.         tools.PokazWiadomosc("SETUP", "Reboot","Zapisano datę i czas ponownego uruchomienia");
  237.     #endif
  238. }
  239.  
  240. // --- SETUP -------------------------------------------------------------------------------- //
  241.  
  242. void setup()
  243. {
  244.     RxTx.begin(RxTxSpeed);    // uruchom komunikację RxTx
  245.     Terminal_Start();         // start Terminala Serial
  246.     WiFi_Start();             // start WiFi
  247.     SPIFFS_Start();           // start systemu plików SPIFFS            
  248.     FTP_Start();              // start serwera FTP  
  249.     TimeCLient_Start();       // start klienta Time  
  250.              
  251.     pogoda.PobierzPogode();   // pobierz by uniknąć błedów w przypadku wywołania wątku    
  252.  
  253.     Panel.PanelInit();
  254.     Panel.AnalogPanel_v1_Create();  
  255.     Panel.AnalogPanel_v1_Show(int (pogoda.PublicPobierzTemperature()), pogoda.PublicPobierzWilgotnosc()) ;
  256.  
  257.    
  258.     // --- CPU_Core_0 ----------------------------------------------------------------------------------
  259.                                                                                                        
  260.     xTaskCreatePinnedToCore(Core_0_Task1, "CPU_Core_0", 10000, NULL, 1, &CPU_Core_0, 0);                
  261.     vTaskDelay(500 / portTICK_PERIOD_MS);                                                              
  262.                                                                                                        
  263.     xTaskCreatePinnedToCore(Core_0_Task2, "CPU_Core_0", 10000, NULL, 1, &CPU_Core_0, 0);                
  264.     vTaskDelay(500 / portTICK_PERIOD_MS);                                                              
  265.                                                                                                        
  266.     xTaskCreatePinnedToCore(Core_0_Task3, "CPU_Core_0", 10000, NULL, 1, &CPU_Core_0, 0);                
  267.     vTaskDelay(500 / portTICK_PERIOD_MS);                                                              
  268.  
  269.     xTaskCreatePinnedToCore(Core_0_Task4, "CPU_Core_0", 10000, NULL, 1, &CPU_Core_0, 0);                
  270.     vTaskDelay(500 / portTICK_PERIOD_MS);            
  271.  
  272.     xTaskCreatePinnedToCore(Core_0_Task5, "CPU_Core_0", 10000, NULL, 1, &CPU_Core_0, 0);                
  273.     vTaskDelay(500 / portTICK_PERIOD_MS);            
  274.        
  275.     // --- CPU_Core_1 ----------------------------------------------------------------------------------
  276.                                                                                                          
  277.     xTaskCreatePinnedToCore(Core_1_Task1, "CPU_Core_1", 10000, NULL, 1, &CPU_Core_1, 1);                
  278.     vTaskDelay(500 / portTICK_PERIOD_MS);                                                                
  279.                                                                                                          
  280.     xTaskCreatePinnedToCore(Core_1_Task2, "CPU_Core_1", 10000, NULL, 1, &CPU_Core_1, 1);                
  281.     vTaskDelay(500 / portTICK_PERIOD_MS);                                                                
  282.  
  283.     xTaskCreatePinnedToCore(Core_1_Task3, "CPU_Core_1", 10000, NULL, 1, &CPU_Core_1, 1);                
  284.     vTaskDelay(500 / portTICK_PERIOD_MS);      
  285.    
  286.     Reboot_Start();   // archiwizuj do pliku czas ponownego uruchomienia systemu  
  287. }
  288.  
  289. // ----------------------------------------------------------------------------------------------------
  290. // --- Rdzeń 0 CPU - Zadanie 1 - co 15 minut ----------------------------------------------------------
  291.                                                                                                        
  292. void Core_0_Task1( void * pvParameters )                          // Rdzeń 0 Zadanie 1                  
  293. {                                                                 // początek                          
  294.     for(;;)                                                       // nieskończona pętla                
  295.     {                                                             // początek FOR                      
  296.         #if Terminal
  297.             tools.DrukujLinie(60);
  298.             tools.PokazWiadomosc("ESP32","CORE", "Wykonuje watek Task1 na CORE-0");
  299.             #if RamDebug
  300.                 tools.PokazWolnyRAM(true, true, 60);
  301.             #endif
  302.         #endif
  303.  
  304.         pogoda.PobierzPogode();                                   // pobierz pogodę z serwera                                                            
  305.         pogoda.PokazPogode();                                     // wyświetl pogodę
  306.  
  307.         // ------------------------------------------------------------------------------------------ //
  308.         // jeśli Flaga_TFT_Panel_1 jest TRUE to znaczy że panel został TEMPERATURY i WILGOTNOŚCI      //
  309.         // jest obecnie wyświetlony na TFT. Co 15 minut po pobraniu danych z serwera OpenWeatherMap   //
  310.         // wyświetl zaktualizowane odczyty na wyświetlaczu analogowym                                 //
  311.         // ------------------------------------------------------------------------------------------ //
  312.        
  313.          
  314.  
  315.         // ------------------------------------------------------------------------------------------ //
  316.        
  317.        
  318.         delay(900000);                 // wykonuj 15 min                    
  319.     }                                                            
  320. }      
  321.  
  322. // ----------------------------------------------------------------------------------------------------
  323. // --- Rdzeń 0 CPU - Zadanie 2 - co 10 minut ----------------------------------------------------------
  324.  
  325. void Core_0_Task2( void * pvParameters )                          // Rdzeń 0 Zadanie 1                  
  326. {                                                                 // początek                          
  327.     for(;;)                                                       // nieskończona pętla                
  328.     {                                                             // początek FOR                                    
  329.         AktualizujCzas();
  330.        
  331.         if (czyNowaGodzina != zegar.Godzina)      // czy zmieniła się godzina ?
  332.         {
  333.             czyNowaGodzina = zegar.Godzina;       // jeśli tak zapisz nową godzinę do zmiennej Godzina
  334.             Flaga_NowaGodzina = true;             // flaga na true
  335.         }
  336.  
  337.         if (czyNowyDzien != zegar.DzienMiesiaca)  // czy zmienił się dzien ?
  338.         {
  339.             czyNowyDzien = zegar.DzienMiesiaca;   // jeśli tak zapisz nowy dzień do zmiennej Dzien
  340.             Flaga_NowyDzien = true;               // flaga na true
  341.             Flaga_Sloneczko = true;               // flaga dla wschod i zachod slonca
  342.         }
  343.  
  344.         #if Terminal
  345.             tools.DrukujLinie(60);
  346.             tools.PokazWiadomosc("ESP32", "CORE", "Wykonuje watek Task2 na CORE-0");                      
  347.             #if RamDebug
  348.                 tools.PokazWolnyRAM(true, true, 60);
  349.             #endif
  350.         #endif
  351.        
  352.         delay(600000);                 // wykonuj co 10 minut
  353.     }                                                            
  354. }                                                            
  355.  
  356. // ----------------------------------------------------------------------------------------------------
  357. // --- Rdzeń 0 CPU - Zadanie 3 - co 1 minutę ----------------------------------------------------------
  358.  
  359. void Core_0_Task3( void * pvParameters )                  // CPU Core 0 - task 3  
  360. {                                                              
  361.     for(;;)                                                    
  362.     {                                                          
  363.         if( czyNowaMinuta != rtc.getMinute())             // sprawdź czy zmieniła się minuta    
  364.         {
  365.             Flaga_NowaMinuta = true;                      // minuta się zmieniła - ustaw FLAGĘ
  366.             czyNowaMinuta = rtc.getMinute();              // altualizuj z RTC
  367.  
  368.             #if Terminal              
  369.                 tools.PokazWiadomosc("CORE0 TASK3","Czas RTC", rtc.getTime().c_str());    
  370.                 #if RamDebug
  371.                     tools.PokazWolnyRAM(true, true, 60);
  372.                 #endif                        
  373.             #endif              
  374.         }    
  375.            
  376.         Panel.AnalogPanel_v1_Show(int (pogoda.PublicPobierzTemperature()), pogoda.PublicPobierzWilgotnosc());
  377.        
  378.         delay(60000);          // wykonuj co 1 minute
  379.     }                                                            
  380. }
  381.  
  382. // ----------------------------------------------------------------------------------------------------
  383. // --- Rdzeń 0 CPU - Zadanie 4 - co 1 minutę ----------------------------------------------------------
  384.  
  385. void Core_0_Task4( void * pvParameters )                  // CPU Core 0 - task 4        
  386. {                                                                
  387.     for(;;)                                                      
  388.     {                                                    
  389.         if ( Flaga_NowyDzien )                            // jeśli minęła północ
  390.         {
  391.             Flaga_NowyDzien = false;                      // przestaw flagę na false, wejście udane
  392.  
  393.             #if Terminal
  394.                 tools.DrukujLinie(60);
  395.             #endif
  396.            
  397.             if (TabTemperaturaIndex > 0)                  // jeśli istnieją jakieś dane ( index > 0)
  398.             {
  399.                 ArchiwizujTemperature();                  // archiwizuj temperaturę
  400.                 TabTemperaturaIndex = 0;                  // resetuj index tablicy
  401.                 SrednieTemperatury = "";                  // resetuj stringa
  402.             }                                             // lub jeśli nie ma danych pokaz wiadomosc
  403.             else tools.PokazWiadomosc("CORE0 TASK4","Temperatura","Nie ma co archiwizowac !");
  404.            
  405.             if (TabCisnienieIndex > 0)
  406.             {
  407.                 ArchiwizujCisnienie();
  408.                 TabCisnienieIndex = 0;        
  409.                 SrednieCisnienie = "";  
  410.             }
  411.             else tools.PokazWiadomosc("CORE0 TASK4","Cisnienie","Nie ma co archiwizowac !");
  412.  
  413.             if (TabWilgotnoscIndex > 0)
  414.             {
  415.                 ArchiwizujWilgotnosc();
  416.                 TabWilgotnoscIndex = 0;
  417.                 SredniaWilgotnosc = "";
  418.             }
  419.             else tools.PokazWiadomosc("CORE0 TASK4","Wilgotnosc","Nie ma co archiwizowac !");
  420.  
  421.             if (TabZachmurzenieIndex > 0)
  422.             {
  423.                 ArchiwizujZachmurzenie();
  424.                 TabZachmurzenieIndex = 0;
  425.                 SrednieZachmurzenie = "";
  426.             }
  427.             else tools.PokazWiadomosc("CORE0 TASK4","Zachmurzenie","Nie ma co archiwizowac !");
  428.  
  429.             if (TabWiatrIndex > 0)
  430.             {
  431.                 ArchiwizujPredkoscWiatru();
  432.                 TabWiatrIndex = 0;
  433.                 SredniaPredkoscWiatru = "";
  434.             }
  435.             else tools.PokazWiadomosc("CORE0 TASK4","Predkosc Wiatru","Nie ma co archiwizowac !");          
  436.  
  437.         #if Terminal
  438.             #if RamDebug
  439.                 tools.PokazWolnyRAM(true, true, 60);
  440.             #endif
  441.         #endif
  442.  
  443.         }
  444.        
  445.         delay(600000);                 // wykonuj co 10 minut
  446.     }                                                
  447. }
  448.  
  449. // ----------------------------------------------------------------------------------------------------
  450. // --- Rdzeń 0 CPU - Zadanie 5------------------------------------------------------------------------
  451.  
  452. void Core_0_Task5( void * pvParameters )            // CPU Core 0 - task 5                
  453. {                                                                
  454.     for(;;)                                                      
  455.     {        
  456.         if ( Flaga_NowaGodzina )                                                    
  457.         {
  458.             Flaga_NowaGodzina = false;              // przestaw flagę na false, wejście udane
  459.  
  460.             #if Terminal
  461.                 tools.DrukujLinie(60);
  462.             #endif
  463.            
  464.             BudujTabliceTemperatur();               // zapisz do tablicy nowe dane o temperatyrze powietrza
  465.             BudujTabliceCisnien();                  // zapisz do tablicy nowe dane o ciśnieniu atmosferycznym
  466.             BudujTabliceWilgotnosci();              // zapisz do tablicy nowe dane o wilgotności powietrza
  467.             BudujTabliceZachmurzenia();             // zapisz do tablicy nowe dane o zachmurzeniu nieba
  468.             BudujTablicePredkosciWiatru();          // zapisz do tablicy nowe dane o prędkości wiatru
  469.            
  470.             tools.DrukujLinie(60);
  471.             PokazTabliceTemperatur();               // pokaż tablicę z pobranymi informacjami o temperaturze
  472.             PokazSredniaTemperatur();               // pokaż średnią temperaturę
  473.            
  474.             PokazTabliceCisnien();                  // pokaż tablicę z pobranymi informacjami o ciśnieniu
  475.             PokazSredniaCisnien();                  // pokaż średnie ciśnienie
  476.            
  477.             PokazTabliceWilgotnosci();              // pokaż tablicę z pobranymi informacjami o wilgotności
  478.             PokazSredniaWilgotnosc();               // pokaż średnią wilgotność
  479.  
  480.             PokazTabliceZachmurzenia();             // pokaż tablicę z pobranymi informacjami o zachmurzeniu
  481.             PokazSrednieZachmurzenie();             // pokaż średnie zachmurzenie nieba
  482.  
  483.             PokazTablicePredkosciWiatru();          // pokaż tablicę z pobranymi prędkościamia wiatru
  484.             PokazSredniaPredkoscWiatru();           // pokaż średnią prędkość wiatru
  485.  
  486.             #if Terminal
  487.                 #if RamDebug
  488.                     tools.PokazWolnyRAM(true, true, 60);
  489.                 #endif
  490.             #endif
  491.         }
  492.  
  493.         if ( Flaga_Sloneczko )                      // archiwuzuj 1x na dobę wschód / zachód słońca
  494.         {
  495.             #if Terminal
  496.                  tools.DrukujLinie(60);
  497.             #endif
  498.            
  499.             BudujBuforSloneczko();              // zbuduj bufor WschodSlonca / ZachodSłonca
  500.             ArchiwizujSloneczko();              // zapisz odczyty do pamięci SPIFFS
  501.             PokazBuforSloneczko();              // pokaz zawartość buforów
  502.             Flaga_Sloneczko = false;            // przestaw flagę na false
  503.             WschodSlonca = "";                  // resetuj bufor WschodSlonca ( EMPTY )
  504.             ZachodSlonca = "";                  // resetuj bufor ZachodSlonca ( EMPTY )
  505.  
  506.             #if Terminal
  507.                 #if RamDebug
  508.                     tools.PokazWolnyRAM(true, true, 60);
  509.                 #endif
  510.             #endif
  511.         }
  512.         else tools.PokazWiadomosc("CORE0 TASK4","Wschod Zachod Slonca","Nie ma co archiwizowac !");  
  513.  
  514.         delay(3600000);                 // wykonuj co 1h                    
  515.     }                                                            
  516. }
  517.  
  518. // ----------------------------------------------------------------------------------------------------
  519. // --- Rdzeń 1 CPU - Zadanie 1 ------------------------------------------------------------------------
  520.  
  521. void Core_1_Task1( void * pvParameters )                          // Rdzeń 0 Zadanie 1                  
  522. {                                                                 // początek                          
  523.     for(;;)                                                       // nieskończona pętla                
  524.     {                                                             // początek FOR                                      
  525.         ftpSrv.handleFTP();                                       // serwer FTP w tle  
  526.         delay(10);                                                //
  527.     }                                                             // koniec pętli FOR                  
  528. }
  529.  
  530. // ----------------------------------------------------------------------------------------------------
  531. // --- Rdzeń 1 CPU - Zadanie 2 ------------------------------------------------------------------------
  532.  
  533. void Core_1_Task2( void * pvParameters )                          // Rdzeń 0 Zadanie 1                  
  534. {                                                                 // początek                          
  535.     for(;;)                                                       // nieskończona pętla                
  536.     {                                                             // początek FOR                                              
  537.         Panel.MultiSwitchPanel_v1(rtc);
  538.         delay(5000);                                             // wykonuj co 10 sekund                  
  539.     }                                                             // koniec pętli FOR                  
  540. }
  541.  
  542. // ----------------------------------------------------------------------------------------------------
  543. // --- Rdzeń 1 CPU - Zadanie 3 ------------------------------------------------------------------------
  544.  
  545. void Core_1_Task3( void * pvParameters )                          // Rdzeń 0 Zadanie 1                  
  546. {                                                                 // początek                          
  547.     for(;;)                                                       // nieskończona pętla                
  548.     {                                                             // początek FOR                                              
  549.         Panel.DigitalClock_v1_Show(rtc);                          // wyświetl ZEGAR
  550.         delay(1000 );                                             // wykonuj co 1s                  
  551.     }                                                             // koniec pętli FOR                  
  552. }
  553.  
  554. // ----------------------------------------------------------------------------------------------------
  555. // --- Task 0 Callback --- co 30 minut ----------------------------------------------------------------
  556.  
  557. void Task0Callback()                                      // funkcja dla task_0
  558. {
  559.    
  560. }
  561.  
  562. // ----------------------------------------------------------------------------------------------------
  563. // --- Task 1 Callback --------------------------------------------------------------------------------
  564.  
  565. void Task1Callback()                                       // funkcja dla task_1
  566. {
  567.  
  568. }
  569.  
  570. // ----------------------------------------------------------------------------------------------------
  571. // --- Task 2 Callback --------------------------------------------------------------------------------
  572.  
  573. void Task2Callback()                                       // funkcja dla task2
  574. {
  575.  
  576. }
  577.  
  578. // ----------------------------------------------------------------------------------------------------
  579. // --- Task 1 Callback --------------------------------------------------------------------------------
  580.  
  581. void Task3Callback()                                      // funkcja dla task_3
  582. {
  583.  
  584. }
  585.  
  586. // ----------------------------------------------------------------------------------------------------
  587. // --- L O O P ----------------------------------------------------------------------------------------
  588. // ----------------------------------------------------------------------------------------------------
  589.  
  590. void loop()
  591. {
  592.    
  593. }
  594.  
  595. // ----------------------------------------------------------------------------------------------------
  596. // --- Archiwizuj Temperature -------------------------------------------------------------------------
  597.  
  598. void ArchiwizujTemperature()
  599. {
  600.     String Bufor = "[" + zegar.SformatowanaData + "]" + SrednieTemperatury  + "\n";
  601.     DodajDoPliku(SPIFFS, "/temperatura.txt", &Bufor);    
  602. }
  603.  
  604. // ----------------------------------------------------------------------------------------------------
  605.  
  606. void BudujTabliceTemperatur()
  607. {
  608.     TabTemperatura[TabTemperaturaIndex] = pogoda.PublicPobierzTemperature();
  609.     SrednieTemperatury += "[" + String(TabTemperatura[TabTemperaturaIndex]) + "]";
  610.     TabTemperaturaIndex ++;
  611.    
  612.     #if Terminal
  613.         tools.PokazWiadomosc("ESP","BudujTabliceTemperatur","Pobrano do tablicy");        
  614.         #if RamDebug
  615.             tools.PokazWolnyRAM(false, false);
  616.         #endif
  617.     #endif
  618. }
  619.  
  620. // ----------------------------------------------------------------------------------------------------
  621.  
  622. void PokazTabliceTemperatur()
  623. {
  624.     tools.PokazWiadomosc("ESP","Tablica Temperatur", SrednieTemperatury.c_str());
  625.    
  626.     #if RamDebug
  627.         tools.PokazWolnyRAM(false, false);
  628.     #endif
  629. }
  630.  
  631. // ----------------------------------------------------------------------------------------------------
  632.  
  633. void PokazSredniaTemperatur()
  634. {
  635.     double sumator = 0;
  636.     for ( uint_fast8_t i = 0; i < TabTemperaturaIndex; i ++ ) sumator += TabTemperatura[i];
  637.     if ( TabTemperaturaIndex > 0 ) sumator = sumator / TabTemperaturaIndex; // nie dziel przez ZERO
  638.  
  639.     String bufor = String(sumator) + " st.C";
  640.     tools.PokazWiadomosc("ESP","Srednia Temperatura",bufor.c_str());
  641.    
  642.     #if RamDebug
  643.         tools.PokazWolnyRAM(false, false);
  644.     #endif
  645. }
  646.  
  647. // ----------------------------------------------------------------------------------------------------
  648. // --- Archiwizuj Cisnienie ---------------------------------------------------------------------------
  649.  
  650. void ArchiwizujCisnienie()
  651. {
  652.     String Bufor = "[" + zegar.SformatowanaData + "]" + SrednieCisnienie + "\n";
  653.     DodajDoPliku(SPIFFS, "/cisnienie.txt", &Bufor);    
  654. }
  655.  
  656. // ----------------------------------------------------------------------------------------------------
  657.  
  658. void BudujTabliceCisnien()
  659. {
  660.     TabCisnienie[TabCisnienieIndex] = pogoda.PublicPobierzCisnienie();
  661.     SrednieCisnienie += "[" + String(TabCisnienie[TabCisnienieIndex]) + "]";
  662.     TabCisnienieIndex ++;
  663.    
  664.     #if Terminal        
  665.         tools.PokazWiadomosc("ESP","BudujTabliceCisnien","Pobrano do tablicy");        
  666.         #if RamDebug
  667.             tools.PokazWolnyRAM(false, false);
  668.         #endif    
  669.     #endif
  670. }
  671.  
  672. // ----------------------------------------------------------------------------------------------------
  673.  
  674. void PokazTabliceCisnien()
  675. {
  676.     tools.PokazWiadomosc("ESP","Tablica Cisnienia", SrednieCisnienie.c_str());
  677.     #if RamDebug
  678.         tools.PokazWolnyRAM(true, true, 60);
  679.     #endif
  680. }
  681.  
  682. // ----------------------------------------------------------------------------------------------------
  683.  
  684. void PokazSredniaCisnien()
  685. {
  686.     uint16_t sumator = 0;
  687.     for ( uint_fast8_t i = 0; i < TabCisnienieIndex; i ++ ) sumator += TabCisnienie[i];
  688.     if ( TabCisnienieIndex > 0 ) sumator = sumator / TabCisnienieIndex; // nie dziel przez ZERO
  689.  
  690.     String bufor = String(sumator) + " mPA";
  691.     tools.PokazWiadomosc("ESP","Srednia Cisnien",bufor.c_str());
  692.    
  693.     #if RamDebug
  694.         tools.PokazWolnyRAM(false, false);
  695.     #endif
  696. }
  697.  
  698. // ----------------------------------------------------------------------------------------------------
  699. // --- Archiwizuj Wilgotnosc --------------------------------------------------------------------------
  700.  
  701. void ArchiwizujWilgotnosc()
  702. {
  703.     String Bufor = "[" + zegar.SformatowanaData + "]" + SredniaWilgotnosc + "\n";
  704.     DodajDoPliku(SPIFFS, "/wilgotnosc.txt", &Bufor);    
  705. }
  706.  
  707. // ----------------------------------------------------------------------------------------------------
  708.  
  709. void BudujTabliceWilgotnosci()
  710. {
  711.     TabWilgotnosc[TabWilgotnoscIndex] = pogoda.PublicPobierzWilgotnosc();
  712.     SredniaWilgotnosc += "[" + String(TabWilgotnosc[TabWilgotnoscIndex]) + "]";
  713.     TabWilgotnoscIndex ++;
  714.    
  715.     #if Terminal
  716.         tools.PokazWiadomosc("ESP","BudujTabliceWilgotnosci","Pobrano do tablicy");        
  717.         #if RamDebug
  718.             tools.PokazWolnyRAM(false, false);
  719.         #endif
  720.     #endif
  721. }
  722.  
  723. // ----------------------------------------------------------------------------------------------------
  724.  
  725. void PokazTabliceWilgotnosci()
  726. {
  727.     tools.PokazWiadomosc("ESP","Tablica Wilgotnosci", SredniaWilgotnosc.c_str());
  728.     #if RamDebug
  729.         tools.PokazWolnyRAM(true, true, 60);
  730.     #endif
  731. }
  732.  
  733. // ----------------------------------------------------------------------------------------------------
  734.  
  735. void PokazSredniaWilgotnosc()
  736. {
  737.     uint16_t sumator = 0;
  738.     for ( uint_fast8_t i = 0; i < TabWilgotnoscIndex; i ++ ) sumator += TabWilgotnosc[i];
  739.     if ( TabWilgotnoscIndex > 0 ) sumator = sumator / TabWilgotnoscIndex; // nie dziel przez ZERO
  740.  
  741.     String bufor = String(sumator) + " %";
  742.     tools.PokazWiadomosc("ESP","Srednia Wilgotnosc",bufor.c_str());
  743.    
  744.     #if RamDebug
  745.         tools.PokazWolnyRAM(false, false);
  746.     #endif
  747. }
  748.  
  749. // ----------------------------------------------------------------------------------------------------
  750. // --- Archiwizuj Zachmurzenie ------------------------------------------------------------------------
  751.  
  752. void ArchiwizujZachmurzenie()
  753. {
  754.     String Bufor = "[" + zegar.SformatowanaData + "]" + SrednieZachmurzenie + "\n";
  755.     DodajDoPliku(SPIFFS, "/zachmurzenie.txt", &Bufor);    
  756. }
  757.  
  758. // ----------------------------------------------------------------------------------------------------
  759.  
  760. void BudujTabliceZachmurzenia()
  761. {
  762.     TabZachmurzenie[TabZachmurzenieIndex] = pogoda.PublicPobierzZachmurzenie();
  763.     SrednieZachmurzenie += "[" + String(TabZachmurzenie[TabZachmurzenieIndex]) + "]";
  764.     TabZachmurzenieIndex ++;
  765.    
  766.     #if Terminal
  767.         tools.PokazWiadomosc("ESP","BudujTabliceZachmurzenia","Pobrano do tablicy");        
  768.         #if RamDebug
  769.             tools.PokazWolnyRAM(false, false);
  770.         #endif  
  771.     #endif
  772. }
  773.  
  774. // ----------------------------------------------------------------------------------------------------
  775.  
  776. void PokazTabliceZachmurzenia()
  777. {
  778.     tools.PokazWiadomosc("ESP","Tablica Zachmurzenia", SrednieZachmurzenie.c_str());
  779.    
  780.     #if RamDebug
  781.         tools.PokazWolnyRAM(false, false);
  782.     #endif
  783. }
  784.  
  785. // ----------------------------------------------------------------------------------------------------
  786.  
  787. void PokazSrednieZachmurzenie()
  788. {
  789.     uint16_t sumator = 0;
  790.     for ( uint_fast8_t i = 0; i < TabZachmurzenieIndex; i ++ ) sumator += TabZachmurzenie[i];
  791.     if ( TabZachmurzenieIndex > 0 ) sumator = sumator / TabZachmurzenieIndex; // nie dziel przez ZERO
  792.  
  793.     String bufor = String(sumator) + " %";
  794.     tools.PokazWiadomosc("ESP","Srednie Zachmurzenie",bufor.c_str());
  795.    
  796.     #if RamDebug
  797.         tools.PokazWolnyRAM(false, false);
  798.     #endif
  799. }
  800.  
  801. // ----------------------------------------------------------------------------------------------------
  802. // --- Archiwizuj Prędkość Wiatru ---------------------------------------------------------------------
  803.  
  804. void ArchiwizujPredkoscWiatru()
  805. {
  806.     String Bufor = "[" + zegar.SformatowanaData + "]" + SredniaPredkoscWiatru + "\n";
  807.     DodajDoPliku(SPIFFS, "/wiatr.txt", &Bufor);    
  808. }
  809.  
  810. // ----------------------------------------------------------------------------------------------------
  811.  
  812. void BudujTablicePredkosciWiatru()
  813. {
  814.     TabPredkoscWiatru[TabWiatrIndex] = pogoda.PublicPobierzPredkoscWiatru();
  815.     SredniaPredkoscWiatru += "[" + String(TabPredkoscWiatru[TabWiatrIndex]) + "]";
  816.     TabWiatrIndex ++;
  817.    
  818.     #if Terminal
  819.         tools.PokazWiadomosc("ESP","BudujTablicePredkosciWiatru","Pobrano do tablicy");        
  820.         #if RamDebug
  821.             tools.PokazWolnyRAM(false, false);
  822.         #endif
  823.     #endif
  824. }
  825.  
  826. // ----------------------------------------------------------------------------------------------------
  827.  
  828. void PokazTablicePredkosciWiatru()
  829. {
  830.     tools.PokazWiadomosc("ESP","Tablica Predkosc Wiatru", SredniaPredkoscWiatru.c_str());
  831.    
  832.     #if RamDebug
  833.         tools.PokazWolnyRAM(false, false);
  834.     #endif
  835. }
  836.  
  837. // ----------------------------------------------------------------------------------------------------
  838.  
  839. void PokazSredniaPredkoscWiatru()
  840. {
  841.     uint16_t sumator = 0;
  842.     for ( uint_fast8_t i = 0; i < TabWiatrIndex; i ++ ) sumator += TabPredkoscWiatru[i];
  843.     if ( TabWiatrIndex > 0 ) sumator = sumator / TabWiatrIndex; // nie dziel przez ZERO
  844.  
  845.     String bufor = String(sumator) + " km/h";
  846.     tools.PokazWiadomosc("ESP","Srednia Predkosc Wiatru",bufor.c_str());
  847.    
  848.     #if RamDebug
  849.         tools.PokazWolnyRAM(false, false);
  850.     #endif
  851. }
  852.  
  853. // ----------------------------------------------------------------------------------------------------
  854. // --- Archiwizuj Wschod / Zachod Slonca --------------------------------------------------------------
  855.  
  856. void BudujBuforSloneczko()
  857. {
  858.     WschodSlonca = pogoda.PublicPobierzWschodSlonca();      // zapisz do (GLOBAL) String WschodSlonca
  859.     ZachodSlonca = pogoda.PublicPobierzZachodSlonca();      // zapisz do (GLOBAL) String ZachodSlonca
  860. }
  861.  
  862. // ----------------------------------------------------------------------------------------------------
  863.  
  864. void ArchiwizujSloneczko()
  865. {
  866.     String Bufor = "["+ zegar.SformatowanaData +"][Wschod. " + WschodSlonca + "][Zachod. " + ZachodSlonca  + "]"  + "\n";
  867.     DodajDoPliku(SPIFFS, "/slonce.txt", &Bufor);    
  868. }
  869.  
  870. // ----------------------------------------------------------------------------------------------------
  871.  
  872. void ArchiwizujReboot()
  873. {
  874.     String Bufor = "[" + zegar.SformatowanaData + "][" + zegar.SformatowanyCzas + "]\n";
  875.  
  876.     #if Terminal
  877.         tools.DrukujLinie(60);
  878.     #endif
  879.    
  880.     DodajDoPliku(SPIFFS, "/reboot.txt", &Bufor);
  881. }
  882.  
  883. // ----------------------------------------------------------------------------------------------------
  884.  
  885. void PokazBuforSloneczko()
  886. {
  887.     String Bufor = "[Wschod " + WschodSlonca + "][Zachod " + ZachodSlonca + "]";
  888.     tools.PokazWiadomosc("ESP","SLONCE", Bufor.c_str());
  889.    
  890.     #if RamDebug
  891.         tools.PokazWolnyRAM(false, false);
  892.     #endif
  893. }
  894.  
  895. // ----------------------------------------------------------------------------------------------------
  896. // --- Aktualizuj Czas --------------------------------------------------------------------------------
  897.  
  898. void AktualizujCzas()
  899. {
  900.         timeClient.update();                                      // aktualizuj z serwera                                                          
  901.  
  902.         unsigned long epochTime = timeClient.getEpochTime();      // pobierz EpochTime                                        
  903.         struct tm *ptm = gmtime ((time_t *)&epochTime);           // strukrura dla EpochTime
  904.                                                                                            
  905.         zegar.Godzina          =  timeClient.getHours();        // pobierz z NTP i zapisz do struktury          
  906.         zegar.Minuta           =  timeClient.getMinutes();      // pobierz z NTP i zapisz do struktury
  907.         zegar.Sekunda          =  timeClient.getSeconds();      // pobierz z NTP i zapisz do struktury                
  908.         zegar.DzienTygodnia    =  timeClient.getDay();          // pobierz z NTP i zapisz do struktury
  909.         zegar.DzienMiesiaca    =  ptm->tm_mday;                 // pobierz z NTP i zapisz do struktury
  910.         zegar.Miesiac          =  ptm->tm_mon+1;                // pobierz z NTP i zapisz do struktury
  911.         zegar.Rok              =  ptm->tm_year+1900;            // pobierz z NTP i zapisz do struktury
  912.        
  913.         zegar.SformatowanaData =  String(zegar.Rok) + ".";
  914.         if (zegar.Miesiac < 10) zegar.SformatowanaData += "0";        // formatowanie do liczby dziesiatek
  915.         zegar.SformatowanaData += String(zegar.Miesiac) + ".";
  916.         if (zegar.DzienMiesiaca < 10) zegar.SformatowanaData += "0";  // formatowanie do liczby dziesiatek
  917.         zegar.SformatowanaData += String(zegar.DzienMiesiaca);
  918.  
  919.         if (zegar.Godzina < 10) zegar.SformatowanyCzas = "0";        
  920.         else zegar.SformatowanyCzas = "";
  921.         zegar.SformatowanyCzas += String(zegar.Godzina);
  922.         zegar.SformatowanyCzas += ":";                      
  923.         if (zegar.Minuta < 10) zegar.SformatowanyCzas += "0";
  924.         zegar.SformatowanyCzas += String(zegar.Minuta);
  925.         zegar.SformatowanyCzas += ":";
  926.         if (zegar.Sekunda <10) zegar.SformatowanyCzas += "0";
  927.         zegar.SformatowanyCzas += String(zegar.Sekunda);        
  928.        
  929.         #if Terminal        
  930.             tools.DrukujLinie(60);        
  931.             tools.PokazWiadomosc("ESP32", "CORE", "RTC przed synchronizacja");            
  932.             tools.PokazWiadomosc("ESP32", "TIME NTP", zegar.SformatowanyCzas.c_str());
  933.             tools.PokazWiadomosc("ESP32", "TIME RTC",  rtc.getTime().c_str());
  934.             tools.PokazWiadomosc("ESP32", "DATA NTP", zegar.SformatowanaData.c_str());
  935.             tools.PokazWiadomosc("ESP32", "DATA RTC",  rtc.getDate().c_str());            
  936.             tools.PokazWiadomosc("ESP32", "CORE", "Synchronizacja RTC wykonana");
  937.         #endif
  938.  
  939.         // Synchronizacja czasu RTC z serwera NTP ---------------------------------------------------------
  940.  
  941.         rtc.setTime(zegar.Sekunda, zegar.Minuta, zegar.Godzina, zegar.DzienMiesiaca, zegar.Miesiac, zegar.Rok);
  942.  
  943.         // RTC wystartował i został zaktualizowany --------------------------------------------------------    
  944. }
  945. // ----------------------------------------------------------------------------------------------------
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!