[Vorstellung] ESP8266 DHT22 akkubetriebener Sensor (z.B. Außensensor)

[roman1528]

Moin.

Heute kann ich mich auch mal wieder zu Wort melden.
Gerade sind die Gehäuse angekommen. Werde mich also heute damit befassen möglichst alles auf einer passenden Platine unter zu bringen.

Das ärgerliche wird nur sein, dass die Platine dann mit Heißkleber oder ähnlich fixiert werden muss, da keine Befestigungspunkte vorhanden sind. Ich denke aber, dass wir bastler damit klar kommen  ... Heißkleber... unser aller Heilmittel XD

Sobald ich was neues habe meld eich mich wieder, bzw. aktualisiere ich die ersten Posts.

Grüße^^

[kadettilac89]

Hallo,

du gehst den Weg über ein zusätzliches Solarpanel. OK. Sehe ich das in deinem Scetch richtig dass bei einem Deep Sleep von 30 Sec. "nur" 60% gespart wird?

Kommentar in der INO-Datei ... "script excekution is about 20s", 30s deep sleep somit in Summe 50sec, 30 / 50 = 60%.

Weißt du wie lange der ESP mit einer 18650 "durchhält"? Du hast 60 Tage mit 3 AA Battrien gemessen, welche Kapazität hatten diese bzw. welches Modell dann kann ich selber nachsehen.

Problem der ganzen ESP-Batterie-Setup ist leider immer die kurze Batterie Lebenserwartung.

Thx

[sbiermann]

Hi,
meinst du mich? Der Kommentar mit den 20s ist noch vom original Skript welches ich hier von jemanden aus dem Forum übernommen habe und alles raus geworfen habe was ich nicht brauche. War auch mein erster Sketch mit dem ESP, die jetzigen sehen alle komplett anders aus. Insbesondere das WLAN Handling.
Meine Durchlaufzeit beträgt etwa 7-9 Sekunden, dann geht der ESP im Deep Sleep für 5 Minuten. Die AA Batterien waren einfache aus dem nächst besten Laden mit 2300mAh. Die 18650 hat jetzt 3000mAh.

Bin heute dazu gekommen alles rein zu löten und zu verpacken in die Box. Anbei 2 Fotos wie es jetzt aussieht. Das Foto im Innenleben ist etwas "wild", war meine erste Bastelei, jetzt sehen die Lochrasterplatinen aufgeräumter auf. Auf dem Foto von außen ist noch ein Maßband dabei damit man eine ungefähre Ahnung bekommt wie "klein" das Teil nur ist.

Viele Grüße
Stefan

[sua]

Hallo roman1528,

eher durch Zufall bin ich gerade hier noch "d'rüber gestolpert":
Battery Powered ESP8266 IoT – Temperature Sensor.

Ggf. bringt das ja noch etwas zu der Stabilität und den Langzeitwerten?

LG,
sua

[MadMax-FHEM]

Interessant, dass auch andere auf solche Ideen kommen

Habe es ähnlich gemacht, allerdings mit ATtiny85 (hatte ich noch rumliegen)...

Bei Datenlieferung alle 3min kam ich auf ca. einen Monat.
Bei Datenlieferung alle 20min mit 3 Monaten kann allerdings auch nicht von wirklichem Batteriebetrieb gesprochen werden...

Bin gespannt, wer mit welcher Lösung (und dabei nicht nur noch längere Pausen zwischen den Datenlieferungen) auf wirklich brauchbare Werte kommt...
...ich bleib mal dran.

Gruß, Joachim

[Octopus180]

Hallo Roman

Ich wollte mal nachfragen wie weit du mit deinem Außensensor bist?

Gruß Peter

[pechnase]

Hallo Roman,

ich habe mir einen IoT Button, ähnlich wie in c't 1/2017 vorgestellt, mit einem ESP8266 nachgebaut. Als Basis habe ich Deinen Sketch genommen. Wenn ich ohne ssl arbeite, funktioniert das auch alles.
Wenn ich aber ssl auf true setze, bekomme ich zwar eine WiFi Verbindung aber keine Verbindung zu meinem FHEM-Server auf einem Raspberry PI.
Frage: hast Du Deinen Skript schon mal mit ssl ausprobiert?

Viele Grüße und vielen Dank
Wolfgang

hier der Sketch

Code Auswählen Erweitern

/******************************************************************************/
// Ursprünglicher Sketch aus ct 1/2017 'Verlasst die Ama-Zone!'
// IoT-WLAN-Button auf Basis ESP8266 und Schranklampe umgebaut
//
// 05.02.2017 wkl: Anpassungen an eigenes Netz
//
//
/*****************************************************************************/

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <WiFiClientSecure.h>
#include <base64.h>

/************************* WiFi Access Point *********************************/

const char*     wifi_ssid     = "meinessid";         //WLAN-SSID
const char*     wifi_psk      = "meinpsk";           //WLAN-Passwort

//FHEM-Server
const char*     fhem_ip       = "192.168.xxx.xxx";   //FHEM-IP-Adresse
const int       fhem_port     = 8083;                //Port FHEMWEB https, BasicAuth
String          fhem_device   = "IoT_Button";        //FHEM-Device in welche die Daten geschrieben werden sollen.
String          fhem_user     = "";                 //FHEM-Benutzername nur eintragen wenn Auth verwendet wird!
String          fhem_passwd   = "";                 //FHEM-Passwort nur eintragen wenn Auth verwendet wird!

boolean         ssl           = true;              //SSL-Verschlüsselung: true = ja; false = nein

// Use Web browser to view and copy the SHA1 Fingerprint
const char*     fhem_fingerprint = "mit Browser ausgelesen"; // Fingreprint FHEM Server

/************************* Declarations **************************************/
void blinkError();
void blinkSuccess();
void blinkSent();

//Variable
String basic;
String state;
String token = fhem_user + ":" + fhem_passwd;

/************************* LED-PIN *******************************************/

#define LED             2                 // GPIO2

/************************ Debug Mode *****************************************/
#define DEBUG

#ifdef DEBUG
#define DEBUG_PRINT(x)     Serial.print (x)
#define DEBUG_PRINTLN(x)   Serial.println (x)
#else
#define DEBUG_PRINT(x)
#define DEBUG_PRINTLN(x)
#endif

/*************************** Sketch Code ************************************/

void setup() {
  Serial.begin(115200);
//  Serial.setDebugOutput(true);
  DEBUG_PRINTLN();
  DEBUG_PRINTLN("Initializing outputs...");
  pinMode(LED, OUTPUT);
  digitalWrite(LED, LOW);    // LED on
  DEBUG_PRINTLN("Starting Wifi connection...");
 
  WiFi.persistent(false); // verhindert, dass bei jedem Start die WiFi Parameter ins Flash geschrieben werden
//  WiFi.mode(WIFI_OFF);   // this is a temporary line, to be removed after SDK update to 1.5.4
  WiFi.mode(WIFI_STA);    // Stellt sicher, dass kein AP erzeugt wird
  WiFi.begin(wifi_ssid, wifi_psk);
 
  int failcounter = 300;
  DEBUG_PRINT("Waiting for a connection");
  while (WiFi.status() != WL_CONNECTED) {
    delay(100);
    DEBUG_PRINT(".");
    if (failcounter <= 0) {
      DEBUG_PRINTLN();
      DEBUG_PRINTLN("Giving up.");
      blinkError();
      ESP.deepSleep(0);
    }
    failcounter--;
  }
  DEBUG_PRINTLN();
  digitalWrite(LED, HIGH);
  DEBUG_PRINTLN("Wifi connected.");
 
  //base64 fhemuser and fhempasswd
  if (fhem_user != "") {
    basic = base64::encode(token);
    DEBUG_PRINT("TokenBase64: ");
    DEBUG_PRINTLN(basic);
  }
 
  // mit ssl Verschlüsselung
  if (ssl == true) {
    DEBUG_PRINTLN("Do with ssl connection");
    //start client
    WiFiClientSecure client;

    //wait for server-connection
    failcounter = 100;
    DEBUG_PRINT("Waiting for a ssl server connection to ");
    DEBUG_PRINT(fhem_ip);
    DEBUG_PRINT(" at Port ");
    DEBUG_PRINT(fhem_port);
    while (!client.connect(fhem_ip, fhem_port)) {  //<- hier kommt kein connect zustande
      delay(100);
      DEBUG_PRINT(".");
      if (failcounter <= 0) {
        DEBUG_PRINTLN();
        DEBUG_PRINTLN("Giving up.");
        blinkError();
        ESP.deepSleep(0);
      }
      failcounter--; 
    }
   
    DEBUG_PRINT("Connection to ");
    DEBUG_PRINT(fhem_ip);
    DEBUG_PRINTLN(" established.");


    //create a URI for the request
    String url = "/fhem?cmd." + fhem_device + "=set%20" + fhem_device + "%20on";
    url += "&XHR=1";
    DEBUG_PRINTLN(url);

    // SHA1 Fingerprint überprüfen
    if (client.verify(fhem_fingerprint, fhem_ip)) {
      DEBUG_PRINTLN("certificate matches");
    }
    else {
      DEBUG_PRINTLN("certificate doesn't match");
    }

    if (basic != "") {
      //send request
      client.print(String("GET ") + url + " HTTP / 1.1\r\n" +
                   "Authorization: Basic " + basic + "\r\n" +
                   "Connection: close\r\n" +
                   "Accept: */*\r\n\r\n");
    }
    else {
      //send request
      client.print(String("GET ") + url + " HTTP/1.1\r\n" +
                 "Connection: close\r\n" +
                 "Accept: */*\r\n\r\n");
    }
  }
 
  // ohne ssl Verschlüsselung
  else {
    //start client
    WiFiClient client;

    //wait for server-connection
    failcounter = 10;
    DEBUG_PRINT("Waiting for a server connection");
    while (!client.connect(fhem_ip, fhem_port)) {
      delay(100);
      DEBUG_PRINT(".");
      if (failcounter <= 0) {
        DEBUG_PRINTLN();
        DEBUG_PRINTLN("Giving up.");
        blinkError();
        ESP.deepSleep(0);
      }
      failcounter--; 
    }
    DEBUG_PRINT("Connection to ");
    DEBUG_PRINT(fhem_ip);
    DEBUG_PRINTLN(" established.");

    //create a URI for the request
    String url = "/fhem?cmd." + fhem_device + "=set%20" + fhem_device + "%20on";
    url += "&XHR=1";
    DEBUG_PRINTLN(url);

    if (basic != "") {
      //send request
      client.print(String("GET ") + url + " HTTP / 1.1\r\n" +
                   "Authorization: Basic " + basic + "\r\n" +
                   "Connection: close\r\n" +
                   "Accept: */*\r\n\r\n");
    }
    else {
      //send request
      client.print(String("GET ") + url + " HTTP/1.1\r\n" +
                     "Connection: close\r\n" +
                     "Accept: */*\r\n\r\n");
    }
  }

  blinkSent();
  delay(500);

  // Stop ESP go to sleep
  ESP.deepSleep(0);

/* 
  // get response
  int success = 0;
  failcounter = 10000;
  while (client.connected()) {
    if (client.available()) {
      String line = client.readStringUntil('\n');
      DEBUG_PRINTLN("Server response: " + line);
      if (line[0] == 'O' && line[1] == 'K') {
        digitalWrite(LED, LOW);
        success = 1;
      }
    }
    if (failcounter <= 0) {
      blinkError();
      ESP.deepSleep(0);
    }
    failcounter--;
  }
  if (success) {
    blinkSuccess();
    // close connection
    DEBUG_PRINTLN("Successfully closing the connection.");
  }
  else {
    DEBUG_PRINTLN("Got no success message.");
    blinkError();
    DEBUG_PRINT("Unable to connect to ");
    DEBUG_PRINT(fhem_ip);
    DEBUG_PRINTLN(". Sorry.");
  }

  DEBUG_PRINTLN("Shutting down.");
  DEBUG_PRINTLN("Going to sleep.");
  ESP.deepSleep(0);
  DEBUG_PRINTLN("Sleep failed.");
  while(1) {
    blinkError();
  }
*/
}

/**************************** empty loop ************************************/
void loop() {
  // this should never be reached.
}

/**************************** some subroutines ******************************/
void blinkSuccess() {
  for (int i = 4; i < 50; i=(5*i) >> 2) {
    digitalWrite(LED, HIGH);   // turn the LED off
    delay(10*i);               // wait
    digitalWrite(LED, LOW);    // turn the LED on
    delay(10*i);               // wait
  }
}

void blinkError() {
  for (int i = 0; i < 28; i++) {
    digitalWrite(LED, HIGH);   // turn the LED off
    delay(125);                // wait
    digitalWrite(LED, LOW);    // turn the LED on
    delay(125);                // wait
  }
}

void blinkSent() {
  for (int i = 0; i < 2; i++) {
    digitalWrite(LED, LOW);    // turn the LED on
    delay(200);                // wait
    digitalWrite(LED, HIGH);   // turn the LED off
    delay(200);                // wait
  }
}


Änderung: ich habe den Fehler gefunden. Man muss FHEM über attr global sslVersion SSLv23:!SSLv3:!SSLv2 auch TLS1.1 ermöglichen. Mein Problem ist damit gelöst.