sobota, 13 stycznia 2024

BME280 - Sensor temperatury, wilgotności i ciśnienia

 

BME280 (ESP32/ESP2866)


BME280 to prosty w użyciu czujnik temperatury, wilgotności oraz ciśnienia atmosferycznego. Zasilany jest napięciem 3.3V, komunikuje się poprzez interfejs I2C oraz SPI, to precyzyjny sensor bazujący na technologi firmy BOSH. Jest dużo dokładniejszy niż DHT11/DHT22, dokonuje pomiary temperatury w zakresie od -40 °C do + 85 °C z dokładnością ± 1 °C. Zakres pomiarowy wilgotności od 10 do 100 % RH z dokładnością ± 3 % RH, mierzy dodatkowo ciśnienie atmosferyczne od 300 do 1100 hPa z precyzją ± 1 hPa. Ponieważ ciśnienie zmienia się wraz z wysokością, można również oszacować wysokość. Istnieje kilka wersji tego modułu czujnika.

Pokażę Ci, jak podłączyć czujnik do ESP32/ESP2866, zainstalować wymagane biblioteki i napisać prosty szkic wyświetlający odczyty czujnika.

Do poprawnej pracy czujnika potrzebne są dwie biblioteki: Adafruit_BME280 oraz Adafruit_Sensor. Biblioteki możemy pobrać klikając w link i ręcznie przenieść do katalogu Library lub za pomocą narzędzia ArduinoIDE.



INSTALOWANIE BIBLIOTEKI ADAFRUIT BME280



Otwórz Arduino IDE, przejdź do Sketch → Dołącz bibliotekę → Zarządzaj bibliotekami, menadżer bibliotek powinien się otworzyć, wyszukaj: „adafruit bme 280” w polu wyszukiwania i zainstaluj.



Analogicznie postępuje by zainstalować bibliotękę Adafruit Unified Sensor. Jest ona niezbędna do prawidłowej pracy czujnika.



INSTALOWANIE BIBLIOTEKI ADAFRUIT UNIFIED SENSOR


Otwórz Arduino IDE, przejdź do Sketch → Dołącz bibliotekę → Zarządzaj bibliotekami, menadżer bibliotek powienien się otworzyć, wyszukaj: „Adafruit Unified Sensor” w polu wyszukiwania i zainstaluj. Wyświetli się zapewne wiele podobnych bibliotek, z listy wyszukujemy dokładnie tą, która potrzebujemy!



Czujnik ten komunikuje się za pomocą protokołu komunikacyjnego I2C, więc okablowanie jest bardzo proste. Możesz użyć domyślnych pinów I2C dla ESP32 i ESP8266 jak w poniższej tabeli (pobrane biblioteki działają także poprawnie dla Arduino UNO, Arduino Nano oraz Arduino MEGA).



Czujnik BMP280

ESP32

ESP8266

WIN (zasilanie)

3.3 V

3.3 V

GND (masa)

GND

GND

SCL

GPIO_22

GPIO_5 (D1)

SDA

GPIO_21

GPIO_4 (D2)





SCHEMAT PODŁĄCZEŃ dla ESP32



Czujnik BME280 podłączamy 4 przewodami z ESP32:


BME280 VCC z zasilaniem 3.3V w ESP32
BME280 GDN z masą w ESP32
BME280 SDI z GPIO21 (SDA) w ESP32
BME280 SCK z GPIO22 (SCL) w ESP32


Oznaczenia na czujniku BME280 mogą być różne, w zależności od producenta układu, SDI to SDA, SCK to SCL.




S
CHEMAT PODŁĄCZEŃ dla ESP2866



Czujnik BME280 podłączamy 4 przewodami z ESP2866:

BME280 VCC z zasilaniem 3.3V w ESP2866
BME280 GDN z masą w ESP2866
BME280 SDI z D2 (GPIO4 SCA) w ESP2866
BME280 SCK z D1 (GPIO5 SCL) w ESP2866


Oznaczenia na czujniku BME280 mogą być różne, w zależnośni od producenta układu, SDI to SDA, SCK to SCL. Poniżej znajduje się szkic programu dla ArduinoIDE, wykorzystujący czujnik do odczytu temperatury, wilgotności, oraz ciśnienia na postawie którego szacowana jest wysokość położenia nad poziomem morza. Nie jest to wartość dokładna, może odbiegać od rzeczywistego położenia.


// █████████████████████████████████████████████████████
//
// ESP32/ESP8266 BlackBook by PowerTGS (2024)
//
// author : Tomasz Majcher 
// e-mail : powerTGS440@gmail.com
// phone  : +48 668 082121
//
// █████████████████████████████████████████████████████
//
// BME280 demo file
//
// source file      : sourcce/sensor/bme280/bme280.ino
// device           : esp32/esp2866/arduino uno/arduino nano/arduono mega
// code platform    : ArduinoIDE
// 
// █████████████████████████████████████████████████████
// M A K R O
// █████████████████████████████████████████████████████
                                    
#define SEALEVELPRESSURE_HPA  (1013.25)
#define SERIAL        true                         // SERIAL włączony
#define SERIAL_SPEED  115200                       // prędkość SERIAL
#define LOOP_DELAY    10000                        // opóźnienie pętli LOOP 

// █████████████████████████████████████████████████████
// B I B L I O T E K I
// █████████████████████████████████████████████████████                                                                                                                                                                                                                                          

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>

// █████████████████████████████████████████████████████
// O B I E K T   K L A S Y   B M E 2 8 0
// █████████████████████████████████████████████████████

Adafruit_BME280 bme; 

// █████████████████████████████████████████████████████
// Z M I E N N E   G L O B A L N E
// █████████████████████████████████████████████████████

float   temperatura = 0;
float   cisnienie = 0;
float   wilgotnosc = 0;
float   wysokosc = 0;

// █████████████████████████████████████████████████████
// D E K L A R A C J E   F U N K C J I
// █████████████████████████████████████████████████████

void Read_BME_280_Sensor (float &temp, float &hum, float &humi, float &alti);
void Show_BME_280_Sensor (float &temp, float &pres, float &humi, float &alti);

// █████████████████████████████████████████████████████
// S E T U P
// █████████████████████████████████████████████████████

void setup() 
{
  #if SERIAL
      Serial.begin(115200);
      Serial.println();Serial.println();
  #endif
  
  bool status = bme.begin(0x76);      // inicjalizacja czujnika BME230, jeśli podłączenie
                                      // jest poprawne zwróci wartość TRUE, w przeciwnym
                                      // wartość FALSE
  
  if (!status) 
  {     
      #if SERIAL
          Serial.println(F("Nie można odnaleźć czujnika BME280"));
          Serial.println(F("Sprawdź podłączenia do urządzenia!"));
      #endif
      
      while (1);
  }
  else
  {
      #if SERIAL
          Serial.println(F("Pomyślnie zainicjalizowano czujnik BME280"));          
      #endif
  }  
}

// █████████████████████████████████████████████████████
// L O O P
// █████████████████████████████████████████████████████

void loop() 
    Read_BME_280_Sensor(temperatura, cisnienie, wilgotnosc, wysokosc);
    Show_BME_280_Sensor(temperatura, cisnienie, wilgotnosc, wysokosc);
  
    delay(LOOP_DELAY);
}

// █████████████████████████████████████████████████████
// R E A D   B M E   2 8 0   S E N S O R
// █████████████████████████████████████████████████████
// funkcja odczytuje wartości z czujnika BME_280
// zwraca wartości temperatury, cisnienia, wilgotnosci, wysokosci
// na wejsciu otrzymuje adresy zmiennych globalnych
// █████████████████████████████████████████████████████

void Read_BME_280_Sensor (float &temp, float &pres, float &humi, float &alti)
{
    #if SERIAL
        Serial.println(F("[BME280_Sensor] Odczytuje wartosci z czujnika "));
    #endif
    
    temp = bme.readTemperature();
    pres = bme.readPressure() / 100.0F;
    humi = bme.readHumidity();
    alti = bme.readAltitude(SEALEVELPRESSURE_HPA);    
}

// █████████████████████████████████████████████████████
// S H O W   B M E   2 8 0   S E N S O R
// █████████████████████████████████████████████████████
// Funkcja wypisuje wartości z czujnika BME_280, na wejsciu otrzymuje adresy zmiennych 
// globalnych. 
// wartości są wyświetlane jeśli makro SERIAL jest true, w przypadku ustawienia false
// cała zawartość pomiędzy #if SERIAL ... #endif jest pomijana przy kompilacji szkicu
// i nie istnieje w pliku binarnym. To jeden ze sposobów na optymalizację kodu oraz
// oszczędność pamięci RAM I PROGMEM
// █████████████████████████████████████████████████████

void Show_BME_280_Sensor (float &temp, float &pres, float &humi, float &alti)
{
    #if SERIAL
        Serial.print(F("[BME280_Sensor] Temperatura = "));
        Serial.print(temp);
        Serial.println(F(" *C"));  
        Serial.print(F("[BME280_Sensor] Cisnienie = "));
        Serial.print(pres);
        Serial.println(F(" hPa"));
        Serial.print(F("[BME280_Sensor] Średnia wysokość = "));
        Serial.print(alti);
        Serial.println(F(" m"));
        Serial.print(F("[BME280_Sensor] Wilgotność = "));
        Serial.print(humi);
        Serial.println(F(" %"));
        Serial.println();    
    #endif
}

// █████████████████████████████████████████████████████
// END OF FILE : src/sensor/bme280.ino
// █████████████████████████████████████████████████████

sobota, 27 lutego 2021

Arduino NANO + Parser (Serial) + klasa Przekaźnik

 Ze słuchawkami na uszach, słuchając album PULSE Pink Floyd'a dzisiaj prosty parser komend wysyłanych przez Serial do Arduino i sterowanie przekaźnikami (8 sztuk). 

od dzisiaj wszystkie moje projekty są podpisane !!! dlaczego ? czytaj na końcu. To moja własność intelektualna nie na sprzedaż. Projekt należy do firmy TransLine z siedzibą w Lubinie. Nie wyrażam zgody na wykorzystanie kodu w celach zarobkowych.

Ponieważ, za bardzo nie wiem co robić z leżacymi NANO w szufladzie, mam ich tam ok. 20 kupione na ALI po 6zł postanowiłem je wykorzystać jako kontroler przekaźników. Do NANO "rozkazy" są wysyłane z ESP32 w postaci napisu typu STRING który jest parsowany przez funkcje zawarte w tym kodzie: DOWNLOAD

< Przekaznik, 301, 0 >     włącz lub wyłącz Przekaźnik nr. 1
< Przekaznik, 302, 0 >
     włącz lub wyłącz Przekaźnik nr. 2
< Przekaznik, 303, 0 >     włącz lub wyłącz Przekaźnik nr. 3
< Przekaznik, 304, 0 >     włącz lub wyłącz Przekaźnik nr. 4
< Przekaznik, 305, 0 >     włącz lub wyłącz Przekaźnik nr. 5
< Przekaznik, 306, 0 >     włącz lub wyłącz Przekaźnik nr. 6
< Przekaznik, 307, 0 >     włącz lub wyłącz Przekaźnik nr. 7
< Przekaznik, 308, 0 >     włącz lub wyłącz Przekaźnik nr. 8
< Przekaznik, 309, 0 >     włącz wszystkie przekaźniki 1-8
< Przekaznik, 310, 0 >     wyłącz wszystkie przekaźniki 1-8

Dla uproszczenia logicznego myślenia, nie istnieje Przekaźnik nr. 0 (wiemy, że w C++ liczy się od 0), tu będzie to po prostu nie istniejący obiekt. Nie muszę chyba nic więcej tłumaczyć, NANO jest podłączone z ESP32 przez konwerter logiki 3V-5V (lepiej tak robić), bez tego działa ale różnice napięć powodują nadmierne nagrzewanie - tak nie wolno. To tylko 4zł a mamy problem z logiką rozwiązany.

A teraz z innej beczki. Spotkałem się z małym problemem przy tworzenie tego projektu do Nano, chodziło w sumie o monitor szeregowy bo Arduino nie nadążało za ESP, pierdoła - tutaj nie ma już tego problemu przez kody 309 i 310 dla parsera. Myślę, zapytam na Elektroda. Porażka i żenada - jedyne co wszystkich interesuje to cały kod, pokaż pokaż pomożemy. Po krótkiej debacie, wszyscy poirytowani, że pytający przewyższa ich wiedzą i kodu nie chce dać. Uważajcie, nie pokazujcie całości jeśli nie chcecie, to wasza własność intelektualna, HAMÓW na ciekawe rozwiązanie (jeśli jest takie) nie brakuje. 

  1. // ---------------------------------------------------------------------------------------------- //
  2. // Relay Controller v0.1 beta for NANO         by PowerTGS440                                     //
  3. // Kontroler Przekaźników v0.1 beta dla NANO   by PowerTGS440                                     //
  4. //                                                                                                //
  5. // e-mail     : powerTGS440@gmail.com                                                             //
  6. // autor      : Tomasz Majcher                                                                    //
  7. // własność   : TransLine Polska                                                                  //
  8. // licencja   : tylko do użytku własnego                                                          //
  9. // ---------------------------------------------------------------------------------------------- //
  10. //
  11. //
  12. // --- F U N C T I O N   D E C L A R A T I O N S ------------------------------------------------ //
  13.                                                                                                   //
  14. void Przekaznik_Start ( void );                                                                   //
  15. void Przekaznik_Raport( int p);                                                                   //
  16. void Przekaznik_Przelacz( int p, bool stan);                                                      //
  17. void ESP_SerialRead ( void );                                                                     //
  18. void ESP_ParseData ( void );                                                                      //
  19. void ESP_ParseSwitch ( void );                                                                    //
  20. void ESP_ShowParsedData ( void );                                                                 //                                                                                                  
  21.                                                                                                   //
  22. // --- D E F I N E    M A K R O ----------------------------------------------------------------- //
  23.                                                                                                   //
  24. #define Terminal      1                 // Serial Terminal                                        //
  25.                                                                                                   //
  26. // ---------------------------------------------------------------------------------------------- //
  27.                                                                                                   //
  28. #if Terminal                                                                                      //
  29.                                                                                                   //
  30.     #define SerialSpeed   19200            // Prędkość transmisji Serial (bezp. prędk. dla NANO   //    
  31.     #define Debug         1                // Debug ON/OFF                                        //
  32.     #define ESPDebug      1                // ESP Serial Debug                                    //
  33.                                                                                                   //    
  34. #endif                                                                                            //
  35.                                                                                                   //
  36. // ---------------------------------------------------------------------------------------------- //
  37. // --- Klasa Przekaznik ------------------------------------------------------------------------- //   <- Klasa Przekaznik
  38. // ---------------------------------------------------------------------------------------------- //
  39.                                                                                                   //
  40. class Przekaznik                                                                                  //
  41. {                                                                                                 //
  42.     protected:                                                                                    //
  43.                                                                                                   //
  44.         uint8_t pin;                                                                              //
  45.         bool state;                                                                               //
  46.         bool normallyOpen;                                                                        //
  47.                                                                                                   //
  48.     public:                                                                                       //
  49.                                                                                                   //
  50.         Przekaznik()                                                                              //
  51.         {                                                                                         //
  52.             #if Terminal                                                                          //
  53.                 Serial.print(F("KONSTRUKTOR domyślny klasy Przekaźnik."));                        //                
  54.             #endif                                                                                //
  55.         }                                                                                         //
  56.                                                                                                   //
  57.         Przekaznik(uint8_t p, bool isNormallyOpen)                                                //
  58.         {                                                                                         //
  59.             pin = p;                                                                              //
  60.             normallyOpen = isNormallyOpen;                                                        //
  61.                                                                                                   //
  62.             #if Terminal                                                                          //
  63.                 Serial.print(F("KONSTRUKTOR klasy Przekaźnik."));                                 //
  64.                 Serial.print(F("Utworzono obiekt. Aktywowano przekaźnik nr : "));                 //
  65.                 Serial.println(p);                                                                //
  66.             #endif                                                                                //
  67.         }                                                                                         //
  68.                                                                                                   //        
  69.         void begin()                                                                              //
  70.         {                                                                                         //
  71.             pinMode(pin, OUTPUT);                                                                 //
  72.             turnOff();                                                                            //
  73.         }                                                                                         //
  74.                                                                                                   //
  75.         bool getState()                                                                           //
  76.         {                                                                                         //
  77.             if (normallyOpen) return !state;                                                      //
  78.             else return state;                                                                    //
  79.         }                                                                                         //
  80.                                                                                                   //
  81.         void turnOn()                                                                             //
  82.         {                                                                                         //
  83.             if (normallyOpen)                                                                     //
  84.             {                                                                                     //
  85.                 if (state == !true) return;                                                       //
  86.                 state = !true;                                                                    //
  87.             }                                                                                     //
  88.             else                                                                                  //
  89.             {                                                                                     //
  90.                 if (state == true) return;                                                        //
  91.                 state = true;                                                                     //
  92.             }                                                                                     //
  93.                                                                                                   //
  94.             digitalWrite(pin, state);                                                             //
  95.                                                                                                   //
  96.             #if Terminal                                                                          //
  97.                 Serial.print(F("Włączono Przekaźnik nr : "));                                     //
  98.                 Serial.println(pin);                                                              //
  99.             #endif                                                                                //
  100.         }                                                                                         //
  101.                                                                                                   //
  102.         void turnOff()                                                                            //
  103.         {                                                                                         //
  104.             if (normallyOpen)                                                                     //
  105.             {                                                                                     //
  106.                 if (state == !false) return;                                                      //
  107.                 state = !false;                                                                   //
  108.             }                                                                                     //
  109.             else                                                                                  //
  110.             {                                                                                     //
  111.                 if (state == false) return;                                                       //
  112.                 state = false;                                                                    //
  113.             }                                                                                     //
  114.                                                                                                   //
  115.             digitalWrite(pin, state);                                                             //
  116.                                                                                                   //
  117.             #if Terminal                                                                          //
  118.                 Serial.print(F("Wyłączono Przekaźnik nr : "));                                    //
  119.                 Serial.println(pin);                                                              //
  120.             #endif                                                                                //
  121.         }                                                                                         //
  122. };                                                                                                //
  123. // ---------------------------------------------------------------------------------------------- //
  124. // --- R E L A Y   O B J E C T   D E C L A R A T I O N   &   D E F I N E ------------------------ //
  125. // ---------------------------------------------------------------------------------------------- //
  126.                                                                                                   //
  127. #define Przekaznik0   0                                           // to jest FAKE, nie ma go :)   //
  128. #define Przekaznik1   1                                           // pin 1 dla Przekaźnik 1       //
  129. #define Przekaznik2   2                                           // pin 2 dla Przekaźnik 2       //
  130. #define Przekaznik3   3                                           // pin 3 dla Przekaźnik 3       //
  131. #define Przekaznik4   4                                           // pin 4 dla Przekaźnik 4       //
  132. #define Przekaznik5   5                                           // pin 5 dla Przekaźnik 5       //
  133. #define Przekaznik6   6                                           // pin 6 dla Przekaźnik 6       //
  134. #define Przekaznik7   7                                           // pin 7 dla Przekaźnik 7       //
  135. #define Przekaznik8   8                                           // pin 8 dla Przekaźnik 8       //
  136.                                                                                                   //
  137. #define P_SIZE        9                                                                           //
  138.                                                                                                   //
  139. Przekaznik P [P_SIZE] = { {Przekaznik0, 1}, {Przekaznik1, 1}, {Przekaznik2, 1},                   //
  140.                           {Przekaznik3, 1}, {Przekaznik4, 1}, {Przekaznik5, 1},                   //
  141.                           {Przekaznik6, 1}, {Przekaznik7, 1}, {Przekaznik8, 1}                    //
  142.                         };                                                                        //
  143.                                                                                                   //                                                                                                  
  144. bool PrzekaznikStan [P_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };                                     //
  145.                                                                                                   //                                                                                                                                                                                                    
  146. // ---------------------------------------------------------------------------------------------- //
  147. // --- P A R S E   F R O M   E S P   C O N S T   a n d   V A R I A B L E ------------------------ //
  148. // ---------------------------------------------------------------------------------------------- //
  149.                                                                                                   //
  150. const byte numChars = 32;                                                                         //
  151. char receivedChars[numChars];                                                                     //
  152. bool newData = false;                                                                             //
  153. char tempChars[numChars];                                                                         //
  154. char messageFromEsp[numChars] = {0};                                                              //
  155. int codeFromEsp1 = 0;                                                                             //
  156. int codeFromEsp2 = 0;                                                                             //
  157.                                                                                                   //
  158. // ---------------------------------------------------------------------------------------------- //
  159. // ------ S E T U P --- S E T U P --- S E T U P --- S E T U P --- S E T U P --- S E T U P ------- //
  160. // ---------------------------------------------------------------------------------------------- //
  161.                                                                                                   //
  162. void setup( void )                                                                                //   <- SETUP
  163. {                                                                                                 //
  164.                                                                                                   //
  165.    Serial.begin(SerialSpeed);                             // ustaw prędkość SERIAL                //
  166.    Przekaznik_Start();                                    // aktywuj przekaźniki                  //
  167.                                                                                                   //
  168. }                                                                                                 //
  169.                                                                                                   //
  170. // ---------------------------------------------------------------------------------------------- //
  171. // ------ L O O P --- L O O P --- L O O P --- L O O P --- L O O P --- L O O P --- L O O P ------- //   <- LOOP
  172. // ---------------------------------------------------------------------------------------------- //
  173. // pętla główna programu dla NANO. Sprawdza czy napłynęła jakaś wiadomość z ESP (RX,TX)           //
  174.                                                                                                   //                                                                  
  175. void loop ( void )                                                                                //
  176. {                                                        // początek funkcji LOOP (pętli)         //
  177.     ESP_SerialRead();                                    // sprawdź czy nadeszedł rozkaz z ESP    //  
  178. }                                                        // koniec funkcji LOOP (pętli)           //
  179.                                                                                                   //
  180. // ---------------------------------------------------------------------------------------------- //
  181. // --- E S P   S E R I A L   R E A D ------------------------------------------------------------ //   <- ESP Serial Read
  182. // ---------------------------------------------------------------------------------------------- //
  183. // sprawdź czy nadeszła jakaś wiadomość z ESP                                                     //
  184.                                                                                                   //
  185. void ESP_SerialRead ( void )                                                                      //
  186. {                                                                                                 //
  187.     static boolean recvInProgress = false;                                                        //
  188.     static byte ndx = 0;                                                                          //
  189.     char startMarker = '<';                              // marker początku ->   "<"              //
  190.     char endMarker = '>';                                // marker końca    ->   ">"              //
  191.     char rc;                                                                                      //
  192.                                                                                                   //
  193.     while (Serial.available() > 0 && !newData)                                                    //
  194.     {                                                                                             //
  195.         rc = Serial.read();                                                                       //
  196.                                                                                                   //
  197.         if (recvInProgress == true)                                                               //
  198.         {                                                                                         //
  199.             if (rc != endMarker)                       // znak to jeszcze nie marer końca  ">"    //
  200.             {                                                                                     //
  201.                                                                                                   //
  202.                 receivedChars[ndx] = rc;                                                          //
  203.                 ndx++;                                                                            //
  204.                                                                                                   //
  205.                 if (ndx >= numChars) ndx = numChars - 1;                                          //                                                    
  206.                                                                                                   //
  207.             }                                                                                     //
  208.             else                                                                                  //          
  209.             {                                                                                     //
  210.                                                                                                   //
  211.                 receivedChars[ndx] = '\0';              // znak końca                             //
  212.                 recvInProgress = false;                                                           //
  213.                 ndx = 0;                                                                          //
  214.                 newData = true;                                                                   //
  215.                                                                                                   //
  216.             }                                                                                     //
  217.         }                                                                                         //
  218.         else                                                                                      //
  219.         if (rc == startMarker)                           // jeśli znak to startMarker ->   "<"    //        
  220.         {                                                                                         //
  221.                                                                                                   //                                              
  222.             recvInProgress = true;                                                                //
  223.                                                                                                   //
  224.         }                                                                                         //
  225.     }                                                                                             //
  226.                                                                                                   //
  227.     // --- jeśli nowe dane --------------------------------- //                                   //
  228.     if (newData)                                             //                                   //    
  229.     {                                                        //                                   //
  230.                                                              //                                   //
  231.         strcpy(tempChars, receivedChars);                    //                                   //
  232.         ESP_ParseData();                                     //                                   //
  233.         ESP_ShowParsedData();                                //                                   //
  234.         ESP_ParseSwitch();                                   //                                   //
  235.         newData = false;                                     //                                   //
  236.                                                              //                                   //
  237.     }                                                        //                                   //
  238.     // ----------------------------------------------------- //                                   //
  239. }                                                                                                 //
  240.                                                                                                   //
  241. // ---------------------------------------------------------------------------------------------- //
  242. // --- E S P   P A R S E   M E S S A G E -------------------------------------------------------- //   <- Parse data from ESP
  243. // ---------------------------------------------------------------------------------------------- //
  244.                                                                                                   //
  245. void ESP_ParseData ( void )                                                                       //
  246. {                                                                                                 //
  247.     char * strtokIndx;                                                                            //
  248.                                                                                                   //
  249.     strtokIndx = strtok(tempChars,",");                                                           //
  250.     strcpy(messageFromEsp, strtokIndx);                                                           //
  251.                                                                                                   //
  252.     strtokIndx = strtok(NULL, ",");                                                               //
  253.     codeFromEsp1 = atoi(strtokIndx);                                                              //
  254.                                                                                                   //
  255.     strtokIndx = strtok(NULL, ",");                                                               //
  256.     codeFromEsp2 = atof(strtokIndx);                                                              //    
  257. }                                                                                                 //
  258.                                                                                                   //                                                                                                  
  259. // ---------------------------------------------------------------------------------------------- //
  260. // --- E S P   D E B U G   M E S S A G E -------------------------------------------------------- //   <- Show Parsed Data
  261. // ---------------------------------------------------------------------------------------------- //
  262.                                                                                                   //
  263. void ESP_ShowParsedData ( void )                                                                  //
  264. {                                                                                                 //
  265.     #if ESPDebug                                                                                  //
  266.         Serial.print(F("Odebrano z ESP. Code: "));                                                //        
  267.         Serial.print(codeFromEsp1);                                                               //        
  268.         Serial.print(F(" Msg : "));                                                               //
  269.         Serial.print(messageFromEsp);                                                             //        
  270.         Serial.print(F(" Data : "));                                                              //
  271.         Serial.println(codeFromEsp2);                                                             //
  272.     #endif                                                                                        //
  273. }                                                                                                 //
  274.                                                                                                   //
  275. // ---------------------------------------------------------------------------------------------- //
  276. // --- E S P   P A R S E   S W I T C H ---------------------------------------------------------- //   <- Parsed Data Switch
  277. // ---------------------------------------------------------------------------------------------- //
  278.                                                                                                   //
  279. void ESP_ParseSwitch ( void )                                                                     //
  280. {                                                                                                 //
  281.     switch ( codeFromEsp1 )                                    // przełącznik kodów z SERIAL      //
  282.     {                                                                                             //
  283.         case  301 : Przekaznik_Przelacz ( codeFromEsp1 - 300, codeFromEsp2 ); break;    // P1     //
  284.         case  302 : Przekaznik_Przelacz ( codeFromEsp1 - 300, codeFromEsp2 ); break;    // P2     //
  285.         case  303 : Przekaznik_Przelacz ( codeFromEsp1 - 300, codeFromEsp2 ); break;    // P3     //
  286.         case  304 : Przekaznik_Przelacz ( codeFromEsp1 - 300, codeFromEsp2 ); break;    // P4     //
  287.         case  305 : Przekaznik_Przelacz ( codeFromEsp1 - 300, codeFromEsp2 ); break;    // P5     //
  288.         case  306 : Przekaznik_Przelacz ( codeFromEsp1 - 300, codeFromEsp2 ); break;    // P6     //
  289.         case  307 : Przekaznik_Przelacz ( codeFromEsp1 - 300, codeFromEsp2 ); break;    // P7     //
  290.         case  308 : Przekaznik_Przelacz ( codeFromEsp1 - 300, codeFromEsp2 ); break;    // P8     //        
  291.         case  309 : Przekaznik_Wlacz_Wszystkie();                             break;    // P! ON  //
  292.         case  310 : Przekaznik_Wylacz_Wszystkie();                            break;    // P! OFF //
  293.     }                                                                                             //
  294. }                                                                                                 //
  295.                                                                                                   //
  296. // ---------------------------------------------------------------------------------------------- //
  297. // --- R E L A Y   I N I T --- uruchamiane z SETUP ---------------------------------------------- //   <- Przekaznik (INIT)
  298. // ---------------------------------------------------------------------------------------------- //
  299.                                                                                                   //    
  300. void Przekaznik_Start()                                                                           //
  301. {                                                                                                 //  
  302.     for (byte i = 0; i <= P_SIZE; i++)                                                            //
  303.     {                                                                                             //
  304.         P[i].begin();                                                                             //      
  305.         PrzekaznikStan[i] = P[i].getState();                                                      //    
  306.     }                                                                                             //
  307. }                                                                                                 //
  308. // ---------------------------------------------------------------------------------------------- //
  309. // --- R E L A Y   S W I T C H ------------------------------------------------------------------ //   <- Przekaznik (SWITCH)
  310. // ---------------------------------------------------------------------------------------------- //
  311.                                                                                                   //    
  312. void Przekaznik_Przelacz( int p, bool stan)                                                       //
  313. {                                                                                                 //  
  314.     switch ( stan )                                                                               //
  315.     {                                                                                             //
  316.         case  0 : P[p].turnOff(); PrzekaznikStan[p] = P[p].getState(); break;                     //  
  317.         case  1 : P[p].turnOn();  PrzekaznikStan[p] = P[p].getState(); break;                     //  
  318.     }                                                                                             //    
  319.                                                                                                   //
  320.     #if Debug                                                                                     //
  321.         Przekaznik_Raport(p);                                                                     //
  322.     #endif                                                                                        //
  323. }                                                                                                 //
  324.                                                                                                   //
  325. // ---------------------------------------------------------------------------------------------- //
  326. // --- R E L A Y   S W I T C H ------------------------------------------------------------------ //   <- Przekaznik (SWITCH)
  327. // ---------------------------------------------------------------------------------------------- //
  328.                                                                                                   //
  329. void Przekaznik_Wlacz_Wszystkie()                                                                 //
  330. {                                                                                                 //
  331.     for(int i = 1; i < P_SIZE; i ++) Przekaznik_Przelacz( i, 1 );                                 //  
  332. }                                                                                                 //
  333.                                                                                                   //
  334. // ---------------------------------------------------------------------------------------------- //
  335. // --- R E L A Y   S W I T C H ------------------------------------------------------------------ //   <- Przekaznik (SWITCH)
  336. // ---------------------------------------------------------------------------------------------- //
  337.                                                                                                   //
  338. void Przekaznik_Wylacz_Wszystkie()                                                                //
  339. {                                                                                                 //
  340.     for(int i = 1; i < P_SIZE; i ++) Przekaznik_Przelacz( i, 0 );                                 //  
  341. }                                                                                                 //
  342.                                                                                                   //
  343. // ---------------------------------------------------------------------------------------------- //
  344. // --- R E L A Y   S W I T C H ------------------------------------------------------------------ //   <- Przekaznik (RAPORT)
  345. // ---------------------------------------------------------------------------------------------- //
  346.                                                                                                   //    
  347. void Przekaznik_Raport( int p)                                                                    //
  348. {                                                                                                 //  
  349.     #if Terminal                                                                                  //
  350.         Serial.print(F("Stan przekaźnika nr : "));                                                //
  351.         Serial.print(p);                                                                          //        
  352.         if ( PrzekaznikStan[p] ) Serial.println(F(" ON "));                                       //
  353.         else                                                                                      //
  354.         if (!PrzekaznikStan[p] ) Serial.println(F(" OFF "));                                      //
  355.     #endif                                                                                        //      
  356. }                                                                                                 //
  357.                                                                                                   //
  358. // ---------------------------------------------------------------------------------------------- //

BME280 - Sensor temperatury, wilgotności i ciśnienia

  BME280 (ESP32/ESP2866) BME280 to prosty w użyciu czujnik temperatury, wilgotności oraz ciśnienia atmosferycznego. Zasilany jest napię...