ESP na bateriach - wykorzystanie esp now

[_LM_]

Przeglądając sieć w poszukiwaniu różnych DIY od czasu do czasu można trafić na różne układziki które mają za zadanie odczytać jakiś parametr a następnie przesłać do urządzenia nadrzędnego. Przeważnie te układy są zasilane z akumulatorów zawierają dodatkowe przetwornice i inne podobne rozwiązania. Byłem ciekaw czy faktycznie esp8266 zawsze musi mieć zasilanie akumulatorowe? Czy pobiera aż tyle prądu że nie da się użyć baterii? Po krótkim przejrzeniu możliwości tych układów okazało się te układy mogą “zejść” z poborem prądu aż do 15uA no nie jest to jakiś rekord wśród współczesnych układów ale jak najbardziej jest osiągalne. Jak to zrobić?

Wpierw należy wybrać układ dzięki któremu osiągniemy cel najkrótszą drogą, płytki deweloperskie typu nodeMCU, oraz Vemos od razu odrzuciłem ze względu na wbudowane stabilizatory oraz układy konwerterów rs232. Esp01 od biedy mógłby być, jednak wymaga kombinacji polegającej na lutowaniu dodatkowego przewodu do pinu wake. Postanowiłem użyć modułu ESP-07 jednak aby wykorzystać pełnię możliwości tego układu należy usunąć diody informujące o stanie urządzenia, ten zabieg wymaga nieco wprawy w posługiwaniu się lutownicą ale gdy już się to uda kolejne µA zaoszczędzone. Następnie, ponieważ opis dotyczy współpracy z BME280 z płytki tego układu również trzeba usunąć stabilizator napięcia oraz zewrzeć dwa punkty. Przeróbki widać poniżej.

W kwestii schematu urządzenie nie jest skomplikowane, płytka jest przygotowana do pracy z popularną przejściówką FTD232 programowanie odbywa się półautomatycznie z wykorzystaniem pinu DTR, chcąc wgrać nowy soft należy po uruchomieniu skryptu nacisnąć przycisk reset. Dodatkowego komentarza wymaga złącze H4 z rezystorem R5. Rezystor przy rezystancji 1ohm w obwodzie zasilania ułatwia pomiary prądu, zwłaszcza, podczas gdy moduł jest w trybie odczytu lub wysyłania danych. Przebieg napięcia na rezystorze odwzorowuje pobór prądu przez układ do zmierzenia oscyloskopem ponieważ klasycznym multimetrem mało co da się zmierzyć, złącze H1 oraz J1 są do dowolnego wykorzystania, złącze pinu ADC wyprowadziłem ale w tym projekcie ADC mierzy wewnętrzne napięcie zasilania. Na koniec opisu elektroniki ważna uwaga: Trzeba pamiętać o konwersji napięć przejściówki oraz samym zasilaniu gdyż ani ESP ani BMP nie zawierają żadnych układów ograniczających napięcie więc można pracować z napięciami do 3.3V nie ma znaczenia czy z przejściówki czy z baterii.

Program 

Całość napisałem w Visual Studio Code z bibliotekami Arduino

Co ważne dla czujnika BME280 znacznie lepiej sprawdziła się biblioteka od sparkfun dlatego że libs od Adafruit zawiera jak dla mnie zbyt dużo niepotrzebnych delay - ów już sama inicjalizacja czujnika to niepotrzebne 100mS a ponieważ nie chciało mi się w tym grzebać, dowiedziałem się że właśnie ta od sparkfun jest lepiej napisana. Na początku kodu widać kilka stałych dosłownych:

#define SLEEP 600e6 // 10minut
#define WIFI_CHANNEL 11 // kanal
#define TIMEOUT 300
#define RTCMEMSTARTADRESS 65 // adrs RTC mme 
#define DEBUG 0

#Sleep pozwala określić co ile moduł ma być wybudzony.

#wifi_channel wiąże się to z tym że część odbiorcza - o której później, nie powinna pracować na tym samym kanale co usługa esp now stąd na stałe przypisana taka wartość, czasem warto poeksperymentować z innymi można zmieniać od 1 do 14

klik

#timeout ustala czas w jakim moduł powinien “wyrobić się” z wszystkimi zadaniami, gdyby coś poszło nie tak to funkcja sleep zostanie uruchomiona po tym czasie (w ms)

#rtcmemstartaddress określa początek obszaru danych w pamięci RTC, pamięć ta nie jest kasowana po resecie urządzenia więc świetnie nadaje się do przechowywania ustawień bieżących modułu.

#debug zmienienie tej wartości na 1 przede wszystkim uruchamia wbudowany uart i funkcje związane z obsługą Serial, przydaje się do testowania oprogramowania.

#include <Arduino.h>
#include <ESP8266WiFi.h>

#include <Adafruit_Sensor.h>
#include <SparkFunBME280.h>
#include <ftoi.h>
/*
#include <ESP8266mDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>
*/
#include <Wire.h>
#include <Ticker.h>
#include <espnow.h>

#define SLEEP 600e6 // 10minut
#define WIFI_CHANNEL 11 // kanal
#define TIMEOUT 300 
#define RTCMEMSTARTADRESS 65 // adrs RTC mme 
#define DEBUG 0

uint8_t broadcastAddress[] = {0xE0, 0x98, 0x06, 0x25, 0x40, 0x80}; // mac modulu odbiorczego

ADC_MODE(ADC_VCC);

const char nazwa[] = "CZUJNIK ZEWNETRZNY";

typedef struct
{

  uint32_t temp;  // temperatura                4
  uint32_t press; // cisnienie                  4
  int humm;       // wilgotnosc                 4
  uint16_t vbat;  // U zas czujnika             2
  uint16_t okno;  //okno 0 -> zamkniete, 1->otwarte
} bme_t;

bme_t g_czujnik;
BME280 bme;
bool readSens(bme_t *bmeSens);

bool checkData(bme_t *dta); // porownuje aktualny pomiar z danymi zapisanymi w rtc_mem

void continueProg(void);
void OnDataSent(uint8_t *mac_addr, uint8_t sendStatus);
void sleep(void);
bool porownaj(bme_t *s, bme_t *d);

Ticker tmr, tbme;
/************************************* START ******************************/
void setup()
{
    tmr.once_ms(TIMEOUT, sleep); // w razie w
  #if DEBUG == 1
    Serial.begin(115200);
    Serial.println("start");
  #endif

  Wire.begin();
  Wire.setClock(400000L);
  bme.setI2CAddress(0x76);
  bme.beginI2C();
  bme.setMode(MODE_SLEEP); //Sleep for now

  if (readSens(&g_czujnik))
  { // jesli wartosci rozne to wykonaj reszte kodu

    WiFi.setOutputPower(0); // nie zmienia czasu ale zmniejsza pobierana moc
    WiFi.mode(WIFI_STA);    // nie zmienia czasu - lepiej zostawic wlaczone

    if (esp_now_init() != 0)
    {
#if DEBUG == 1
      Serial.println("Error initializing ESP-NOW");
      return;
      ESP.deepSleep(SLEEP);
#else
      sleep();
#endif
    }
    //memcpy(&SendBUf[sizeof(nazwa)],&Czujnik_Data[1],sizeof(czujnik_t)); // kopiowanie struktury
    static uint8_t SendBuf[64];
    memcpy(SendBuf, &nazwa, sizeof(nazwa));
    memcpy(&SendBuf[sizeof(nazwa)], &g_czujnik, sizeof(g_czujnik));

    esp_now_set_self_role(ESP_NOW_ROLE_CONTROLLER); // jako master
    esp_now_register_send_cb(OnDataSent); // callback
    esp_now_add_peer(broadcastAddress, ESP_NOW_ROLE_SLAVE, WIFI_CHANNEL, NULL, 0); // do kogo wyslac?
    esp_now_send(broadcastAddress, SendBuf, sizeof(SendBuf)); // wyslij
    sleep();
  }
  else
    sleep(); // jesli dane takie same to nie trzeba wysylac
}

void loop()
{
}

// odczyt bme
bool readSens(bme_t *bmeSens)
{

  static bme_t pomiar; // static dlatego aby zmienna byla automatycznie wyzerowana
  system_rtc_mem_read(RTCMEMSTARTADRESS, &pomiar, sizeof(bme_t));

#if DEBUG == 1
  Serial.println("Start pomiar");
#endif
  int cc, cu;
  bool znak;

  bme.setMode(MODE_FORCED); //Wake up sensor and take reading
  while (bme.isMeasuring() == false); //Wait for sensor to start measurment
    
  while (bme.isMeasuring() == true) ; //Hang out while sensor completes the reading
   

  bmeSens->humm = (int)bme.readFloatHumidity();

  floatToInt(bme.readFloatPressure() / 100.0F, 1, &znak, &cc, &cu); // konwersja
  wstaw((uint32_t *)&bmeSens->press, znak, cc, cu);
  floatToInt(bme.readTempC(), 1, &znak, &cc, &cu);
  wstaw((uint32_t *)&bmeSens->temp, znak, cc, cu);
  bmeSens->vbat = ESP.getVcc();
  bmeSens->okno = 0x0;

  if (porownaj(&g_czujnik, &pomiar))
  {                                                                     // zwraca true kiedy wyniki rozne
    system_rtc_mem_write(RTCMEMSTARTADRESS, &g_czujnik, sizeof(bme_t)); // kopiowanie do mem
    return true;
  }
  else
    return false; // jesli nie bylo zmian

#if DEBUG == 1
  Serial.print("T=");
  Serial.println(bme.readTempC(), 2);
  Serial.print("P=");
  Serial.println(bme.readFloatPressure(), 0);
  Serial.print("H=");
  Serial.println(bme.readFloatHumidity(), 0);
#endif
}

// callback
void OnDataSent(uint8_t *mac_addr, uint8_t sendStatus)
{

#if DEBUG == 1
  if (sendStatus == 0)
  {
    Serial.println("Dostarczono");

    sleep();
  }
  if (sendStatus)
  {
    Serial.println("Blad wysylki danych");

    sleep();
  }

#else
  // sleep();

#endif
}

void sleep()
{

  WiFi.mode(WIFI_OFF); //
  //ESP.deepSleepInstant(SLEEP,WAKE_NO_RFCAL);
WiFi.forceSleepBegin();
ESP.deepSleep(SLEEP, WAKE_NO_RFCAL);

}

bool porownaj(bme_t *s, bme_t *d)
{
  char *ps = (char *)s;
  char *pd = (char *)d;

  for (uint16_t i = 0; i < sizeof(bme_t); i++)
  {
    if (ps[i] != pd[i])
      return true; // jesli nowy pomiar != pomiar poprzedni
  }
  return false;
}

 

Jak widać oprogramowanie to zaledwie kilka linijek kodu, funkcja nawet nie wchodzi w loop(); po resecie następuje odczyt czujnika BME, gdy się powiedzie zostaje wywołana funkcja która ustawia moduł w tryb wysyłania danych, warunkiem uruchomienia esp now jest również to że dane z poprzedniego pomiaru muszą być różne od bieżących. Przy tych samych nie ma sensu ponownie wysyłać pomiarów. Zaciekawienie może budzić funkcja  floatToInt dodałem ją ponieważ nie potrzebne mi były pomiary z dwoma i więcej miejsc po przecinku( a takie wyniki odsyła funkcja odczytu bme) więc wyniki są konwertowane do dwóch intów i jednego bool określającego znak.

Pomiary

Pomiarów dokonywałem za pomocą rezystora szeregowego włączonego w obwodzie masy, pierwszy oscylogram pokazuje trudne początki z układem, jeszcze bez ograniczenia mocy esp, z biblioteką Adafruit i ogólnie nie prezentowały się zbyt zachęcająco, dopiero po kilku próbach oraz pomocy elektroda (dzięki @khoam) udało się uzyskać wyniki jak powyżej. Jak widać poza trybem czuwania gdzie układ faktycznie pobiera te kilkanaście µA. Urządzenie od wybudzenia do zakończenia wysyłki potrzebuje zaledwie 240mS gdzie największy pobór (ok 100mA) zajmuje niecałe 60mS. Niestety trochę czasu zajmuje inicjalizacja modułu, głównie czas przez który uruchamia się bootloader właściwie to już nie walczyłem z tym.

Część odbiorcza

Odbiornik jest zbudowany na esp12e(planowo esp 01) program działa tak, że nasłuchuje transmisji od części nadawczej, gdy pojawią się nowe dane odbiornik przełącza się w tryb wifi, łączy się do z serwerem remoteMe wysyła dane po czym znów przechodzi w tryb nasłuchiwania.  

Przyszłościowo chciałbym aby wszelkie konfiguracje mogły zostać wpisane z poziomu aplikacji a nie jak teraz ręcznie z poziomu kodu. Jak na razie oddaję w wasze ręce nie tylko kody źródłowe obu modułów, napisałem również prostą aplikację pod android która będzie odczytywała wartości z czujnika zdalnego, pomijam konfigurację usługi remoteMe. Aby jednak móc przetestować urządzenie trzeba zrobić kilka kroków:

W programie nadajnika wpisać poprawny MAC adres odbiornika można to zrobić w prosty sposób wpisując króciutki program

#include <ESP8266WiFi.h>

void setup(){

Serial.begin(115200);
   delay(500);
Serial.println();
Serial.print("MAC: ");
Serial.println(WiFi.macAddress());
}

Następnie ustawić wstępne warunki kompilacji i już można wgrywać kod. W module odbiornika jest więcej zabawy: Należy dokonać ustawień związanych z remoteme, hasła do swojego wifi i ja jeszcze mam ustawione stałe IP dla swojego modułu gdyż znacznie przyśpiesza połączenie z siecią.

#define DEVICE_ID 17 // id
#define DEVICE_NAME "" // twoja nazwa
#define TOKEN "" // twój token

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESP8266mDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>
#include <Ticker.h>
#include <espnow.h>
#include <ftoi.h>

#include <RemoteMe.h>
#include <RemoteMeSocketConnector.h>


#define RTCSTARTADRESS 65

const char *ssid = ""; // wifissid
const char *password = ""; // pass

IPAddress staticIP(192, 168, 0, 10); // ponizej adresow przydzielanych dynamicznie 
IPAddress gateway(192, 168, 26, 1);
IPAddress subnet(255, 255, 255, 0);
RemoteMe &remoteMe = RemoteMe::getInstance(TOKEN, DEVICE_ID);

Ticker tmr;
uint32_t licznik;

typedef void(*ptrParseFun_t)(void);

typedef struct {

  uint32_t temp;             // temperatura      4
  uint32_t press;            // cisnienie        4
  int humm;               // wilgotnosc       4
  uint16_t vbat;          // U zas czujnika   2
  uint16_t okno; // okno 0 -> zamkniete, 1->otwrte 1
  
} readNow_t;     // struktura zajmuje 19 bajtow       



const char czZew[] = "CZUJNIK ZEWNETRZNY";
const char okno1[] = "OKNO01";

const char * const ptrStr[] = {czZew,okno1}; // tab wskaznikow 



enum incomingDTA {no_data,bme_sens, okno_pok};
//                   0        1          2

typedef struct {
readNow_t data;
uint32_t stat;
ptrParseFun_t p; // wskaznik na f parsujaca
} sysMem_t;


sysMem_t g_structData;

void RestartFunction(void);
void parseOkno();
void parseData();
void timeout(void);
void OnDataRecv(unsigned char *mac, unsigned char *incomingData,
                unsigned char len);
void onBMEzewnetrznyChange(String s);
void onStanOkienChange(String s);


inline void setBMEzewnetrzny(String s) {
  remoteMe.getVariables()->setText("BMEzewnetrzny", s);
}

inline void setStanOkien(String s) {remoteMe.getVariables()->setText("StanOkien", s); }

void setup() {
  //  sysMem_t g_structData;
  Serial.begin(115200);

      system_rtc_mem_read(RTCSTARTADRESS, &g_structData, sizeof(sysMem_t));

  Serial.println("Wifi start");
  Serial.print("MAC: "); Serial.println(WiFi.macAddress());

  WiFi.disconnect();

  if (g_structData.stat == 1) { // tryb wysylania do remoteMe
    Serial.println("Tryb remote");
    WiFi.config(staticIP, gateway, subnet);
    WiFi.begin(ssid, password);
    WiFi.mode(WIFI_STA);

    while (WiFi.waitForConnectResult() != WL_CONNECTED) {
      Serial.println("Connection Failed! Restart...");

      ESP.restart(); // jesli nie powiodlo sie laczenie z siecia. (Todo:
    }                // uruchomic kreatora WiFi?)

    remoteMe.getVariables()->observeText("BMEzewnetrzny",
                                         onBMEzewnetrznyChange);
    remoteMe.getVariables()->observeText("StanOkien", onStanOkienChange);

    remoteMe.setConnector(new RemoteMeSocketConnector);
    remoteMe.sendRegisterDeviceMessage(DEVICE_NAME);

    if (g_structData.p) g_structData.p(); // jesli wskaznik przypisany to wykonaj
    else  RestartFunction(); // jesli wskaznik nie zostal przypisany
    
    } else {
    WiFi.mode(WIFI_STA);
    Serial.println("Tryb odbioru z czujnikow");
    if (esp_now_init() != 0) {
      Serial.println("Error initializing ESP-NOW");

      return;
    }
    esp_now_set_self_role(ESP_NOW_ROLE_SLAVE);
    esp_now_register_recv_cb(OnDataRecv);
  }
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(D3, INPUT_PULLUP);
}
  
void loop() {
  /*
   ArduinoOTA.handle();
 */
if(g_structData.stat == 1){  // jesli jakies dane do wyslania
  remoteMe.loop();
}
}

void OnDataRecv(
    unsigned char *mac, unsigned char *incomingData,
    unsigned char len) { // dane z czujnikow kopiowanie do pamieci rtc i restart

  uint8_t l = 0;
  uint8_t bf[4];

  for (uint8_t i = 0; i < sizeof(ptrStr) / sizeof(char *); i++) {
    if (0 == strcmp((char *)incomingData, ptrStr[i])) {
      l = i + 1; // sprawdzam z ktorego czujnika przylecialy dane
      break;
    }
  }
  sysMem_t x;
  if (l == bme_sens) {

    memcpy(&x.data, &incomingData[strlen(ptrStr[l - 1]) + 1],
           sizeof(readNow_t));

  //  x.stat = l;
   x.stat = 1;
    x.p = parseData;
  system_rtc_mem_write(RTCSTARTADRESS, &x, sizeof(sysMem_t));
  }

  if (l == okno_pok) {

    memcpy(&bf, &incomingData[strlen(ptrStr[l - 1]) + 1], sizeof(bf));

  //  x.stat = l;
   x.stat = 1;
    x.data.okno = bf[0];
    memcpy(&x.data.vbat, &bf[2], 2);
    x.p = parseOkno;
    system_rtc_mem_write(RTCSTARTADRESS, &x, sizeof(sysMem_t));
  }
  
  Serial.print("Nowe dane - Restart ESP");
  ESP.restart();
}

 void parseData(){

  char buf[100];
  char b2[5];
  bool znak;
  int cc =0 ;
  int cu = 0;
  uint8_t * p;
  uint8_t * p2 = (uint8_t*)&cc;

 strcpy(buf,"EXT="); // naglowek -> nazwa czujnika EXT -> external, zewnetrzny
 //if(g_BMEstatus)strcat(bf,"OK");else strcat(bf,"FALSE"); // status BME
 strcat(buf,"OK");
 strcat(buf,"&T="); // temperatura

 p = (uint8_t*)&g_structData.data.temp;
 znak = p[0];
 cu = p[1];
 p2[0] = p[2];
 p2[1] = p[3];
 //Serial.print("t= "); Serial.print(znak); Serial.print(cc); Serial.print(".");Serial.println(cu);
 //p2[1] = p[3];
 if(znak)strcat(buf,"-");
 strcat(buf,itoa(cc,b2,10));
 strcat(buf,".");
 strcat(buf,itoa(cu,b2,10));
 strcat(buf,"&H=");
 strcat(buf,itoa(g_structData.data.humm,b2,10));
 strcat(buf,"&P=");

  p = (uint8_t*)&g_structData.data.press;
 znak = 0;
 cu = p[1];
 p2[0] = p[2];
 p2[1] = p[3];
 strcat(buf,itoa(cc,b2,10));
 strcat(buf,".");
 strcat(buf,itoa(cu,b2,10));
 strcat(buf,"&U=");
 strcat(buf,itoa(g_structData.data.vbat/1000,b2,10));
  uint16_t xx = (g_structData.data.vbat % 1000)/10;
 strcat(buf,".");
 if(xx<10)strcat(buf,"0"); // zero wiodace
 strcat(buf, itoa(xx,b2,10));
 strcat(buf,"&end");
g_structData.p = NULL; // po wyslaniu kasowanie wskaznika 
system_rtc_mem_write(RTCSTARTADRESS, &g_structData, sizeof(sysMem_t));
Serial.println("wysylka do Remoteme");

setBMEzewnetrzny(buf);
tmr.once(5,timeout); // jesli brak odpowiedzi z remoteme
}
 
void parseOkno(){
char buf[50];
char b2[5];
strcpy(buf,"Okno=");
if(g_structData.data.okno)strcat(buf,"Otwarte");
if(0 == g_structData.data.okno)strcat(buf,"Zamkniete");
strcat(buf,"&U=");

 strcat(buf,itoa(g_structData.data.vbat/100,b2,10));
  uint16_t xx = (g_structData.data.vbat % 100);
 strcat(buf,".");
 if(xx<10)strcat(buf,"0"); // zero wiodace
 strcat(buf, itoa(xx,b2,10));
 //strcat(buf,"&R=");
 //strcat(buf,itoa(g_structData.data.timeToRestart,b2,10));
 strcat(buf,"&end");
//g_structData.stat = 0; 
g_structData.p = NULL; // po wyslaniu kasowanie wskaznika 
system_rtc_mem_write(RTCSTARTADRESS, &g_structData, sizeof(sysMem_t));
Serial.println("wysylka do Remoteme");
setStanOkien(buf);
tmr.once(5,timeout); // jesli brak odpowiedzi z remoteme
}


void timeout(){
 Serial.println("RemoteMe Time OUT");
 RestartFunction();
}


void RestartFunction(){ // zapisuje do rtc mem i restart
 g_structData.stat = 0;
 system_rtc_mem_write(RTCSTARTADRESS, &g_structData, sizeof(sysMem_t));
 ESP.restart();
 }


 void onBMEzewnetrznyChange(String s) {
Serial.println("RemoteMe potwierdzilo odbior");
RestartFunction();
} 

void onStanOkienChange(String s){
  Serial.println("RemoteMe potwierdzilo odbior");
  RestartFunction();
}

Na koniec prosta Apka którą napisałem w javie z pomocą Basic for Android pozwala ona na szybki dostęp do czujników, aplikacja prosi o dostęp do aparatu gdyż kopiowanie linku do zmiennych remoteme następuje przez skanowanie kodu qr. 

Podobnie powstała bliźniacza aplikacja na PC (tu jednak tylko print screen) pozwala ona na więcej gdyż mogę również sterować urządzeniami w mieszkaniu. 

SCH_zewnetrzny_2021-08-12.zipESPnow.zip

PCB_PCB_zewnetrzny_2021-08-12.zipESPnowNadajnik.zip

Kod źródłowy aplikacji z widokami:

sesnsor.zip

Skompilowana aplikacja:

APK.zip

[Treker (Damian Szymański)]

@_LM_ dziękuję za opis ciekawego DIY. Temat został właśnie zatwierdzony, więc podbijam, aby inne osoby zobaczyły Twój projekt

[ethanak]

Fajne, ale się doczepię:

Co złego jest w funkcji sprintf, że zamiast niej trzeba wrzucać bandę strcatów i itoa?

Co takiego tajemniczego siedzi w funkcji wstaw, że w połączeniu z floatToInt będzie lepsza od prostego (int)round(f/cośtam)?

 

 

[_LM_]

10 minut temu, ethanak napisał:

Fajne, ale się doczepię

Konstruktywna krytyka zawsze mile widziana. 

Co do tych funkcji: ten kod był pisany jakoś na wiosnę więc nie pamiętam szczegółowo dla czego tak. Zapewne wynikało to z tego że przez lata pisałem na małe avr gdzie jak wiesz trzeba oszczędzać każdy bajt ramu i romu. Pewnie gdzieś tam wyszło mi że moje funkcje zabierają nieco mniej jednego albo drugiego, teraz już działając na esp coraz mniej zwracam uwagę na optymalizację, poza tym w moich programach przydałoby się więcej c++