Dauerkalender

Küchenwecker mit Solarpanel

Es folgt eine Schaltung, die aus fertigen Modulen zusammengestellt wird. Die Komponenten des „Küchenweckers mit Solarpanel“ sollen so verschaltet werden, dass das Einsetzen einer Batterie oder einer anderen externen Spannungsquelle nicht notwendig ist. Die Rolle des Energiespenders übernehmen hier je nach aktuellen Lichtverhältnissen ein Solarpanel oder ein Akku.
Die Grundaufgabe der Schaltung weicht nicht von der eines gewöhnlichen Küchenweckers ab. Man stellt die gewünschte Wartezeit ein und startet den Wecker. Nach Ablauf der Zeit erfolgt meist ein akustisches Signal. Ein Hinweis, dass z.B. die Frühstückseier oder Mittagsuppe fertig sind.
Die gesamte Schaltung benötigt im eingeschalteten Zustand einen Strom in Höhe von ca. 40 bis 45 mA. Das ist nicht gerade wenig. Deswegen, um den Akku nicht unnötig zu belasten, wird die Schaltung so konzipiert, dass bei nicht Benutzung eine automatische Abschaltung erfolgt. In dem ausgeschalteten Zustand kann der Akku mithilfe des Solarpanels wieder aufgeladen werden.

Ein Li-ion Akku übernimmt die Rolle des Energiespeichers. Die nominale Spannung des Akkus beträgt 3,7 V. Mit einer Ladekapazität von 800mAh kann der Akku über einen längeren Zeitabschnitt die Schaltung „am Leben“ erhalten.

Solarpanel 6V. Solarpanel macht die Schaltung von einer externen Spannungsversorgung unabhängig. Vorausgesetzt natürlich, es steht ausreichend Lichtenergie zur Verfügung. Bei schlechten Lichtverhältnissen können zwei oder mehrere Solarpanels zusammengeschaltet werden.

Ladeelektronik. Das Modul „Waveshare Solar Power Management“ kümmert sich um den Ladevorgang. Sobald das Solarpanel Strom liefert, wird der Akku automatisch aufgeladen. Vier Leuchtdioden informieren über den aktuellen Stand des Akkus. Sobald der Akku überlastet wird, erfolgt eine automatische Abschaltung. Damit wird der Akku vor der Tiefentladung geschützt.

7-Segmentanzeige mit TM1637. Das Anzeige-Modul besteht aus einer 7-Segmentanzeige (4-Digit) und dem Treiber TM1637. Der Treiber erleichtert erheblich das Ansteuern der Anzeige. Trotz, dass die Anzeige aus 29 Elementen besteht, werden für die Ansteuerung durch den Mikrocontroller nur zwei Leitungen benötigt.

Arduino Nano. Der Mikrocontroller Arduino Nano wacht über das Gesamtspiel aller Komponenten der Schaltung. Es werden insgesamt sieben seiner I/O-Pins in Anspruch genommen. Drei Pins, die als Eingänge definiert werden, sind für die Tasten-Eingaben zuständig. Zwei Pins befassen sich mit der 7-Segmentanzeige. Zwei weitere Pins sind als Ausgänge definiert. Ein Ausgang ist für die automatische Abschaltung vorgesehen, der andere steuert den aktiven Summer.

Tianbo HJR-4102E-L-05V. Das 5V-Relais von Tianbo ist für die Spannungsversorgung von Arduino und anderen Komponenten der Schaltung (außer Ladeelektronik) verantwortlich. Das Relais wird mit einem Taster eingeschaltet. Der Taster muss solange gedrückt gehalten werden, bis das Programm des Arduino anläuft. Dann übernimmt Arduino die Ansteuerung des Relais und der Taster kann losgelassen werden. Nach Benutzung des Weckers schaltet Arduino das Relais und damit sich selbst automatisch ab.

Aktiver Summer 5V. Wenn man die zwei Gleichrichterdioden, die in die Schaltung eingepflegt wurden, außer Acht lässt, ist der 5V-aktiver Summer der kleinste Teilnehmer der Schaltung. Er beinhaltet neben einen kleinen Lautsprecher auch eine Steuerelektronik. Durch Anlegen einer Spannung von 5VDC beginnt der Bauteil sofort „Krach“ zu machen. Mit seinem Piepton wird signalisiert, dass die eingestellte Zeit des Küchenweckers abgelaufen ist.

Der Schaltplan

Schaltplan

Die Testschaltung

Testschaltung

Mit dem Schalter ON-OFF auf dem Modul „Waveshare Solar Power Management“ wird die Ladeelektronik aktiviert und kann als Spannungsquelle in Anspruch genommen werden. Das Spiel zwischen dem Akku, Solarpanel, Stromentnahme und dem Ladevorgang wird von dem Modul automatisch verwaltet.
Mit dem Taster S1 wird unsere Schaltung aktiviert. Der Tasterdruck wird solange benötigt, bis der Ausgang D2 des Arduino gesetzt wird. Das Relais wird jetzt von Arduino gesteuert und der Taster kann losgelassen werden.
Mit den Tastern S2 und S3 wird in Sekunden und Minuten die gewünschte Zeit eingestellt. Mit dem Taster S1 wird der Wecker gestartet. Das Runterzählen der Zeit erfolgt in einem 1-Sekunde-Takt. Nach Ablauf der Zeit wird der aktive Summer aktiviert. Das akustische Signal des Summers informiert, dass die Zeit abgelaufen ist.
Eine wichtige Funktion der Schaltung ist die automatische Abschaltung. Die Schaltung wird in dem Beispiel nach 20 Sekunden, sofern keine Taste betätigt wurde oder die Hauptzeit abgelaufen ist, abgeschaltet. Die Aus-Zeit wird in der Variable „Selbstabschaltung“ gespeichert. Die Variable wird in Sekundentakt dekrementiert. Sobald eine Taste betätigt wurde, wird die „Selbstabschaltung“ auf den Wert 20 zurückgesetzt. Wird die Schaltung 20 Sek. lang nicht benutzt, wird der Ausgang D2 zurückgesetzt und das Relais abgeschaltet.

Das Programm

          
  #include <TM1637Display.h>                               // Display - Bibliothek
  TM1637Display display(5, 4);                             // CLK, DIO - Pins

  int Zeit;                                                // Zeit - Hauptvariable (dez)
   
  int Taste_Sekunden = 12;
  int Taste_Minuten = 11;
  int Taste_Ein_Start = 3;
  int Einschaltung = 2;                                    // Relais Selbsthaltung
  int Summer = 6;                                          // Ausgang Summer
  
  unsigned long Millis_Aktuell;
  unsigned long Millis_Alt;
  bool Sekunde_Flanke;                                     // Sekunden Takt
  int Sekunden, Minuten;                                   
  bool Start;                                              // Wecker Start
  bool Summer_ein_aus;                                     // Hilsvariable Summer
  int Selbstabschaltung = 20;                              // Aus nach 20 Sekunden
  
  // *************************************************************************************
  void setup() {

    display.setBrightness(10);
    display.clear();
    pinMode (Einschaltung, OUTPUT);
    pinMode (Summer, OUTPUT);
    pinMode (Taste_Sekunden, INPUT_PULLUP);
    pinMode (Taste_Minuten, INPUT_PULLUP);
    pinMode (Taste_Ein_Start, INPUT_PULLUP);
    pinMode (Summer, OUTPUT);
    digitalWrite(Einschaltung, HIGH);                      // Selbsthaltung EIN
    digitalWrite(Summer, LOW);
    delay (1000);
  }

  // *************************************************************************************
  void loop() {
                                                  
      Sekunde_Flanke = false;                              // Sekunden-Takt 
      Millis_Aktuell = millis();
      if (Millis_Aktuell > (Millis_Alt + 1000)) {
          Millis_Alt = Millis_Aktuell;
          Sekunde_Flanke = true; }            

      if (Sekunde_Flanke and Start and (Zeit == 0)) {      // Zeit abgelaufen, Summer ein/aus
          Summer_ein_aus = !Summer_ein_aus;
          digitalWrite(Summer, LOW);
          if (Summer_ein_aus) { digitalWrite(Summer, HIGH); } }
          
      if (Sekunde_Flanke and Start and (Zeit != 0)) {      // Die Zeit läuft (Sekundentakt)
          Zeit_Berechnen (-1); 
          if (Zeit < 0) { Zeit = 0; } }

      if (Sekunde_Flanke) {                                // Zeit Selbstabschaltung
          Selbstabschaltung = --Selbstabschaltung; 
          if (Selbstabschaltung == 0) { digitalWrite(Einschaltung, LOW); } }          
                                                      
      if (digitalRead(Taste_Sekunden) == LOW) {            // Sekunden Eingabe (S3)
          Zeit_Berechnen (1); }

      if (digitalRead(Taste_Minuten) == LOW) {             // Minuten Eingabe (S2)
          Zeit_Berechnen (100); }     
                                                           // Reset + Stop
      if ((digitalRead(Taste_Sekunden) == LOW) & (digitalRead(Taste_Minuten) == LOW)) {
          Zeit_Berechnen (0);
          digitalWrite(Summer, LOW);
          Start = false; }
    
      if (digitalRead(Taste_Ein_Start) == LOW) {           // Küchenwecker Start (S1)
          Selbstabschaltung = 20;
          Start = true; } 

      String Display_Ausgabe = String (Zeit);              // Zeit - Anzeige
      display.showNumberDecEx(Display_Ausgabe.toInt(), 0b11100000, false, 4, 4);
      delay (150);  
  } 
  // *************************************************************************************

  void Zeit_Berechnen (int Sek) {                          // Zeit aktualisieren
      Sekunden = Zeit % 100;
      Minuten = Zeit / 100;
      switch (Sek) {
          case 1: {                                        // 1 Sek. addieren (S3)
              Sekunden = ++Sekunden; 
              if (Sekunden == 60) { Sekunden = 0; }
              break; }
          case 100 : {                                     // 1 Min. addieren (S2)
              Minuten = ++Minuten; 
              if (Minuten == 100) { Minuten = 0; }
              break; }
          case -1 : {                                      // 1 Sek. subtrahieren (Zeit läuft)
              Sekunden = --Sekunden; 
              if (Sekunden == -1) { 
                  Sekunden = 59; 
                  if (Minuten == 0) { Sekunden = 0; }
                  Minuten = --Minuten; }
              if (Minuten == -1) { Minuten = 0; }
              break; }
          case 0: {                                        // Zeit = 0 (Reset)
              Sekunden = 0; 
              Minuten = 0;
              break; }              
      }
      Zeit = Minuten * 100 + Sekunden;
      Selbstabschaltung = 20;                              // Selbstabschaltung zurücksetzen
  }
  // *************************************************************************************          

Kurzvideo

Kurzvideo

Solarenergie & Akkus

Weitere Themen: