Posts by Neueinsteiger

RasPiPo war eins meiner ersten Projekte. Die erste Version bestand aus einer Funktürklingel, deren Empfänger an einen GPIO eines RasPi angeschlossen war. Daher der ursprüngliche Name.

Die zweite Version bestand aus einem ESP8266, der das Ereignis per Wlan schickt. Leider gab es in der Zwischenzeit sehr viele Änderungen an der FritzBox Firmware, so dass Uhrzeit und Datum nicht mehr übertragen werden. Auch ein Foto erhalte ich leider nicht mehr. Meine Programmierkenntnisse reichen nicht aus, um das zu fixen.

Aber Akkuspannung und Temperatur werden noch immer ganz brav per E-Mail gemeldet. Am E-Mail Eingang kann ich in etwa auch die Uhrzeit fest machen.

Vielleicht findest Du in dem Projekt Anregungen, um Dein Problem zu lösen.

Das Teil läuft übrigens immer noch. Ein Satz Akkus hält ewig. Vom Gefühl her würde ich sagen, dass ich die Akkus so alle 10 Monate einmal auflade.

Wer wie ich einen Shelly 3EM verbaut hat, der möchte die ermittelten Werte verarbeiten und visualisieren. Bei mir kommt hinzu, dass ich ein Balkonkraftwerk installiert habe, was der eigentliche Grund für den Shelly war. Die Werte nur in der App zu sehen reichte mir auf Dauer aber nicht, da es nervig ist, ständig das Handy zur Hand zu nehmen, nur um die aktuellen Werte zu sehen. Daher habe ich nach einer Lösung gesucht, wie die Werte der drei Phasen einzeln und als Summe in Echtzeit dargestellt werden können. Der Aufwand sollte sich in Grenzen halten. Ich wollte mir kein großes Display an die Wand hängen, auf dem alle erdenklichen Dinge angezeigt werden. Es sollte eine dezente Anzeige werden, der die Mitbewohner entnehmen können, wann es sinnvoll ist, einen Verbraucher einzuschalten.

Als einfache und günstige Hardware bietet sich ein ESP8266 an, von dem ich noch diverse Modelle herumliegen habe. Da sich meine Programmierkenntnisse in engen Grenzen halten, habe ich nach einem Sketch gesucht, mit dem die Daten aus dem Shelly per Wlan ausgelesen werden. Der entscheidende Tipp kam von Leroy Cemoi. An dieser Stelle noch mal

Mit diesem Sketch als Basis habe ich zum Test ein 7-Segment Display angeschlossen. Als klar war, dass alles so läuft, wie ich es mir vorstelle, habe ich dieses gegen ein 1.8" TFT getauscht. Als Gehäuse dient ein defekter AVM Fritz!Powerline 510E. Die Beschriftung des Deckels lies sich mit Terpentin Ersatz sehr schnell entfernen.

Die Original-Platine habe ich demontiert, ein passendes Loch in den Deckel gefräst und das Display von hinten eingeklebt. Ziemlich enge Geschichte in dem Gehäuse, aber wenn man die Kabel lang genug lässt, findet sich irgendwann eine Anordnung der Komponenten, bei der sich der Deckel schließen lässt.

Wichtig: Alles gut isolieren. Da sind 230V AC sehr nah an den DC-Komponenten!!

In der Nacht fiel mir auf, dass das Display den ganzen Raum erleuchtet. Daher habe ich zusätzlich noch einen LDR installiert, mit dessen Werten die Helligkeit des Backlights gesteuert wird. Für den LDR habe ich das im Gehäuse vorhandene Loch des Reset-Tasters genutzt, dass wie dafür gemacht zu sein schien.

Das Mapping muss noch etwas angepasst werden, daher lasse ich mir den Wert in der ersten Zeile zum Debugging anzeigen. Der verschwindet natürlich demnächst.

Updates werden der Einfachheit halber OTA aufgespielt.

Rein technisch läuft das jetzt so, wie ich es mir vorgestellt habe. Optisch kann man die Anzeige vielleicht noch aufhübschen.

Steinardo

Danke für die Info. Nur leider kann ich noch immer nicht programmieren.

Leroy Cemoi

Der Link enthält genau das, was ich gesucht habe, nach einigem Herumprobieren habe ich die Ausgabe im seriellen Monitor und auf einem Display

Nun muss ich nur noch ein Gehäuse finden und dann schauen, ob ich nicht doch noch ein anderen Display nehme. Aber das grundsätzliche Problem ist gelöst. Ich komme mit dem ESP an die Daten des Shelly

Testweise wollte ich die Daten im seriellen Plotter ausgeben. Leider klappt das aber nicht. Ich nehme an, dass es ein banaler Fehler ist. Vielleicht sieht jemand das Problem?

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(",");

Ich lese die Werte der drei Phasen am Hausanschluss mit einem Shelly EM3 aus. Diese stehen per Wlan vor Ort zur Verfügung und werden mir unterwegs auch in der App angezeigt. Das funktioniert alles einwandfrei.

Nun würde ich die Werte der drei Phasen so wie den Summenwert aller Phasen gerne mit einem ESP8266 über das heimische Wlan auslesen.

Hintergrund ist, dass ich in der Küche ein kleines Display installieren möchte, auf dem der aktuelle Verbrauch angezeigt wird und in möglichst kurzen Abständen aktualisiert wird.

Kennt jemand einen fertigen Sketch oder ein Projekt, mit dem es möglich ist, die Daten per ESP8266 auszulesen? Dann müsste ich das Rad nicht neu erfinden.

Tja, ich sags mal so:

Wenn es die Möglichkeit gibt, ein Problem in Software oder in Hardware zu lösen, dann nehme ich den Lötkolben (weil ich nicht Programmieren kann)

Ist Dein Problem denn jetzt gelöst?

Mhhhh, der Takt (intern 8Mhz) stimmt?

Prellt vielleicht Dein Taster?

Versuch mal die angehangene Schaltung. Dann sollte er nicht mehr prellen.

edit: Die 4h sind natürlich nicht super exakt. Sie sind abhängig von der Genauigkeit des internen Taktes. Der variiert nach Umgebungsbedingungen (Luftfeuchtigkeit, Temperatur) etwas.

Hallo Andreas,

willkommen im Forum.

Ist schon eine Weile her mit dem X-Mas Timer - aber es funktionieren noch immer alle Modelle, die ich seinerzeit erstellt habe.

Hier der Inhalt der oben verlinkten INO-Datei:

/*
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) {


}


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

Ein paar Platinen habe ich noch liegen. Alles Weitere bitte per PN.

Du hast Post.

Hallo,

sorry, PM Account lief über. Ich habe aufgeräumt. Jetzt sollte es wieder klappen.

Alles weitere dann via PM.

Aufgesteckt ist eine Platine, auf der sich der der CC1101 befindet. Das kann man nicht einfach austauschen, da dafür ein komplett anderer Sketch notwendig wäre.

Ich nutze HM IP nicht, habe aber im Ohr, dass die "nicht-IP (866 Mhz)" Geräte ebenfalls über HM IP genutzt werden können. Daher die Frage an diejenigen, die es wissen:

Kann ich mit einer HP-IP Anlage die "nicht-IP" Geräte steuern?

Es müsste nicht nur die Hardware komplett geändert werden, sondern auch die Firmware.

Damit reden wir nicht mehr von einer Modifikation des bestehenden Projektes, sondern von einem komplett neuen Projekt. Da ich aktuell keinen Bedarf daran habe, werde ich das nicht umsetzen. Aber vielleicht findet sich ein anderes interessiertes Forenmitglied, mit dem eine Umsetzung möglich wäre.

Bezüglich der Platine hast Du eine PN.

Vielleicht muss es nicht zwingend eine RasPi Hardware sein?

Thread

Pihole auf OrangePi im AVM Powerline Gehäuse

Ich suchte die Möglichkeit, einen Pihole möglichst anwenderfreundlich aufzubauen, da diese Lösung in einem DAU Haushalt arbeiten soll.
Zuerst einmal musste ich das thermische Problem des OrangePi lösen. Die CPU/SoC wird im Betrieb unglaublich heiß. Der Kühlkörper muss also relativ groß sein und die Wärme ohne Lüfter ordentlich abtransportieren. Gefunden habe ich einen Kühlkörper aus Kupfer, bei dem sich die Lamellen auseinander biegen lassen. Die Lösung erschien mir sinnvoll. Ein…

Neueinsteiger

Mar 14th 2021

Da die Spannung komplett auf die Ventile geschaltet wird und ich nicht weiß, was sie vertragen, würde ich maximal 9V6 nehmen. Aber auch dabei bitte nachmessen. Denn bei voll geladenem Akku können es durchaus mal wesentlich höhere Spannungen sein.

Eine Alternative zum 9V Block wäre vielleicht 6xAA Batterien.

Gab es das Problem mit den Abbrüchen schon immer oder erst seit einem der letzten Updates der Zentrale?

Es könnte nämlich auch durchaus sein, dass der CC1101 nicht nicht ganz mit Deiner Zentrale harmoniert, weil er leicht verstimmt ist.

Das Problem könnte ich versuchen zu lösen - dann bitte PN.

Wenn Du in "einer" Welt bleiben möchtest, wäre RaspberryMatic vielleicht eine Lösung.

Einen großen Teil der Aktoren/Sensoren kann man günstig selber bauen. Dazu gibt es eine seit langer Zeit sehr aktive Community.

Dort werden und wurden unter anderem Geräte entwickelt, die der Hersteller in der Form gar nicht im Angebot hat, wie z. B. mein Gardena-Ventil Adapter.

Thread

Umbau GARDENA Bewässerungsventil (1251-20) 9V auf HomeMatic

Als "Machbarkeitsstudie" habe ich eine Schaltung entwickelt, mit der es möglich ist, Gardena Bewässerungsventile vom Typ 1251-20 per HomaMatic zu schalten. Die Platine mißt in etwa 36x61mm. Es ist sowohl ein 6poliger ISP-Header als auch Rx/Tx mit GND und Reset vorhanden, um Sketche auf den AVR zu bekommen. Die CC1101 Platine habe ich gesockelt, um sie beim Flashen entfernen zu können.

Da die Hardware ohne passende Software nicht zu gebrauchen ist und ich ein bekennender Softwarelegastheniker…

Neueinsteiger

Mar 17th 2019

Aber auch ganz banale Dinge wie Nachbauten von Temperaturdifferenzsensoren, etc.

Als Basis könnte man diese kleine Schaltung nehmen und damit das gewünschte Projekt umsetzen. Viel kleiner geht es nicht.

Hier ein kleiner Auszug der dortigen Projekte:

https://asksinpp.de/Projekte/

Ich habe hier vor einiger Zeit mal einen interessanten Kühlkörper gezeigt.

Der müsste auch auf einen RasPi SOC passen.

Thread

Pihole auf OrangePi im AVM Powerline Gehäuse

Ich suchte die Möglichkeit, einen Pihole möglichst anwenderfreundlich aufzubauen, da diese Lösung in einem DAU Haushalt arbeiten soll.
Zuerst einmal musste ich das thermische Problem des OrangePi lösen. Die CPU/SoC wird im Betrieb unglaublich heiß. Der Kühlkörper muss also relativ groß sein und die Wärme ohne Lüfter ordentlich abtransportieren. Gefunden habe ich einen Kühlkörper aus Kupfer, bei dem sich die Lamellen auseinander biegen lassen. Die Lösung erschien mir sinnvoll. Ein…

Neueinsteiger

Mar 14th 2021

Eine interessante Möglichkeit zur ursprünglichen Frage in diesem Faden bietet dieser Artikel:

https://www.elektormagazine.de…and-others-in-the-shelter

Zu welchem Zeitpunkt hast Du wie lange gemessen?

Die 20 mA sind völlig normal, aber nicht der Ruhestrom. Wird die Batterie angeklemmt, dauert es etwa 20-30 Sekunden, bis die Schaltung in den Tiefschlaf geht. So lange werden die rund 20mA gezogen.

Ist die Platine angelernt und in Betrieb, dann geht der Stromverbrauch während des Schaltvorganges kurzzeitig hoch (Ventil wird geschaltet), um dann wieder auf 20mA zu fallen, bis die Schaltung wenige Sekunden später wieder in den Tiefschlaf geht.

Du solltest die CC1101 Platine nicht abziehen oder anstecken, während die Schaltung an die Batterie angeklemmt ist!

Dem Thema hat sich wolwin ausführlich gewidmet und im aktuellen Update der Firmware (Anfang 2021) die Werte wie folgt gesetzt:

#define BAT_VOLT_LOW_MAX 90 // 9.0V

#define BAT_VOLT_LOW 81 // 8.1V

#define BAT_VOLT_CRITICAL 78 // 7.8V

Aber letztlich kommt es auch immer auf das Ventil an. Manche Ventile arbeiten bei 8V noch zuverlässig, andere schon nicht mehr. Es scheint eine gewisse Serienstreuung zu geben. Auch gibt es natürlich Bauteiletoleranzen, die das Ergebnis der Messung leicht "verfälschen". Sollte ein Ventil nicht mehr zuverlässig schalten, liegt es mit großer Wahrscheinlichkeit an der zu niedrigen Batteriespannung.