Ein Display für den Kalender

;; cyd-export.el - Automatischer Export für das ESP32-Display
(require 'json)
(require 'org)
(require 'org-agenda)
(require 'subr-x)

;; --- HIER DIE PFADE AUF DEM PI ANPASSEN ---
(setq org-agenda-files '("/home/benutzer/Agenda.org"))
(defvar cyd-json-zielpfad "/home/benutzer/html/agenda.json")
;; ------------------------------------------

(defun bereinige-esp32-text (text)
  (let* ((s1 (replace-regexp-in-string "[ \t]+:[[:alnum:]_@]+:[ \t]*$" "" text))
         (s2 (replace-regexp-in-string "ä" "ae" s1 t t))
         (s3 (replace-regexp-in-string "ö" "oe" s2 t t))
         (s4 (replace-regexp-in-string "ü" "ue" s3 t t))
         (s5 (replace-regexp-in-string "Ä" "AE" s4 t t))
         (s6 (replace-regexp-in-string "Ö" "OE" s5 t t))
         (s7 (replace-regexp-in-string "Ü" "UE" s6 t t))
         (s8 (replace-regexp-in-string "ß" "ss" s7 t t))
         (s9 (replace-regexp-in-string "[^[:ascii:]]" "" s8)))
    (string-trim s9)))

(defun hole-termine-fuer-tag (tage-in-zukunft)
  (let* ((zeit (time-add (current-time) (days-to-time tage-in-zukunft)))
         (datum (list (nth 4 (decode-time zeit))
                      (nth 3 (decode-time zeit))
                      (nth 5 (decode-time zeit))))
         (tages-termine nil))
    (dolist (datei (org-agenda-files))
      ;; Sicherstellen, dass wir nur echte Org-Dateien prüfen
      (when (string-match "\\.org$" datei)
        (let ((eintraege (org-agenda-get-day-entries datei datum :timestamp)))
          (dolist (eintrag eintraege)
            (let ((text (get-text-property 0 'txt eintrag))
                  (uhrzeit (get-text-property 0 'time eintrag)))
              (when text
                (let* ((sauberer-text (bereinige-esp32-text (substring-no-properties text)))
                       (anzeige-text (if (and (stringp uhrzeit) (not (string-empty-p uhrzeit)))
                                         (concat (string-trim (substring-no-properties uhrzeit)) " " sauberer-text)
                                       sauberer-text)))
                  (push (list (cons "titel" anzeige-text)) tages-termine))))))))
    tages-termine))

(defun starte-cyd-export-prozess ()
  (let ((meine-todos nil)
        (heute (hole-termine-fuer-tag 0))
        (morgen (hole-termine-fuer-tag 1))
        (uebermorgen (hole-termine-fuer-tag 2)))

    ;; TODOs aus den konfigurierten Agenda-Dateien sammeln
    (org-map-entries
     (lambda ()
       (let ((titel (org-get-heading t t t t)))
         (push (list (cons "titel" (bereinige-esp32-text titel))) meine-todos)))
     "/+TODO" 'agenda)

    ;; NEU: Wir drehen alle Listen mit 'nreverse' um, damit die Reihenfolge
    ;; exakt deiner Org-Datei und der chronologischen Uhrzeit entspricht.
    (let ((json-daten (list (cons "todos" (nreverse meine-todos))
                            (cons "heute" (nreverse heute))
                            (cons "morgen" (nreverse morgen))
                            (cons "uebermorgen" (nreverse uebermorgen)))))
      (with-temp-file cyd-json-zielpfad
        (insert (json-encode json-daten))))))

;; Das Skript sofort ausführen, wenn es geladen wird
(starte-cyd-export-prozess)

  {
  "todos": [
    {
      "titel": "Unbeaufsichtigte Updates einrichten"
    },
    {
      "titel": "Vorbereitung CoS"
    },
    {
      "titel": "Vorbereitung DoIP"
    },
    {
      "titel": "Balkonkasten schick machen"
    },
    {
      "titel": "For all Mankind vom FTP laden"
    },
    {
      "titel": "Keller aufraeumen"
    },
    {
      "titel": "Emacs-Agenda per Caldav syncen"
    },
    {
      "titel": "Prots default pruefen"
    },
    {
      "titel": "Fett und oel fuer 3D Drucker besorgen"
    },
    {
      "titel": "Groesseren V-Server bestellen und Dienste migrieren"
    }
  ],
  "heute": [
    {
      "titel": "Pfingsten"
    }
  ],
  "morgen": [
    {
      "titel": "Pfingsten"
    },
    {
      "titel": "19:30-22:00 Spielrunde DoIP"
    }
  ],
  "uebermorgen": null
}

0 */6 * * * /usr/bin/emacs --batch -l /home/benutzer/cyd-export.el

sudo usermod -aG dialout $USER

#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <TFT_eSPI.h>
#include <SPI.h>
#include <XPT2046_Touchscreen.h>
#include "time.h"

// --- HIER DEINE DATEN EINTRAGEN ---
const char* ssid = "WIFINAME";
const char* password = "WIFI-PASSWORT";
const char* json_url = "http://url/agenda.json";  // Pfad auf dem Pi
// ----------------------------------

// C64-spezifische Farbwerte
#define C64_DARK_BLUE 0x0011
#define C64_LIGHT_BLUE 0xA51F
#define DARKMODE_BG TFT_BLACK
#define DARKMODE_TEXT TFT_CYAN

// Anschlüsse für Touch auf CYD-Board
#define XPT2046_IRQ 36
#define XPT2046_MOSI 32
#define XPT2046_MISO 39
#define XPT2046_CLK 25
#define XPT2046_CS 33

SPIClass touchSPI(VSPI);
XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);
TFT_eSPI tft = TFT_eSPI();

int aktuelleAnsicht = 0;
int aktuelleSeite = 0;  // NEU: Merkt sich, auf welcher Unterseite wir sind
String aktuelleDaten = "";
unsigned long letzterAbruf = 0;
bool isDarkMode = false;
int letzteMinute = -1;

// Helligkeit
const int MIN_HELLIGKEIT = 5;
const int MAX_HELLIGKEIT = 150;
int aktuelleHelligkeit = MAX_HELLIGKEIT;

// --- THEMES ---
struct Theme {
  String name;
  uint16_t bgColor;
  uint16_t textColor;
};

const Theme themes[] = {
  { "C64 BASIC", 0x0011, 0xA51F },           // Klassisches C64 Blau
  { "MAINFRAME", TFT_BLACK, TFT_GREEN },     // Grüner Phosphor
  { "BERNSTEIN", TFT_BLACK, 0xFD20 },        // Warmes Terminal-Orange
  { "NORTON DOS", TFT_BLUE, TFT_YELLOW },    // Blau mit kräftigem Gelb
  { "DARKMODE", TFT_BLACK, TFT_CYAN },       // Schwarz mit Cyan
  { "DOS", TFT_BLACK, TFT_LIGHTGREY}         // DOS
};
const int anzahlThemes = 6;

int aktuellesTheme = 0;     // Startet mit C64
bool imThemeMenue = false;  // Status: Sind wir auf der Agenda oder im Menü?


void setup() {
  Serial.begin(115200);

  pinMode(21, OUTPUT);

  tft.init();
  tft.invertDisplay(true);
  tft.setRotation(1);
  tft.setTextSize(2);
  tft.fillScreen(C64_DARK_BLUE);

  touchSPI.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
  ts.begin(touchSPI);
  ts.setRotation(1);

  tft.setTextColor(C64_LIGHT_BLUE, C64_DARK_BLUE);
  tft.drawString("COMMODORE 64 BASIC V2", 10, 10, 1);
  tft.drawString("VERBINDE W-LAN...", 10, 30, 1);

  // NEU: Dem ESP32 einen eigenen Namen für den Router geben
  WiFi.setHostname("skynet-agenda");

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) { delay(500); }

  // Automatische Sommer-/Winterzeit für Deutschland (MEZ/MESZ)
  configTzTime("CET-1CEST,M3.5.0,M10.5.0/3", "pool.ntp.org");

  datenAbrufen();
  bildschirmZeichnen();
}

void loop() {
  // 1. Automatische Aktualisierung & Auto-Rücksprung alle 5 Min.
  if (millis() - letzterAbruf > 300000) {
    //fadeAus(); // Falls du das Dimm-Feature beim Laden nutzen willst
    datenAbrufen();

    aktuelleAnsicht = 0;  // Zurück zur Kategorie "HEUTE"
    aktuelleSeite = 0;    // Zurück auf die erste Seite

    bildschirmZeichnen();
    //fadeEin();
    letzterAbruf = millis();
  }

  // 2. Uhrzeit-Ecke minütlich aktualisieren
  struct tm timeinfo;
  if (getLocalTime(&timeinfo)) {
    if (timeinfo.tm_min != letzteMinute) {
      zeichneKopfzeile();
    }
  }

  // 3. Touch-Steuerung mit Ghost-Touch-Filter
  if (ts.touched()) {
    TS_Point p = ts.getPoint();

    // Nur echte Berührungen (Z-Wert) durchlassen
    if (p.z > 500) {

      // A. Zuerst prüfen: Wurde die untere rechte Ecke (Stern / Zurück) getippt?
      if (p.x > 2500 && p.y > 2500) {
        imThemeMenue = !imThemeMenue;  // Menü auf oder zu
        bildschirmZeichnen();
        delay(300);
        return;  // Bricht ab und startet die loop() sofort frisch
      }

      // B. Was passiert bei einem normalen Tipp auf den Bildschirm?
      if (imThemeMenue) {
        // Im Menü: Ein Tipp irgendwo anders schaltet das Theme durch (Live-Vorschau)
        aktuellesTheme++;
        if (aktuellesTheme >= anzahlThemes) aktuellesTheme = 0;
      } else {
        // In der Agenda: Deine originale Logik zum Blättern nach Links oder Rechts
        if (p.x < 1500 || p.x > 2500) {
          JsonDocument doc;
          int maxSeitenAktuell = 1;
          bool datenGelesen = false;

          // Kurz nachschauen, wie viele Seiten die aktuelle Ansicht hat
          if (aktuelleDaten != "" && !deserializeJson(doc, aktuelleDaten)) {
            datenGelesen = true;
            String jsonKeys[] = {"heute", "morgen", "uebermorgen", "todos"};
            int anzahlElemente = doc[jsonKeys[aktuelleAnsicht]].size();
            maxSeitenAktuell = (anzahlElemente == 0) ? 1 : ((anzahlElemente - 1) / 9) + 1;
          }

          if (p.x < 1500) {
            // Nach Links tippen (zurück)
            if (aktuelleSeite > 0) {
              aktuelleSeite--;
            } else {
              aktuelleAnsicht--;
              if (aktuelleAnsicht < 0) aktuelleAnsicht = 3;
              if (datenGelesen) {
                String jsonKeys[] = {"heute", "morgen", "uebermorgen", "todos"};
                int anzahlNeu = doc[jsonKeys[aktuelleAnsicht]].size();
                aktuelleSeite = (anzahlNeu == 0) ? 0 : ((anzahlNeu - 1) / 9);
              } else {
                aktuelleSeite = 0;
              }
            }
          } else if (p.x > 2500) {
            // Nach Rechts tippen (vorwärts)
            aktuelleSeite++;
            if (aktuelleSeite >= maxSeitenAktuell) {
              aktuelleSeite = 0;
              aktuelleAnsicht++;
              if (aktuelleAnsicht > 3) aktuelleAnsicht = 0;
            }
          }
        }
      }

      bildschirmZeichnen();
      delay(300);
    }
  }
}

void zeichneKopfzeile() {
  uint16_t bgColor = themes[aktuellesTheme].bgColor;
  uint16_t textColor = themes[aktuellesTheme].textColor;

  tft.setTextColor(textColor, bgColor);
  tft.setTextSize(2);

  struct tm timeinfo;
  if (getLocalTime(&timeinfo)) {

    // 1. Hintergrundbeleuchtung dimmen (Passiert immer im Hintergrund)
    if (timeinfo.tm_hour >= 22 || timeinfo.tm_hour < 6) {
      aktuelleHelligkeit = MIN_HELLIGKEIT;
    } else {
      aktuelleHelligkeit = MAX_HELLIGKEIT;
    }

    // 2. Zeitstempel je nach Ansicht formatieren
    char timeString[20];
    if (aktuelleAnsicht == 0) {
      // Auf der "Heute"-Seite: Datum und Uhrzeit (z.B. "23.05.2026 14:38")
      strftime(timeString, sizeof(timeString), "%d.%m.%Y %H:%M", &timeinfo);
    } else {
      // Auf allen anderen Seiten: Nur die Uhrzeit (z.B. "14:38")
      strftime(timeString, sizeof(timeString), "%H:%M", &timeinfo);
    }

    // Text rechtsbündig an Position 310 ausgeben
    tft.drawRightString(timeString, 310, 10, 1);

    letzteMinute = timeinfo.tm_min;
  }
}

void datenAbrufen() {
  if (WiFi.status() == WL_CONNECTED) {
    HTTPClient http;
    http.begin(json_url);
    int httpCode = http.GET();
    if (httpCode == 200) {
      aktuelleDaten = http.getString();
    }
    http.end();
  }
}

void bildschirmZeichnen() {
  uint16_t bgColor = themes[aktuellesTheme].bgColor;
  uint16_t textColor = themes[aktuellesTheme].textColor;

  tft.fillScreen(bgColor);
  tft.setTextColor(textColor, bgColor);
  tft.setTextSize(2);
  tft.setTextWrap(false);  // Tippanimation erzeugt sonst Zeilenumbrüche

  zeichneKopfzeile();

  if (imThemeMenue) {
    // --- THEME-MENÜ ZEICHNEN ---
    tft.drawString("THEMES", 10, 10, 1);
    tft.drawLine(10, 28, 310, 28, textColor);

    int yPosition = 40;
    for (int i = 0; i < anzahlThemes; i++) {
      // Setzt einen fetten Pfeil vor das aktive Theme
      String zeile = (i == aktuellesTheme) ? "> " : "- ";
      zeile += themes[i].name;

      tft.setCursor(10, yPosition);
      tft.print(zeile);  // Wir printen im Menü sofort (ohne Delay), damit der Live-Wechsel flüssig ist
      yPosition += 18;
    }

  } else {
    String kategorien[] = { "HEUTE", "MORGEN", "UEBERMORGEN", "OFFENE TODOs" };
    String headerTitel = kategorien[aktuelleAnsicht];

    if (aktuelleDaten == "") {
      tft.drawString(headerTitel, 10, 10, 1);
      tft.drawLine(10, 28, 310, 28, textColor);
      tft.drawString("WARTE AUF DATEN...", 10, 40, 1);
    } else {
      JsonDocument doc;
      DeserializationError fehler = deserializeJson(doc, aktuelleDaten);

      if (!fehler) {
        String jsonKeys[] = { "heute", "morgen", "uebermorgen", "todos" };
        JsonArray liste = doc[jsonKeys[aktuelleAnsicht]];

        int totalItems = liste.size();
        int maxSeiten = (totalItems == 0) ? 1 : ((totalItems - 1) / 9) + 1;
        if (aktuelleSeite >= maxSeiten) aktuelleSeite = maxSeiten - 1;

        if (maxSeiten > 1) {
          headerTitel += " (" + String(aktuelleSeite + 1) + "/" + String(maxSeiten) + ")";
        }

        tft.drawString(headerTitel, 10, 10, 1);
        tft.drawLine(10, 28, 310, 28, textColor);

        int startIdx = aktuelleSeite * 9;
        int endIdx = startIdx + 9;
        int index = 0;
        int yPosition = 40;

        for (JsonObject eintrag : liste) {
          if (index >= startIdx && index < endIdx) {
            String text = eintrag["titel"];
            text.toUpperCase();

            // NEU: Die Länge etwas schärfer abschneiden (23 statt 25),
            // damit es inklusive dem "- " exakt in die 320 Pixel der Breite passt.
            if (text.length() > 23) {
              text = text.substring(0, 20) + "...";
            }

            tft.setCursor(10, yPosition);
            String zeile = "- " + text;

            for (int i = 0; i < zeile.length(); i++) {
              tft.print(zeile[i]);
              delay(5);
            }

            yPosition += 18;
          }
          index++;
        }
      } else {
        tft.drawString(headerTitel, 10, 10, 1);
        tft.drawLine(10, 28, 310, 28, textColor);
        tft.drawString("FEHLER BEIM LESEN", 10, 40, 1);
      }
    }
  }
  tft.drawString("READY.", 10, 210, 1);
  tft.fillRect(100, 210, 15, 15, textColor);

  // Dynamischer Button unten rechts
  if (imThemeMenue) {
    tft.drawString("<-", 290, 210, 1);  // Zurück-Pfeil im Menü
  } else {
    tft.drawString("*", 300, 210, 1);  // Stern in der Agenda
  }
}

void fadeAus() {
  // Dimmt das Display in kleinen Schritten von 200 auf 0 (aus)
  for (int i = aktuelleHelligkeit; i >= 0; i -= 5) {
    analogWrite(21, i);
    delay(15);  // Je höher der Delay, desto langsamer das Dimmen
  }
}

void fadeEin() {
  // Erhellt das Display sanft wieder auf unseren Zielwert 200
  for (int i = 0; i <= aktuelleHelligkeit; i += 5) {
    analogWrite(21, i);
    delay(15);
  }
}