Kleiner Touch-Button

Last Updated 1 Woche ago by mcp_user

Clever, stromsparend, flexibel – und jetzt läuft er zum ersten Mal!

Was ich will, ist:

Ein winziger Touch-Button
Den ich einfach an die Wand oder auf den Schreibtisch kleben kann, ohne zusätzliche Verkabelung, also batteriebetrieben
Er muss durch eine einfache Berührung aktiviert werden können, also muss er aus dem Ruhemodus aufwachen
Er verbindet sich mit WLAN und ist sehr flexibel, also muss er einen ESP8266 haben!!!!!
Die endgültige Lösung wird eine kleine Batterie haben, die genauso groß ist wie der Knopf – natürlich 🙂 !!!!

Schließlich habe ich mich für folgende Komponenten entschieden:

1,8-Zoll-LCD-Bildschirm SPI-Seriellport-Modul TFT-Farbdisplay Touchscreen ST7735 (128*160) für Arduino
LOLIN D1 Mini Pro V 2.0.0 (inklusive LiPo-Ladegerät)
PIC 16LF1824, MPLAB IDE für PIC-Programmierung + Programmiergerät
Leiterplatte von Aissler, entworfen mit Fritzing
Clion und Platformio für die ESP8266-Entwicklung
Quellcode: https://github.com/happychriss/TouchSwitch

Warum war das eine kleine Herausforderung?

Nun ja… Ich habe das Display bereits zum Laufen gebracht, viele weitere Details zum Display, zur Verkabelung und zum ESP findest du HIER. Aber es verbraucht im Betrieb viel Strom, also muss es in den SCHLAFMODUS wechseln, wenn niemand das Display nutzt. Jetzt kann es an der Wand hängen und einfach warten. Sobald du es brauchst, berührst du das Display, es wacht auf und ist bereit – nach einer Weile fällt es wieder in den Tiefschlaf. Dort sollte es einige Monate durchhalten.

Es ist einfach, den ESP8266 in den Tiefschlaf zu versetzen – aber wie weckt man ihn wieder auf?

Leider habe ich im Display keine Logik gefunden, die ein „Weck“-Signal für den ESP8266 unterstützen würde. Der Ansatz ist also, den ESP8266 immer im Ruhezustand zu lassen und einen PIC-Low-Power-Mikrocontroller zu verwenden, der dem Display regelmäßig kurzzeitig Strom zuführt, um dessen Touch-Controller zu überprüfen. Wird keine Berührung gemeldet, schaltet der PIC den Strom ab und geht wieder in den Ruhezustand. Wurde eine Berührung erkannt, weckt der PIC den ESP8266 auf, versorgt das Display mit Strom und schaltet die Hintergrundbeleuchtung ein. Alles läuft wieder.

Energie sparen!

Meine ursprüngliche Idee war, den ESP8266 zu nutzen, um regelmäßig aufzuwachen und das Display zu überprüfen. Leider kann der ESP8266 den Status seiner I/Os (digitale Ein-/Ausgänge) im Tiefschlaf nicht beibehalten (ich habe ziemlich lange gebraucht, um das herauszufinden), sodass im Tiefschlaf Strom zum Display fließen würde (tatsächlich war es nicht einmal möglich, die Hintergrundbeleuchtung zu deaktivieren)… und keine Energieeinsparung.

components, on the PCB visible the PIC, still separate WEMOS

PIC 16LF1824 Low-Power-Mikrocontroller

Hier nutzt der PIC16 seine Low-Power-Funktionen, er benötigt keine weitere Hardware zum Betrieb und lässt sich einfach programmieren:

Der PIC schläft
Um das Display zu aktivieren, ist es mit einem Transistor verbunden, der das Display „erdet“, um den Stromkreis zu schließen.
Sobald dies geschehen ist, zieht er die Hintergrundbeleuchtung herunter (damit sie deaktiviert bleibt) und überprüft den „Touch-IRQ“-Pin des Displays.
Erst wenn eine Berührung erkannt wird, zieht er den RST-Pin auf Masse, sodass der ESP8266 aufwacht. Das Schöne an einem PIC ist, dass er den IO-Status während des Ruhezustands beibehält.

Ich poste diesen Auszug, um zu zeigen, wie einfach sich der PIC für solche Aufgaben einsetzen lässt:

 while (1)
    {
        WDTCONbits.SWDTEN = 0b1;
        SLEEP(); // sleep for watchdog sleep time 1.3 sec
        WDTCONbits.SWDTEN = 0b0;
       
        pen_pressed=false;
      
        //Enable the display (without backlight) to measure if touched 
        IO_RC4_TFT_BKL_OUT_SetLow();
        IO_RC3_TFT_PWR_OUT_SetHigh();  
        
        __delay_ms(40); //time needs the TFT to boot
                
        PEN_value=IO_RC5_TFT_PEN_IN_GetValue()  ;

        // Pen is pressed *** Wake up display
        if (PEN_value==0) {
         
            pen_pressed=true;

            IO_RC0_ESP_RST_OUT_SetLow(); 
            __delay_ms(10);
            IO_RC0_ESP_RST_OUT_SetHigh(); 
            
            // enable TFT backlight
            __delay_ms(600); //give the ESP time to wake up
            IO_RC4_TFT_BKL_OUT_SetHigh();
        }

        // check, if the ESP allows me to sleep again
        if (pen_pressed) {
            do {
                __delay_ms(500);
                SLEEP_value=IO_RC1_ESP_SLEEP_IN_GetValue() ;
            }
            while (SLEEP_value!=0);
        }

        // Go back to sleep
        IO_RC2_TST_OUT_SetLow();
        IO_RC3_TFT_PWR_OUT_SetLow();
        IO_RC4_TFT_BKL_OUT_SetLow() ;
        
    }
}

ESP8266-Programmierung

Nach dem Aufwachen durch den PIC übernimmt der ESP die Steuerung des Displays und verbindet sich über WLAN mit dem SmartHome-Server / DocBox-Server – um sich zu registrieren. Das ist nichts Besonderes. Aber ich wollte ein System einrichten können, das Menüs und Untermenüs anzeigt, also habe ich den folgenden Ansatz mit der AdafruitGFX-Button-Bibliothek und einem „button-press-handler“ entwickelt, wie unten gezeigt – nach der Definition der Tasten wird jede Taste einem „Handler“ (https://github.com/happychriss/TouchSwitch/blob/master/src/tft_helper.cpp), der aufgerufen wird, wenn die Taste gedrückt wird. Wenn jedes „Untermenü“ in einer eigenen C-Datei untergebracht ist, ergibt sich ein sehr modulares und strukturiertes Ergebnis.

uint main_menu() {

    //****** Paint the Display ************************************************

    DPL("**** Paint Main-Menu Display");

    tft.fillScreen(ST7735_WHITE);

    enum M1 {
        B_SCAN = 0, B_COPY = 1, B_HOME = 2, B_STATUS = 3
    };

    Adafruit_GFX_Button buttons[4];
    buttons[B_SCAN].initButtonUL(&tft, B_X_SPACE, B_Y_SPACE, B_X_WIDTH, B_Y_HEIGHT, C_BUTTON, C_BACK, C_TEXT, "SCAN", 1);
    buttons[B_COPY].initButtonUL(&tft, B_X_SPACE + (X_MAX / 2), B_Y_SPACE, B_X_WIDTH, B_Y_HEIGHT, C_BUTTON, C_BACK, C_TEXT, "COPY", 1);
    buttons[B_HOME].initButtonUL(&tft, B_X_SPACE, (Y_MAX / 2) + B_Y_SPACE, B_X_WIDTH, B_Y_HEIGHT, C_BUTTON, C_BACK, C_TEXT, "STATUS", 1);
    buttons[B_STATUS].initButtonUL(&tft, (X_MAX / 2) + B_X_SPACE, (Y_MAX / 2) + B_Y_SPACE, B_X_WIDTH, B_Y_HEIGHT, C_BUTTON, C_BACK, C_TEXT, "MORE", 1);

    for (int i = B_SCAN; i <= B_STATUS; i++) {
        buttons[i].drawButton();
        buttons[i].press(false);
    }

    global_status = GLOBAL_ACTION_MAIN_MENU;
    struct _button_handler buttonHandler[4];
    buttonHandler[0].button_action = menu_start_scanner;
    buttonHandler[1].button_action = menu_start_copy;
    buttonHandler[2].button_action = menu_start_test;
    buttonHandler[3].button_action = menu_start_more;

    return HandleButtons(buttons, 4, buttonHandler, TOUCH_SECONDS_WAIT);

Es braucht eine Leiterplatte

Schließlich wurde mir klar, dass das ein bisschen Verdrahtung erfordern würde, also habe ich meine zweite Leiterplatte mit Fritzing entworfen und direkt über Aisler bestellt, ein deutsches Unternehmen für Rapid Prototyping. Ich war sehr positiv überrascht vom günstigen Preis und der schnellen Lieferung. Es ist so viel einfacher, die Leiterplatte zu entwerfen, als die ganze Verdrahtung selbst zu machen. Hier sind die Ergebnisse.

Breadboard Layout – the pins at the bottom are to connect the display (wiring, see separate post)

PCB Layout (2 level) – needed one wiring

Alles zusammengebaut … immer noch winzig!

Insgesamt besteht das System aus folgenden Komponenten: TFT-Display, ESP8266, PIC und Akku – und sollte trotzdem noch winzig sein. Ich habe viel mit verschiedenen Layouts herumexperimentiert – das war das Ergebnis. Schließlich (natürlich) muss noch der Akku hinzugefügt werden. Bei der Wahl des ESP habe ich mich für den Wemos Mini entschieden, der mit einem integrierten LiPo-Akku und LiPo-Ladegerät geliefert wird.

Full tiny switch build together, TFT on top

Wemos-1 with PCI16 on the PCB, the FTF is put on top.

Was kommt als Nächstes?

Es braucht ein Gehäuse 🙂