Posts by Neueinsteiger

/*  20.03.2023 Auslesen des Shelly EM3
*
*  Benötigte Hardware:
*  ESP8266 Wemos D1
*  Display TFT 1.8 SPI 160 x 128
*  LDR aus der Grabbelkiste
*  Widerstand (um den passenden Wert zu ermitteln am besten erst mal ein 100k Poti)
*  Gehäuse eines defekten AVM Fritz!Powerline 510E
*  Lochrasterplatine 2,54mm Rastermaß (Rest)
*  HLK PM-03 (3V3 Netzteil)
*  Sicherungshalter
*  Printklemme 2polig
*  Kleinkram wie Kabel, Kabelschuhe, Kapton-Tape, Aderendhülsen, etc.
*
*  Updates werden OTA übertragen, damit das Gerät nicht bei jedem Update an den PC angeschlossen werden muss.
*
*  Im Sketch darf kein "delay" verwendet werden, weil OTA sonst nicht funktioniert.
*  Den Teil des Sketches, mit dem der Shelly ausgelesen wird, habe ich von hier geschnorrt:
*  https://www.mikrocontroller.net/topic/533575
*
*  Die GPIO des ESP8266 dürfen mit maximal 12mA belastet werden. Das Backlight des Displays zieht 9-10mA.
*  Daher habe ich es direkt ohne Transistor an GPIO12 angeschlossen. Der LDR war irgendein LDR aus der Kramkiste.
*  Den optimalen Wert des Widerstandes habe ich mit einem 100k Poti ermittelt (bei Dunkelheit so lange gedreht,
*  bis 1024 angezeigt wurde) und dann für den Widerstand übernommen.
*  Die "Feinabstimmung" am konkreten Einsatzort kann man noch mit den Werten
*  des Mappings justieren. Superexakt muss das auch alles nicht sein, nur sollte das Display in der Nacht nicht den ganzen
*  Raum ausleuchten, bei Sonnenschein aber trotzdem gut lesbar sein.
*
*  Anschluss Display - GPIO
*
*  GND - GND
*  Vcc - 3V3
*  SCL - 14 (D5)
*  SDA - 13 (D7)
*  RES - 02 (D4)
*  DC  - 04 (D2)
*  CS  - 00 (D3)
*  BL  - 12 (D6)
*
*
*  Anschluss LDR
*
*  GND - LDR - Widerstand/Poti(um herauszufinden, welcher Wert am besten passt) - 3V3
*            !
*            !
*           A0
*
*  Meine Version des Wemos besitzt intern bereits einen Spannungsteiler am Eingang von A0, so dass dieser,
*  obwohl er eigentlich nur den Bereich 0V - 1V erfasst, auch 3V3 verträgt.
*
*
*
*/






#include <Arduino.h>
#include <ArduinoJson.h>
#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClient.h>
// #include <TM1637Display.h>     // das zweite Display benötige ich aktuell nicht
#include <Adafruit_GFX.h>
#include <Adafruit_ST7735.h>


#include <ESP8266mDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>


// #define CLK 16          // 7 Segment Display
// #define DIO 5           // 7 Segment Display


#define TFT_RST   2     // TFT RST an D4
#define TFT_CS    0     // TFT CS  an D3
#define TFT_DC    4     // TFT DC  an D2
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);


// TM1637Display display(CLK, DIO);     // zweites Display wird aktuell nicht benötigt
const char *ssid = "daheim";
const char *password = "Dein Wlan Passwort";
String Shelly_IP = "IP des Shelly";
const int led = LED_BUILTIN;  // muss abgeschaltet sein, damit es keine Probleme mit einer Resetschleife gibt


int LDR = A0;           // LDR ist als Spannunsteiler an A0 angeschlossen (s. Eingangstext)
int sensorWert = 500;   // Der Wert wird zum Start fiktiv auf 500 gesetzt
int Backlight = 12;     // GIPO 12 steuert direkt ohne Transistor das Backlight des Displays
int Prozent = 50;       // fiktive Zahl zu Beginn
int ShowIP = 1;         // fiktive (aber sinnvolle) Anfangszahl für ShowIP


bool debugging = false;  // true: Werte werden oben im TFT angezeigt // false: Werte werden nicht mehr angezeigt
bool SerialPrint = false;// true: Serial.Print der Werte ist an // false: Serial.Print der Werte ist aus


ESP8266WiFiMulti WiFiMulti;


long myTimer = 0;
long myTimeout = 2000;              // Zeit in ms bis Werte neu auf dem Display angezeigt werden


void setup()
{
pinMode (Backlight,OUTPUT);


digitalWrite(led, LOW);
Serial.begin(115200);


WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
WiFiMulti.addAP(ssid, password);  // ist zusätzlich nötig für OTA


tft.initR(INITR_BLACKTAB);         // initialisieren des ST7735S TFT


uint16_t time = millis();
//  tft.fillScreen(ST7735_BLACK);


tft.setRotation(0);                 // TFT entsprechend der Einbaulage drehen (0 - 3)
tft.fillScreen(ST7735_BLACK);


while (WiFi.waitForConnectResult() != WL_CONNECTED) {
Serial.println("Connection Failed! Rebooting...");
delay(5000);
ESP.restart();
}
// Diesen Teil des Sketches habe ich aus dem OTA Beispiel einfach nur hier rein kopiert und mit meinen Daten versehen


ArduinoOTA.setHostname("Shelly_ESP_Final");   // unter diesem Namen ist der ESP in der Arduino IDE als Port zu finden
ArduinoOTA.setPassword("admin");              // Passwort, dass beim OTA Update benötigt wird


ArduinoOTA.onStart([]() {
String type;
if (ArduinoOTA.getCommand() == U_FLASH)
type = "sketch";
else // U_SPIFFS
type = "filesystem";


// NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
Serial.println("Start updating " + type);
});
ArduinoOTA.onEnd([]() {
Serial.println("\nEnd");
});
ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
});
ArduinoOTA.onError([](ota_error_t error) {
Serial.printf("Error[%u]: ", error);
if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
else if (error == OTA_END_ERROR) Serial.println("End Failed");
});
ArduinoOTA.begin();
Serial.println("Ready");
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
}


int pwr1,pwr2,pwr3,pwrsum;


int http_get(String getstr)
{
StaticJsonDocument<200> doc;
WiFiClient client;
HTTPClient http;
int pwr;


if (http.begin(client, getstr))
{
int httpCode = http.GET();
if (httpCode > 0)
{
if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY)
{
String payload = http.getString();
//  Serial.println(payload);
DeserializationError error = deserializeJson(doc, payload);
if (error)
{
//    Serial.print(F("deserializeJson() failed: "));
//    Serial.println(error.f_str());
}
pwr = doc["power"];
}
} else {
//  Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());
}
http.end();
} else {
//  Serial.printf("[HTTP} Unable to connect\n");
}
return pwr;
}




void loop()
{


ArduinoOTA.handle();


if (millis() > myTimeout + myTimer ) {
myTimer = millis();


// wait for WiFi connection
if ((WiFiMulti.run() == WL_CONNECTED))
{
//    digitalWrite(led, LOW);         // Nur für Debugging notwendig - kollidiert aber mit dem TFT, wodurch eine Resetschleife ausgelöst wird
pwr1 = http_get("http://" + Shelly_IP + "/emeter/0");
pwr2 = http_get("http://" + Shelly_IP + "/emeter/1");
pwr3 = http_get("http://" + Shelly_IP + "/emeter/2");
//  digitalWrite(led, HIGH);          // Nur für Debugging notwendig


pwrsum = pwr1 + pwr2 + pwr3;




if (SerialPrint == true) {
Serial.print("Summe: ");
Serial.print(pwrsum);
Serial.print(",");
Serial.print("Phase 1: ");
Serial.print(pwr1);
Serial.print(",");
Serial.print("Phase 2: ");
Serial.print(pwr2);
Serial.print(",");
Serial.print("Phase 3: ");
Serial.print(pwr3);
// Serial.print("\t");
Serial.println(",");
}
}


/*
display.clear();                // Anzeige auf dem 7-Segment Display TM1637
display.setBrightness(3);       // Nicht zu grell, damit es lesbar bleibt
display.showNumberDec(pwrsum);  // Es wird nur ein Wert angezeigt
*/


tft.setTextWrap(true);        // Text darf am Ende der Zeile abgeschnitten werden
tft.fillScreen(ST7735_BLACK);


sensorWert = analogRead(LDR);                        // Variable sensorWert mit dem aktuellen Wert des LDR füllen
analogWrite(Backlight,map(sensorWert,1024,0,1,220)); // Backlight gemäß aktuellem LDR Wert steuern, Werte wurden individuelleb Gegebenheiten angepasst


if (debugging == true) {


Prozent = map((sensorWert),1024,0,0,100);
// Debugging der Helligheit
tft.setCursor(5, 5);
tft.setTextColor(ST7735_ORANGE);
tft.setTextSize(2);
tft.print("LDR: ");
tft.println(sensorWert);


// Debugging der PWM Ausgabe
tft.setCursor(5, 21);
tft.setTextColor(ST7735_ORANGE);
tft.setTextSize(2);
tft.print("Out: ");
tft.print(Prozent);
tft.println("%");
}




if (pwrsum >= 0) {
tft.setCursor(20, 40);
tft.setTextColor(ST7735_WHITE);
tft.setTextSize(4);
tft.println(pwrsum);
}


if (pwrsum < 0) {
tft.setCursor(0, 40);
tft.setTextColor(ST7735_YELLOW);
tft.setTextSize(4);
tft.println(pwrsum);
}


tft.setTextColor(ST7735_GREEN);
tft.setTextSize(1);
tft.println("");


if (pwr1 >= 0) {
tft.setTextColor(ST7735_GREEN);
tft.setTextSize(2);
tft.print("  A: ");
tft.println(pwr1);
}
if (pwr1 < 0) {
tft.setTextColor(ST7735_YELLOW);
tft.setTextSize(2);
tft.print("  A: ");
tft.println(pwr1);
}


if (pwr2 > 0) {
tft.setTextColor(ST7735_GREEN);
tft.setTextSize(2);
tft.print("  B: ");
tft.println(pwr2);
}
if (pwr2 < 0) {
tft.setTextColor(ST7735_YELLOW);
tft.setTextSize(2);
tft.print("  B: ");
tft.println(pwr2);
}
if (pwr2 == 0) {
tft.setTextColor(ST7735_WHITE);
tft.setTextSize(2);
tft.print("  B: ");
tft.println(pwr2);
}


if (pwr3 > 0) {
tft.setTextColor(ST7735_GREEN);
tft.setTextSize(2);
tft.print("  C: ");
tft.println(pwr3);
}
if (pwr3 < 0) {
tft.setTextColor(ST7735_YELLOW);
tft.setTextSize(2);
tft.print("  C: ");
tft.println(pwr3);
}
if (pwr3 == 0) {
tft.setTextColor(ST7735_WHITE);
tft.setTextSize(2);
tft.print("  C: ");
tft.println(pwr3);
}


tft.setTextColor(ST7735_GREEN);     // Leerzeile
tft.setTextSize(1);
tft.println("");




if (ShowIP < 6) {                     // Beim Start des Displays wird einmalig in der letzten Zeile die IP angezeigt
tft.setTextColor(ST7735_YELLOW);
tft.setTextSize(1);
tft.print(" IP: ");
tft.print(WiFi.localIP());
ShowIP = (ShowIP + 1);


if (debugging == false) {


// Autor
tft.setCursor(5, 5);
tft.setTextColor(ST7735_YELLOW);
tft.setTextSize(2);
tft.println("   FSA");


// Datum
tft.setCursor(5, 21);
tft.setTextColor(ST7735_YELLOW);
tft.setTextSize(2);
tft.println("24.03.2023 ");
}
}


}
}

Serial.print("Summe: ");
Serial.print(pwrsum); // pwr1,pwr2,pwr3,pwrsum;
Serial.print(",");
Serial.print("Phase 1: ");
Serial.print(pwr1);
Serial.print(",");
Serial.print("Phase 2: ");
Serial.print(pwr2);
Serial.print(",");
Serial.print("Phase 3: ");
Serial.print(pwr3);
// Serial.print("\t");
Serial.println(",");

/*
02.11.2015
Kompiliert mit Arduino IDE 1.6.4
ASCII Zeichnung von www.asciiflow.com


ATtiny85


+-------------+
Reset        +-+(D5)         +-+  5V
|(A0)         |
|             |
+-+ D3       D2 +-+   Eingang
| A3       A1 |     Spannungsteiler
|             |
+-+ D4       D1 +-+  Ausgang
| A2          |    Mosfet
|             |
GND          +-+          D0 +-+  Eingang
+-------------+    Zustand Taster




Vorhaben:
Ergänzung der LED Akku-Weihnachtsbeleuchtung (3xEneloop) um einen Timer und eine Spannungsüberwachung der Akkus, damit diese nicht tiefentladen werden.
Optional wäre es möglich, den Timer durch ein externes Quarz genauer laufen zu lassen. Hierzu sind D3 und D4 unbeschaltet geblieben.


Warnung:
Es dürfen mit dieser Schaltung nur 3 x 1,2V Akkus (Eneloop werden empfohlen) verwendet werden. Sollten Zellen mit höherer Spannung verwendet werden, kann der
verbaute Mikrocontroller Schaden nehmen, da der am analogen Eingang verbaute Spannungsteiler auf drei NiMh Zellen berechnet wurde.


Ablauf:
Der ATtiny wird durch einen Interrupt (Wechsel sowohl von HIGH nach LOW als auch umgekehrt möglich) geweckt, der Timer beginnt zu laufen
Pin6 geht auf HIGH und startet die Versorgungsspannung der LED über einen Mosfet
Pin7 misst die Akkuspannung
Ist der Timer abgelaufen, wird Pin6 LOW und der ATtiny geht in den Tiefschlaf
Tiefschlaf - warten auf Interrupt


Sollte die Spannung unter den vorgegebenen Wert (3V) sinken, dann fangen die LED an, im Sekundentakt zu blinken, wobei der Timer weiter läuft.
Fällt die Spannung unter 2V7, dann wird die Versorgungsspannung der LEDs abgeschaltet und der ATtiny geht in den Tiefschlaf.
Um eine möglichst gleichmäßige Helligkeit während der gesamten Dauer zu ermöglichen, wird die Helligkeit durch PWM der Akkuspannung angepast. Ermittelt wurde
in 24 Schritten ein Stromverbrauch von etwa 50mA, der über die gesamte Laufzeit in etwa gleich bleiben soll. Der Vorwiderstand zur LED Kette wurde hierzu entfernt.
Da die Spannung der Eneloops anfangs relativ schnell einbricht, sollte dies bei weißen LED mit relativ hohem Vf kein Problem sein. Zumindest gab es bei mir bisher keine Probleme.


Die drei Eneloops haben voll geladen in serie geschaltet eine Leerlaufspannung von etwa 4,28V


*/


#include <avr/power.h>
#include <avr/sleep.h>
#include "avr/wdt.h"






//*****************************************************
// Hier die konkreten Werte eingeben:


float Laufzeit = 4;                          // Angabe der Laufzeit des Timers in Stunden
float Vref = 1.065;                          // die Spannung, bei der am analogen Eingang 1023 angezeigt wird
float Schwellwert = 3.0;                     // die Spannung, ab der die LED anfangen zu blinken
float Abschaltspannung = 2.7;                // die Spannung, ab der die Lichterkette komplett abgeschaltet wird
float Spannungsteiler1 = 10000;              // Wert des Widerstandes des Spannungsteilers, der auf Masse gelegt ist
float Spannungsteiler2 = 33000;              // Wert des Widerstandes des Spannungsteilers, der auf Vcc gelegt ist
// ****************************************************


const int Taster = 0;
const int Mosfet = 1;
const int Spannungsmesser = A1;
int Helligkeit = 10;
float spannung = 0;
int analogwert = 0;
int SpannungState = Helligkeit;
int MosfetState = Helligkeit;
int Taster1 = 0;
unsigned long previousMillisMosfet = 0;    // normale Funktion
unsigned long previousMillisSpannung = 0;  // Spannung Grenzwert unteschritten


float Verhaeltnis = (1-(Spannungsteiler2 / (Spannungsteiler1+Spannungsteiler2)));
long intervalMosfet = Laufzeit*60*60*1000;  // Umrechnung der vorgegebenen Stunden in Millisekunden
//  long intervalMosfet = 6000;            // Interval während der Entwicklung
long intervalSpannung = 500;


// ****************************************************


void setup() {


wdt_disable();
pinMode(Mosfet, OUTPUT);
pinMode(Spannungsmesser, INPUT);
pinMode(Taster, INPUT);
analogReference(INTERNAL);


wdt_enable(WDTO_4S);
gotoSleep(); // Timer soll nicht anlaufen, nur weil die Batterien getauscht werden
}


// ****************************************************


void gotoSleep() {
unsigned long currentMillisMosfet = millis();
wdt_disable();
MosfetState = Helligkeit;
SpannungState = Helligkeit;
analogWrite(Mosfet, 0);


ADCSRA &= ~(1<<ADEN);        // ad-wandler daektivieren
GIMSK |= 1<<PCIE;
PCMSK |= 1<<PCINT0;


set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_enable();
sleep_mode();
sleep_disable();


GIMSK &= ~(1<<PCIE);
PCMSK &= ~(1<<PCINT0);
ADCSRA |= (1<<ADEN);         // ad-wandler wieder aktivieren
wdt_enable(WDTO_4S);
delay(500);
previousMillisMosfet = currentMillisMosfet;
}


// ****************************************************


void loop()
{
analogwert = analogRead(Spannungsmesser);
spannung = ((analogwert*(Vref/1024))/Verhaeltnis);
Taster1 = digitalRead(Taster);
unsigned long currentMillisMosfet = millis();
unsigned long currentMillisSpannung = millis();
unsigned long currentMillisAbschalten = millis();


if ((spannung > Schwellwert))
{
analogWrite(Mosfet, Helligkeit);
if(currentMillisMosfet - previousMillisMosfet >= intervalMosfet) {
previousMillisMosfet = currentMillisMosfet;


if (MosfetState == 0)
{
MosfetState = Helligkeit;
}
else
MosfetState = 0;
analogWrite(Mosfet, MosfetState);
}
}




if (spannung <= Schwellwert)
{
if(currentMillisSpannung - previousMillisSpannung >= intervalSpannung) {
previousMillisSpannung = currentMillisSpannung;


if (SpannungState == 0)
{
SpannungState = Helligkeit;
}
else
SpannungState = 0;
analogWrite(Mosfet, SpannungState);
}
if(currentMillisMosfet - previousMillisMosfet >= intervalMosfet) {
previousMillisMosfet = currentMillisMosfet;
analogWrite(Mosfet, 0);
gotoSleep();
}
}


if ((Taster1 == LOW))
{
delay(800);
gotoSleep();
}




if ((MosfetState == 0) && (spannung > Schwellwert))
{
gotoSleep();
}






if (spannung >= 4.4)
{
Helligkeit = 10;
}


if ((spannung >= 4.25) && (spannung < 4.4))
{
Helligkeit = 45;
}


if ((spannung >= 4.1) && (spannung < 4.25))
{
Helligkeit = 50;
}


if ((spannung >= 3.99) && (spannung < 4.1))
{
Helligkeit = 55;
}


if ((spannung >= 3.9) && (spannung < 3.99))
{
Helligkeit = 60;
}


if ((spannung >= 3.81) && (spannung < 3.9))
{
Helligkeit = 65;
}


if ((spannung >= 3.73) && (spannung < 3.81))
{
Helligkeit = 70;
}


if ((spannung >= 3.67) && (spannung < 3.73))
{
Helligkeit = 75;
}


if ((spannung >= 3.61) && (spannung < 3.67))
{
Helligkeit = 80;
}


if ((spannung >= 3.56) && (spannung < 3.61))
{
Helligkeit = 85;
}


if ((spannung >= 3.51) && (spannung < 3.56))
{
Helligkeit = 90;
}


if ((spannung >= 3.48) && (spannung < 3.51))
{
Helligkeit = 95;
}


if ((spannung >= 3.44) && (spannung < 3.48))
{
Helligkeit = 100;
}


if ((spannung >= 3.38) && (spannung < 3.44))
{
Helligkeit = 110;
}


if ((spannung >= 3.3) && (spannung < 3.38))
{
Helligkeit = 120;
}


if ((spannung >= 3.27) && (spannung < 3.3))
{
Helligkeit = 128;
}


if ((spannung >= 3.19) && (spannung < 3.27))
{
Helligkeit = 150;
}


if ((spannung >= 3.13) && (spannung < 3.19))
{
Helligkeit = 170;
}


if ((spannung >= 3.08) && (spannung < 3.13))
{
Helligkeit = 185;
}


if ((spannung >= 3.04) && (spannung < 3.08))
{
Helligkeit = 205;
}


if ((spannung >= 3.0) && (spannung < 3.04))
{
Helligkeit = 225;
}


if ((spannung >= 2.99) && (spannung < 3.0))
{
Helligkeit = 235;
}


if ((spannung >= 2.98) && (spannung < 2.99))
{
Helligkeit = 245;
}


if ((spannung >= 2.97) && (spannung < 2.98))
{
Helligkeit = 250;
}


if (spannung <= Abschaltspannung)
{
gotoSleep();
}




wdt_reset();
}


// ****************************************************


//void interrup() {}


ISR(PCINT0_vect) {


}


// ****************************************************