Fixing OLED

boards/nucleo_wl55jc.overlay

@@ -33,6 +33,6 @@
         dc-gpios = <&gpiob 8 GPIO_ACTIVE_HIGH>;
         reset-gpios = <&gpioc 1 GPIO_ACTIVE_LOW>;
         cs-gpios = <&gpiob 10 GPIO_ACTIVE_LOW>;
-        label = "OLED";
+        label = "oled";
     };
 };

include/oled/oled.h

@@ -11,4 +11,7 @@
 #define BYTES_PER_LINE 16                    //    ((WIDTH + 7) / 8)
 #define ALLSCREEN_GRAGHBYTES 1024           //(BYTES_PER_LINE * HEIGHT)
 
+
+void oled_draw_something(char toDraw);
+
 #endif

prj.conf

@@ -1,9 +1,12 @@
-CONFIG_DISPLAY=y
+# --- Grundlagen für Ihren manuellen Treiber ---
-CONFIG_SSD16XX=y
+# Das ist alles, was Ihr Code wirklich benötigt.
 CONFIG_SPI=y
 CONFIG_GPIO=y
+CONFIG_PRINTK=y
 
+# --- LoRa Konfiguration (unverändert) ---
 CONFIG_LORA=y
 CONFIG_LORA_SHELL=y
 
+# --- Stack Size (unverändert) ---
 CONFIG_MAIN_STACK_SIZE=2048

src/main.c

@@ -2,7 +2,7 @@
 #include <zephyr/kernel.h>
 #include <zephyr/sys/printk.h>
 
-#include "epaper/epaper.h"
+//#include "epaper/epaper.h"
 #include "oled/oled.h"
 
 #include "utils/buttons.h"

src/oled/oled.c

@@ -2,7 +2,6 @@
 #include <zephyr/device.h>
 #include <zephyr/drivers/spi.h>
 #include <zephyr/drivers/gpio.h>
-#include <zephyr/drivers/display.h>
 #include <zephyr/sys/printk.h>
 
 #include "oled/oled.h"
@@ -10,30 +9,35 @@
 #define OLED_NODE DT_NODELABEL(oled)
 #define SPI_BUS   DT_BUS(OLED_NODE)
 
-// GPIOs - JETZT WIEDER MIT CS-PIN
+// GPIOs
 static const struct gpio_dt_spec oled_cs    = GPIO_DT_SPEC_GET(OLED_NODE, cs_gpios);
 static const struct gpio_dt_spec oled_dc    = GPIO_DT_SPEC_GET(OLED_NODE, dc_gpios);
 static const struct gpio_dt_spec oled_reset = GPIO_DT_SPEC_GET(OLED_NODE, reset_gpios);
 
 // SPI
-// Wir verwenden hier nicht mehr SPI_DT_SPEC_GET, da wir CS manuell steuern
 static const struct device *spi_dev = DEVICE_DT_GET(SPI_BUS);
 static struct spi_config spi_cfg = {
     .frequency = 2000000,
     .operation = SPI_WORD_SET(8) | SPI_TRANSFER_MSB | SPI_OP_MODE_MASTER,
-    .slave = 0, // Nicht relevant für Master
+    .cs = NULL,
-    .cs = NULL, // WICHTIG: Keine CS-Steuerung durch den Treiber
 };
 
-// GPIO Makros: Manuelle Kontrolle reaktiviert
+// --- Raw GPIO Control ---
-#define OLED_CS_ENABLE  gpio_pin_set_dt(&oled_cs, 1) // Aktiv (LOW)
+// Wir ignorieren jetzt die ACTIVE_LOW/HIGH Flags und steuern die Spannung direkt.
-#define OLED_CS_DISABLE gpio_pin_set_dt(&oled_cs, 0) // Inaktiv (HIGH)
+// Das ist der ultimative Test.
 
-#define OLED_DC_COMMAND gpio_pin_set_dt(&oled_dc, 0) // LOW für Befehle
+// Für CS (soll bei Aktivierung LOW sein)
-#define OLED_DC_DATA    gpio_pin_set_dt(&oled_dc, 1) // HIGH für Daten
+#define OLED_CS_ENABLE  gpio_pin_set_raw(oled_cs.port, oled_cs.pin, 0)
+#define OLED_CS_DISABLE gpio_pin_set_raw(oled_cs.port, oled_cs.pin, 1)
+
+// Für DC (soll bei Daten HIGH sein)
+#define OLED_DC_COMMAND gpio_pin_set_raw(oled_dc.port, oled_dc.pin, 0)
+#define OLED_DC_DATA    gpio_pin_set_raw(oled_dc.port, oled_dc.pin, 1)
+
+// Für RST (soll bei Reset LOW sein)
+#define OLED_RST_ASSERT   gpio_pin_set_raw(oled_reset.port, oled_reset.pin, 0)
+#define OLED_RST_DEASSERT gpio_pin_set_raw(oled_reset.port, oled_reset.pin, 1)
 
-#define OLED_RST_ASSERT   gpio_pin_set_dt(&oled_reset, 1) // Aktiv (LOW)
-#define OLED_RST_DEASSERT gpio_pin_set_dt(&oled_reset, 0) // Inaktiv (HIGH)
 
 void oled_driver_delay_xms(uint32_t ms) {
     k_msleep(ms);
@@ -48,32 +52,28 @@ void OLED_Spi_WriteBuffer(uint8_t *data, size_t len) {
 void OLED_Write_Command(uint8_t cmd) {
     OLED_DC_COMMAND;
     OLED_CS_ENABLE;
-    oled_driver_delay_xms(1); // Paranoid-Delay
     OLED_Spi_WriteBuffer(&cmd, 1);
     OLED_CS_DISABLE;
-    oled_driver_delay_xms(1); // Paranoid-Delay
 }
 
 void OLED_Write_Data(uint8_t *data, size_t len) {
     OLED_DC_DATA;
     OLED_CS_ENABLE;
-    oled_driver_delay_xms(1); // Paranoid-Delay
     OLED_Spi_WriteBuffer(data, len);
     OLED_CS_DISABLE;
-    oled_driver_delay_xms(1); // Paranoid-Delay
 }
 
 void OLED_Reset(void) {
-    printk("Führe Hardware-Reset durch...\n");
+    printk("Führe Hardware-Reset durch (Raw-Modus)...\n");
     OLED_RST_ASSERT;
-    oled_driver_delay_xms(20);
+    oled_driver_delay_xms(50);
     OLED_RST_DEASSERT;
     oled_driver_delay_xms(100);
 }
 
 void OLED_HW_Init(void) {
     OLED_Reset();
-    printk("Sende Initialisierungssequenz...\n");
+    printk("Sende Initialisierungssequenz (Raw-Modus)...\n");
     OLED_Write_Command(0xAE); // Display OFF
     OLED_Write_Command(0xD5); OLED_Write_Command(0x80); // Set Clock
     OLED_Write_Command(0xA8); OLED_Write_Command(0x3F); // Set MUX
@@ -90,53 +90,49 @@ void OLED_HW_Init(void) {
     OLED_Write_Command(0xA4); // Display ON from RAM
     OLED_Write_Command(0xA6); // Normal Display
     OLED_Write_Command(0xAF); // Display ON in normal mode
-    printk("Initialisierung gesendet.\n");
+    printk("Initialisierung gesendet (Raw-Modus).\n");
 }
 
+void OLED_WhiteScreen_White(void) {
+    uint8_t buffer[128];
+    memset(buffer, 0xFF, sizeof(buffer)); // Alles auf 1 setzen für Weiß
+    for (uint8_t page = 0; page < 8; page++) {
+        OLED_Write_Command(0xB0 + page);      // Set Page Address
+        OLED_Write_Command(0x00);             // Lower column start address
+        OLED_Write_Command(0x10);             // Higher column start address
+        OLED_Write_Data(buffer, sizeof(buffer));
+    }
+}
 
 void oled_draw_something(char toDraw) {
-    int ret;
+    printk("OLED Init (Raw-Modus)...\n");
-    printk("OLED Init...\n");
 
     if (!device_is_ready(spi_dev)) {
-        printk("FATAL: SPI-Gerät nicht bereit!\n");
+        printk("FATAL: SPI-Gerät nicht bereit!\n"); return;
-        return;
+    }
+    if (!device_is_ready(oled_cs.port)) {
+        printk("FATAL: CS GPIO Port nicht bereit!\n"); return;
+    }
+    if (!device_is_ready(oled_dc.port)) {
+        printk("FATAL: DC GPIO Port nicht bereit!\n"); return;
+    }
+    if (!device_is_ready(oled_reset.port)) {
+        printk("FATAL: RESET GPIO Port nicht bereit!\n"); return;
     }
 
-    // Konfiguriere jeden Pin und prüfe das Ergebnis
+    printk("Konfiguriere Pins für Raw-Output...\n");
-    ret = gpio_pin_configure_dt(&oled_cs, GPIO_OUTPUT);
+    gpio_pin_configure_dt(&oled_cs, GPIO_OUTPUT_INACTIVE);
-    if (ret != 0) {
+    gpio_pin_configure_dt(&oled_dc, GPIO_OUTPUT_INACTIVE);
-        printk("FEHLER %d: Konnte CS-Pin nicht konfigurieren\n", ret);
+    gpio_pin_configure_dt(&oled_reset, GPIO_OUTPUT_INACTIVE);
-        return;
-    }
-
-    ret = gpio_pin_configure_dt(&oled_dc, GPIO_OUTPUT);
-    if (ret != 0) {
-        printk("FEHLER %d: Konnte DC-Pin nicht konfigurieren\n", ret);
-        return;
-    }
-
-    ret = gpio_pin_configure_dt(&oled_reset, GPIO_OUTPUT);
-    if (ret != 0) {
-        printk("FEHLER %d: Konnte RESET-Pin nicht konfigurieren\n", ret);
-        return;
-    }
-    printk("Alle GPIOs erfolgreich konfiguriert.\n");
     
-    // Pins explizit in den inaktiven Startzustand versetzen
-    gpio_pin_set_dt(&oled_cs, 0);
-    gpio_pin_set_dt(&oled_dc, 0);
-    gpio_pin_set_dt(&oled_reset, 0);
-
-
     k_msleep(100);
 
     OLED_HW_Init();
 
-    printk("Display sollte jetzt initialisiert und AN sein. Stoppe hier.\n");
+    k_msleep(100); // Kleiner Delay nach der Initialisierung
 
-    // Endlosschleife, um zu verhindern, dass das Programm endet
+    printk("Display initialisiert. Fülle jetzt den Bildschirm weiß...\n");
-    while(1) {
+    OLED_WhiteScreen_White();
-        k_sleep(K_SECONDS(10));
+
-    }
+    printk("Display-Finish! Der Bildschirm sollte jetzt weiß sein.\n");
-}
+}