suche eine geeignete Zeitverzögerungsschaltung

Hallo liebe Freunde,

ich möchte einen Tastdimmer für eine LED-Beleuchtung mit einem Bewegungsmelder ansteuern.
Der Dimmer hat die angenehme Eigenschaft, dass bei einem kurzen Impuls die zuletzt eingestellte Helligkeit eingeschaltet wird.
Also stelle ich mir vor, dass der Ausgang des Bewegungsmelders über ein Relais ein Monoflop, wie es ihn zB. bei Conrad gibt, ansteuert und einen 1-sec.-Impuls abgibt, der den Tastdimmer auslöst. Aber nach vielleicht einer Minute muss noch ein 1-sec.-Impuls kommen, der den Tastdimmer wieder abschaltet. Und da fehlt mir eine Idee, wie das möglichst einfach zu bewerkstelligen ist. Hat vielleicht noch jemand eine andere Idee, wie das auf einfache Weise gelöst werden kann.

Lg Funky

Retriggerbares Monoflop mit einstellbarer Zeit.
Und am Ausgang des Monoflops ein Latch (Flankengesteuertes Flipflop), das durch eine Verzögerungskette von 1s sich selbst wieder zurücksetzt.

danke für die Antwort, aber vielleicht nochmal für Dummies: wie genau sieht ein Latch aus und wo kriegt man das?

https://de.wikipedia.org/wiki/Flipflop
Lies mal Abschnitt 3.3

Auf der Seite ist oben Rechts ein 74ATC74 zu sehen.
Das ist z.B. ein Baustein mit 2 D-Latches.


Du kannst auch einfach mal bei Google "d-latch kaufen" oder "rs-latch kaufen" eingeben.
Da kommen sofort Treffer für die 74xx und die 4xxx Reihe.

Die Verzögerungskette wird hier erklärt:
https://de.wikipedia.org/wiki/Delay-Locked_Loop

da habe ich ja jetzt erst mal Futter. das muss ich mir erst mal zu Gemüte führen. Hoffentlich komme ich klar.
Danke für die Infos

Zitat:

---

Zitat von funky34

Hat vielleicht noch jemand eine andere Idee, wie das auf einfache Weise gelöst werden kann.

---

Das System hat einen digitalen Eingang und einen Ausgang. Ich würde den kleinsten µC nehmen, den ich in der Kiste hab, also ein 8-Pinner. Andere mögen den kleinsten Arduino nehmen. Damit läßt sich leicht etwas aufbauen, die Funktion kann man dann leicht ohne zu löten den Erfordernissen anpassen.

MfG Klebwax

Hallo Klebwax,

super, dass du dich hier noch gemeldet hast. Die Idee mit dem Mikrocontroller gefällt mir. Leider habe ich mich Ende der 80-er Jahre mal mit Kleinrechnern beschäftigt, seit dem nur noch mit dem PC.
Und so habe ich auch keinen µC in einer Kramkiste. Kannst du mir einen konkreten Vorschlag machen, was für ein µC für meinen Zweck geeignet ist, für den es auch gute Dokumentationen gibt.

Lg Funky

Grundsätzlich gibt es für jeden Controller gute Dokumentation, nennt sich Datenblatt. Ich würde einen AVR nehmen (z.B. Attiny45 o.Ä.). Was du zu denen noch benötigst ist ein Programmer, damit du das Programm, das du geschrieben hast auch übertragen kannst. Die Software zum Programmieren gibt es kostenlos (von Atmel das AVR Studio für C und Assembler oder Bascom => Basicdialekt,...). Es gibt auch noch die Arduinos (verschiedene Leistungsklassen), der Vorteil ist das es schon sehr viel fertig gibt (Funktionen zum Programmieren) und die Controller einen Bootloader besitzen, damit man keinen externen Programmer benötigt.

Bei Controllern musst du aufpassen das du nur 5V (oder weniger) hast und der Strom den die Ausgänge liefern auch nicht sehr hoch ist. Wenn du ein Relais schalten willst benötigst du eine Treiberstufe (einfacher Transistor und eine Diode gegen die Spannungsspitze beim Abschalten).

MfG Hannes

gerade für Arduino-Einsteiger ohne große Programmier-Erfahrung finde ich das Funduino-Tutorial sehr brauchbar:

http://funduino.de/wp-content/upload...ch-12-2016.pdf

PS,
allerdings ist die hier verwendete Arduino IDE schon sehr alt (1.0.3), heute haben wir mindestens 1.8.x - nicht alles ist also sicher 100% up-to-date.
Fürs Basiswissen reicht es aber dicke.

Wenn es aufwendiger wird mit dem Controller (Wieder-) Einstieg, es gibt auch Zeitschalter mit 555-timern.

Die Bezeichnung von: "150 zweiten" bedeutet 150 Sekunden. :)

https://www.google.de/search?q=DC+5-12+V+Einstellbare+NE555+Modul+Led-Licht+Verz%C3%B6gerung&client=firefox-b&dcr=0&source=lnms&tbm=shop&sa=X&ved=0ahUKEwi4rZj LreLZAhUuyKYKHcDPBvQQ_AUICygC&biw=1908&bih=886

https://www.youtube.com/watch?v=4r3AuVLgma4
https://www.youtube.com/watch?v=i0SNb__dkYI
https://www.youtube.com/watch?v=HAi9TwqMHhc
https://www.youtube.com/watch?v=Oemj1xvDaIY

Zitat:

---

Zitat von Manf

Wenn es aufwendiger wird mit dem Controller (Wieder-) Einstieg, es gibt auch Zeitschalter mit 555-timern.

[/URL]

---

Der erste 1-sec- Impuls soll mit dem Bewegungsmelder kommen (Licht ein), der 2. 1-sec- Impuls nach einer gewünschten Zeit, zb. 2 Min (Licht aus). da weiß ich nicht, wie ich das mit 555-Timer zu machen ist.

Hallo funky34,
ohne Grundlagen geht es nun mal nicht.

vielleicht hilft das etwas weiter?:
https://www.rahner-edu.de/grundlagen.../timer-ic-555/

Gruß

Mit einem 555 wird das nicht so ohne weiteres gehen.
Erstell erst mal mit einem 555 ein retriggerbares Monoflop.
Der Ausgang geht beim Start von OFF auf ON (je nach Spannung die verwendet wird z.B. von 0V auf 5V).
Und bei Ablauf der Zeit auf ON auf OFF.
Retriggerbar heist, das wenn innerhalb der ON-Zeit ein neuer Startimpuls kommt der Timer zurückgesetzt wird und die ON-Zeit entsprechend länger wird.

Danach nimmt man ein Latch (Flankengesteuertes Flip Flop) bei jedem Wechsel (OFF nach ON oder ON nach OFF) wird der Ausgang des Latch von OF auf ON gesetzt.
Jetzt benötigt man eine Verzögerungskette (das kann ein zweiter 555 sein) die nach einer Sekunde das Latch zurücksetzt.

So bekommt man ein paar Nanosekunden nach dem Auslösereigniss einen 1S Puls und am Ende der eingestellten Zeit einen zweiten 1S Puls.
Wobeoi man die Länge des Pulses der beim Flankenwechsel auftritt auch einstellen kann wenn er nur kürzer ist als die kürzeste Zeit des ersten Monoflops.

Wie gesagt in dem genannten Video über den 555, ab 4:44 wird der Monoflop erklärt.

https://www.youtube.com/watch?v=i0SNb__dkYI

Wenn das mit dem Verständniss bei der Hardware Entwicklung noch hängt oder das Elektronik wissen nicht ausreicht, wäre die µC Variante allerdings wirklich eine Überlegung wert.

Eventuell mal den:
"Digispark Mini, ATtiny85, USB"
ansehen.
(ich selbst habe keine Erfahrung mit dem)
Der soll mit der Arduino IDE direkt per USB programimerbar sein, ist klein und kostet nicht die Welt.
Wenn die eine Sekunde langen Pulse nicht auf die Nanosekunde genau sein muß, ist ein Programm auch nicht all zu komplex.

Mit dem Triggerereigniss (und wenn Merkvariable2 nicht gesetzt ist) wird der aktuelle Wert des freilaufenden Timers in eine Variable1 geschrieben
Eine Merkvariable2 wird gesetzt und der Ausgang3 gesetzt.
Bei jedem Programmdurchlauf wird der Timer mit der Variable1 + eine Sekunde verglichen.
Bei Erreichen oder Überschreiten wird Ausgang3 gelöscht.

Ebenfalls bei jedem Programmdurchlauf wird der freilaufende Timer mit dem Wert der Varibale1 + der Zeit die bis zum zweiten Puls vergehen soll verglichen.
Ist das erreicht oder überschritten wird der Timer in eine Variable4 eingelesen und der Ausgang3 gesetzt, bei jedem Programmdurchlauf wird der Timer mit der Variable4 + eine Sekunde verglichen.
Bei Erreichen oder Überschreiten wird Ausgang3 gelöscht und die Merkvariable2 gelöscht.

Erfolgt ein Triggerereigniss wärend die Merkvariable2 gesetzt ist, wird Variable1 auf den aktuellen Timerwert gesetzt aber nicht der der Programmteil für den ersten ein Sekunden Puls durchlaufen.

Diese Variante hat gegenüber delay() (eine Funktion der Arduino IDE) den Vorteil, daß der µC wärend der ganzen Zeit weiter Daten verarbeitet und nicht blokiert ist. Theoretisch kann der also noch etwas anderes parallel machen, solange die Zykluszeit für den Programmdurchlauf dadurch nicht zu lang wird. Falls doch müsste man einen Interrupteingang nuzten und ggf. Timer-IRQs nutzen.

Das wäre im groben die Programmlogik.
Kosten wären bei dieser Variante nur, knapp 13 € wenn man bei Reichelt kauft (andere Anbieter könnten ggf. günstiger sein).
Die Arduino IDE kann man kostenlos runterladen.

Eine Eingangs- und eine Ausgangsschaltung müsste man ggf. genauso bauen wie bei der Hardware Variante auch.
(Anpass- und Schuzschaltung für den Eingang und Lestungstreiber/Anpaßschaltung für den Ausgang)

Mit der Überlegung über einen µC könnte ich mich anfreunden.
Du hast mr nun schon den möglichen Programmablauf recht detailreich beschrieben. Kannst du mir nicht die Programmzeilen zu Papier bringen. Ich werde mir den vorgeschlagenen Typ bei Reichelt bestellen.
Und danke für die Tipps

lg Funky

Ich kann wenn überhaupt frühestens am Wochenende mal was versuchen (Familinetermine).
Da ich mich mit dem Board nicht auskenne, muß ich erst mal nach Doku suchen damit ich weis welche Pins was können.

Wenn das triggerSignal lang genug ansteht, reicht ja ein digitalRead(). Steht das nur kurz an, brauchts einen Interrupteingang und eine ISR (Interrupt Service Routine).

Kann also sein, das ich was schreibe, das bei mir (nano, uno, due, mega) funktioniert, aber nicht an dem "Digispark Mini, ATtiny85, USB".
Das wäre dann anpassarbeit.
Und wie schon geschrieben, eine eventuell notwendige Eingangs und Ausgangsbeschaltung sollte man nicht vergessen.
Wäre doof so ein Teil wegen in paar gesparter Cent zu toasten.

https://s3.amazonaws.com/digistump-r...kSchematic.pdf

https://www.google.de/url?sa=t&rct=j...EtAIxFbzGqNLO6

http://www.cboden.de/mikro-controlle...-dem-digispark

https://arduino.ua/images/DPC254-2.jpg

Code:

---

// Digispark Mini, ATtiny85, USB
// Test 1 - Feste Zeiten mit Delay

void setup() {               
  pinMode(0, INPUT);
  pinMode(1, OUTPUT); 
}

void loop() {
  int trigger = digitalRead(0);
  if (trigger <> 0)
  {
    digitalWrite(1, HIGH);
    delay(1000);            //1 Sekunde an
    digitalWrite(1, LOW);
    delay(10000);        //10 Sekunden aus
    digitalWrite(1, HIGH);
    delay(1000);            //1 Sekunde an
    digitalWrite(1, LOW);
  }
}

---

Code:

---

NICHT FERTIG
// Digispark Mini, ATtiny85, USB
// Test 2 -

unsigned long prev1micros = 0;
int trigger = 0;
int togglesatate = LOW;

void setup() {               
  pinMode(0, INPUT);
  pinMode(1, OUTPUT); 
  // attachInterrupt(0, Eingang, LOW);
}

void loop() {
  int trigger = digitalRead(0);
  if (trigger <> 0 && togglestate == LOW)
  {
    togglestate = HIGH;
    unsigned long cur1micros = millis();
     
  }
  if (trigger <> 0 && togglestate == HIGH)
  {
    unsigned long cur1micros = millis();
     
  } 
  digitalWrite(1, HIGH);
  digitalWrite(1, LOW);
}

---

Code:

---

// Digispark Mini, ATtiny85, USB
// Test 3 -

---

#

Also, ich werde das Teil ja erst mal bestellen und da habe ich es auch sicher nicht vor dem WE, also ein Zeitproblem gibts nicht. Das Eingangssignal stammt vom Dämmerungsschalter und liegt minimal eine Minute an. Da der Dämmerungsschalter Hochspannung liefert, muss da erst noch ein Relais her.

Also, wenns erst nächste Woche oder später wird, würde ich mich trotdem über die Programmzeilen freuen, ich übernehme sie nicht ungesehen, versprochen, sondern nur als Einstieg für meine Versuche mit dem Teil. Aber eine Supergrundlage wäre das bestimmt. Quellen für die notwendigen Infos habe ich Dank eurer Hilfe bekommen.

Zitat:

---

Zitat von funky34

Da der Dämmerungsschalter Hochspannung liefert, muss da erst noch ein Relais her.

---

Das ist keine Hochspannung, Hochspannung ist über 1000V. Nennen wir diese Spannung einfach Netzspannung. Gefährlich ist diese Spannung aber trotzdem.

Wenn du es mit einem Relais machen willst (am Einfachsten), achte darauf das du ein Signalrelais verwendest und kein Leistungsrelais, sonst kann es zu Problemen kommen.


Ich würde eine Flankenerkennung einbauen und auf diese Flanke reagieren. Hier als Pseudocode (mit teilweise C-Code weil ich in C programmiere):
Bewegungsmelder = BM
"Sollwert" ist die Pause zwischen den beiden Impulsen
!= bedeutet "ist nicht"
== bedeutet "ist gleich"
++ bedeutet "erhöhen um 1"

Code:

---

Dauerschleife
{
  BM einlesen

  Flankenerkennung: (BM != BM_alt) & (BM == geschalten)      => dadurch hast du eine Flankenerkennung auf eine positive Flanke
  {
      Status = 1
  }

  switch (Status)
  {
      case 1:
        Ausgang setzen
        Status = 2
        "switch" Abbruch
      case 2:
        Ausgang löschen
        Status = 3
        "switch" Abbruch
      case 3:
        Zähler ++
        Wenn Zähler >= Sollwert: Status = 4, Zähler = 0
        "switch" Abbruch
      case 4:
        Ausgang setzen
        Status = 5
        "switch" Abbruch
      case 5:
        Ausgang löschen
        Status = 0
        "switch" Abbruch
  }

  BM_alt = BM
  Pause (1s)
}

---

Zuerst wird erkannt ob der BM geschalten hat (Flankenerkennung), wenn ja wird in "case 1" der Ausgang gesetzt, durch die Pause am Ende der Dauerschleife wird der Ausgang 1s später wieder gelöscht (case 2). Die eigentliche Zeit zwischen den beiden Impulsen wird mit "case 3" gemacht, der Zähler wird bei jedem Schleifendurchlauf um 1 erhöht (dadurch hast du ein vielfaches des Schleifendurchlaufes). Wenn der Zähler den Sollwert erreicht wird in case 4 und case 5 der Impuls erzeugt.

Beim switch kannst du noch nach "case 5" ein "default" einfügen, das wird immer ausgeführt wenn bei Status keine der cases zutrifft (z.B. nach "case 5" da dort Status auf 0 gesetzt wird).

Du kannst auch die Pausenzeit ändern (z.b. 100ms), dann musst du aber eventuell noch zwischen den beiden Cases für Ausgang setzen bzw löschen ein weiteres Case einsetzen und mit einem Zähler versehen (wie bei case 3). Dann hast du:
Case 1 Ausgang setzen
Case 2 Zähler (Impulslänge)
Case 3 Ausgang löschen
Case 4 Zähler (Pause zwischen Impulsen)
Case 5 Ausgang setzen
Case 6 Zähler (Impulslänge)
Case 7 Ausgang löschen

MfG Hannes

Danke für eure Vorschläge. jetzt muss ich warten, bis das Teil da ist. Danach bin ich erst mal unterwegs. Ich werde mich später sicher nochmal melden, wenn ich vielleicht noch nen Tipp brauche.

Lg Funky

mit Arduino API Funktionen (millis, delay) geht das doch wirklich noch 1000mal einfacher....!

Wenn man kein retriggerbares Monoflop braucht, geht natürlich auch delay().

Code:

---

// Digispark Mini, ATtiny85, USB
// Test 1 - Feste Zeiten mit Delay

void setup() {               
  pinMode(0, INPUT);
  pinMode(1, OUTPUT); 
}

void loop() {
  int trigger = digitalRead(0);
  if (trigger <> 0)
  {
    digitalWrite(1, HIGH);
    delay(1000);            //1 Sekunde an
    digitalWrite(1, LOW);
    delay(10000);        //10 Sekunden aus
    digitalWrite(1, HIGH);
    delay(1000);            //1 Sekunde an
    digitalWrite(1, LOW);
  }
}

---

Sobald der Trigger ausgelöst ist, wird das stur abgearbeitet.
Ob währenddessen ein zweiter Trigger kommt, der den Zyklus verlängern soll, wird nicht registriert.

Bei Retriggerbarkeit, wird der erste 1 Sekunden Puls erzeugt, wenn während oder nach dem Impuls ein neuer Trigger kommt wird die Zeit für das Monoflop zurückgesetzt und die Gesammtzeit ist dann die schon verstrichene Zeit plus die Zeit auf die der Timer eingestellt ist. Wie bei einem Treppenhauslicht kann man damit die Zeit bis zum zweiten 1 Sekunden Puls beliebig verlängern, wenn mann innerhalb der Zeit immer wieder neu triggert.

Es kommt halt auf die exakte Aufgabenstellung an, was man benötigt.

genau, zum Retriggern verwendet man nicht delay sondern stoppt/überwacht millis() in einer eigenen while() loop:

zum Retriggern wird einfach vorher die Systemzeit millis gestoppt,
dann wird ein Zielwert der gestoppten Zeit + 10000 milli-sek (oder was auch immer) zwischengespeichert.
In der while-Schleife wird dann solange geloopt, bis millis den Zielwert erreicht oder überschritten hat.

In der Loop wird parallel weiterhin trigger=digitalRead(0) abgefragt, und wenn ein Tastendruck erfolgt ist, wird erneut der Zielwert um 10000milli-sek erhöht.

Die Version mit delay sieht doch recht überschaubar aus. Wenns damit erst mal klappt, kann man doch weiter experimentieren.

Ganz so einfach ist das nicht.

Der erste 1 Sekunden Puls soll ja nur einmal ausgeführt werden und darf sich auch nicht verlängern.
Und der zweite 1 Sekunden Puls soll auch nur einmal kommen, am Ende kommen und darf sich auch nicht verlängern.
Also muß durch Verriegelung verhindert werden das erneute Trigger diese Impulse mehrfach erzeugen oder verlängern.
Und der zweite 1 Sekunden Puls muß ein Retriggern verhindern während er läuft.
Man muß sich halt klar machen, das selbst bei kurzen Ereignissen, die Programmschleife x mal durchlaufen wird und ohne Verriegelungen und Zustandsmerker, der ganze Ablauf durcheinander kommen kann.

Nachdem der Vorgang gestartet worden ist, kann es zum erneuten Triggern kommen
1- während der erste Puls läuft
2- Zwichen den Pulsen
3- während der zweite Puls läuft
4- nach dem der Zyklus beendet ist.

Bei 1- darf sich nur die Zeit verlängern.
Bei 2- darf sich nur die Zeit verlängern.
Bei 3- darf gar nichts passieren.
Bei 4- wird der Zyklus neu gestarted.

und wie könnte das programmtechnisch aussehen?

Merkervariablen!

Für jeden Zustand eine Abfrage, ob die Startedingungen erfüllt sind und noch kein entsprechender Merker gesetzt ist. Wenn ja, dann kann die Start Sequenz für den Zustand durchgeführt werden. (Merker setzen, Timerwert in Variable übernehmen und z.B. Ausgangspegel ändern).
Wenn die Startbedingungen erfüllt sind und der Merker gesetzt ist, dann wird die Schlußsequenz durchlaufen.
Also prüfen ob der Timerwert vom Start plus der Wert der zu verstreichenden Zeit gleich oder größer ist als die aktuelle Zeit.
Wenn nicht ist das Sequenzende erreicht und es werden die Ausleitenden Maßnahmen getroffen.
Ggf. einen Merker setzen, das diser Abschnitt bereits ausgeführt wurde (ob dieser Merker nicht gesetzt ist, wäre dann eine der Startbedingungen), den Mekrer das dieser Abschnitt grade durchlaufen wird wieder löschen und ggf. Ausgangspegel ändern.

Man hat also für jeden Abschnitt im Zyklus zwei Sequenzen. Eine zum starten und eine zum Ausführen und beenden.
Und man hat (bei dieser Aufgabenstellung) 4 erlaubte Systemzustände.
Man erstellt eine Wahrheitstabelle und zeichnet ggf. zur Visualisierung mal die Pegel von Eingang, Ausgang, und dem Monoflop1 (lange, variable Zeit, nicht die Pulse) auf.
Dann fängt man an den Eingangsimpuls zu verlängern und erneut zu senden. und schaut, ob man immer noch das gewollte Ergebniss bekommt, oder ob sich dann z,B der 1S Puls am Start verlängert oder wärend des Zyklus wiederhohlt.
Fügt einen Merker ein und schaut ob man durch dessen Setzen das Fehlverhalten unterbindet.
Dann prüft man wann der Merker wieder gelöscht werden muß, damit man damit nicht in einem Zustand gefangen ist oder beim nächsten Durchlauf des Gesamtzyklus nicht mehr funtionsfähig ist.

Am Ende hat man eine Liste mit Merkern und wo (wann) man sie setzen und löschen muß damit das Programm immer sauber funktioniert.
Das dann in Code abzubilden ist eine reine Sache des Wissens über die Möglichkleiten der Zielsprache (hier C++).
Bei einem Programm dieser Größenordnung macht man das im Kopf oder auf dem Papier.
Bei komplexeren Programmen werden dann Unittests (der Programmierer selbst) oder Modultests (jemand fremdes als Tester) geschrieben.
Der Test bzw. die Begutachtung durch Dritte ist nicht verkehrt, damit man bei einem systematischen Fehler, seitens des Programmierers, nicht hängen bleibt.

viel einfacher ist es, das für mehrere Taster mit verschiedenen Verzögerungen per Multithreading zu lösen.
Jede Taster-Abfrage kommt in einen eigenen Thread (== eine eigene loop).

Multithreading für Arduino gibt es als Scheduler Libs, in verschiedenen Ausführungen nur für M0 und Due (sehr stabil) oder auch für AVR und ARM gemeinsam (etwas "shaky"):
http://www.mindstormsforum.de/viewto...p=66188#p66188


Multithreading birgt allerdings auch ein paar Fallstricke für absolute Neulinge, die man erst durch etwas Einarbeitung und wachsende Erfahrung in den Griff bekommt - aber dann läuft's perfekt! 8)

Zitat:

---

Zitat von HaWe

viel einfacher ist es, das für mehrere Taster mit verschiedenen Verzögerungen per Multithreading zu lösen.
Jede Taster-Abfrage kommt in einen eigenen Thread (== eine eigene loop).

---

Welche mehreren Taster?
Es gibt genau einen Eingangspin und genau einen Ausgangspin.

ach so, das hatte ich falsch verstanden, ich dachte er wollte mehrere Ausgänge mit mehreren Tastern simultan und jeweils zeitverzögert steuern.

Nein, dann ist es ja so einfach, wie ich schon hier geschrieben habe:

https://www.roboternetz.de/community...l=1#post643431

Ich hab das mal für ein Handy gebaut, war im Grunde ähnlich in den Anforderungen. Da mussten zwei Tasten gedrückt werden, damit es alleine wählt und das Freisprechen einschaltet. Ich habs dann kurzerhand mit 3 555-Timern gemacht. Die steuern sich gegenseitig. Die Ausgänge des 555 schalten nach Masse durch (irre mich hoffentlich nicht), was ganz praktisch ist. Damit kann man den nächsten 555 am Triggereingang auf LOW ziehen. Mal nach einem Datenblatt googlen, da sind auch Beispielschaltungen ist ziemlich einfach, nur diskret etwas aufwendig. Prinzip: der erste 555 wird mit dem Bewegungsmelder getriggert, nach 1s schaltet dann der Ausgang um. Den zweiten 555 kann man mit demselben Impuls triggern und ihm die Zeit von 2min zum Ablaufen geben, dann schaltet der Ausgang um und triggert bspw. den dritten 555. Fertig. Die Ausgänge kann man noch über ein OR-Gatter-TTL-Baustein zusammenführen und dort am Ausgang einen Schalttransistor dranhängen, der gegen Masse schaltet (ich glaub damit gehen ca. 50mA zu schalten - BCxxx), Zwecks Relais, Freilaufdiode für Relais erübrigt sich damit glaub ich auch (Transistor), aber zur Not kann man ja noch eine am Relais dranschalten.

Datenblatt mit Beschaltung und Formeln zur Berechnung:

http://html.alldatasheet.com/html-pd.../12/LM555.html

Hallo Moppi, danke für deine Anregung, das ist sicher eine gute Idee, aber ich habe schon den µC bestellt und werde mich damit auseinandersetzen, wenn das nicht klappt, kann ichs ja immer noch nach deiner Version versuchen.

danke
Funky

Ja, hatte ich schon gelesen, dass Du den bestellt hast. Mir ging es nur darum, dass das nicht so schwer ist mit den 555-ern. Zumal man damit noch viele andere Dinge machen kann. Wollte Dir deshalb Mut zusprechen, die 555er im Repertoire zu haben ist immer gut. Mit einem µC bist Du auf jeden Fall hinterher flexibler, kannst es jederzeit in der Funktion ändern, das ist der Nachteil bei dem Andern. Welche Kosten verursacht die µC Variante eigentlich?

Zitat:

---

Zitat von Moppi

Welche Kosten verursacht die µC Variante eigentlich?

---

Ich hatte ja vorgeschlagen, einen 8-Pinner zu nehmen. Ich verwende PICs, da kosten die kleinen mit 8 bzw 14 Pins so einen € oder auch etwas weniger. Dazu kommt noch ein Stützkondensator für ein paar Cent. Dann noch einmalig ein PICKit 3 Clone für rund 10€ als Programmer/Debugger. Der Compiler und die IDE sind umsonst. Für die zwei-drei Dutzend Programmzeilen mit denen man diese Problem lösen kann, ist außer dem Lesen des Datenblattes nicht mehr nötig.

Entsprechendes gilt natürlich auch für die AVRs, die kommen ja inzwischen aus dem gleichen Stall. Je nach Prozessortyp kann man noch den einen oder anderen Cent sparen, um einen oder zwei 555 nachzubilden tuts der allerkleinste. In Summe kann das billiger werden als ein 555 mit den zusätzlichen Bauteilen, insbesondere wenn die Kapazitäten größer werden. Genauer wirds allemal. Die internen Oszillatoren der modernen µCs sind besser als 1%, größere Kondensatoren haben eher Tolleranzen größer 10%.

MfG Klebwax

Anhang 33370
Diesen Digispark habe ich bestellt.
Und dann benötige ich noch den folgenden Programmer?Anhang 33371

- - - Aktualisiert - - -

Anhang 33372
oder wo ist der Unterschied zu dem Teil? Was ist einfacher oder besser beschrieben?

- - - Aktualisiert - - -

Zitat:

---

Zitat von funky34

Digispark habe ich bestellt.[...]Und dann benötige ich noch den folgenden Programmer?

---

Für den Digispark benötigst du keinen zusätzlichen Programmer. Er kommt mit einem vorinstallerten Arduino-Bootloader und kann über USB programmiert werden. Hier die Anleitung vom Hersteller: https://digistump.com/wiki/digispark

Ja, an Hardware braucht es nur den Computer auf dem die Arduino IDE ist und dessen USB-Anschluss und die Digispark.
Eine etwas bessere Anleitung gibt es hier:
https://digistump.com/wiki/digispark...als/connecting

Wenn Du die aktuellste Arduino IDE auf einem Windows System installierst, benötigst Du den Treiber.
Dann in der Arduino IDE die URL für den zusätzlichen Boardmanager und dort dann die 16,5MHz default wählen.

Als ersten Test den Code von der Anleitung in die IDE copieren, compilieren und hochladen.
Digispark einstecken und danach fängt die LED an zu blinken (Progamm wird ausgeführt).
Du kannst die Digispark dann rausziehen und z.B. in ein USB Netzteil oder Powerbank (wenn die eine USB A Buchse hat) einstecken und nach ein paar Sekunden läuft das Programm.

Ich hatte mir günstig ein Dreierpack geschossen, ist heute morgen gekommen.
Habe eben den Post gelesen und in unter 6 Minuten vom Auspacken bis ans Netzteil vom Smartphone Stecken alles gemacht (Arduino IDE ist bei mir bereits installiert, also nur Treiber und Borad installieren). jetzt blinkt es an der Steckdose im Sekundentakt.
Also super einfach das Teil.