marvin.herold/EdSaGfmvA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixing OLED

Browse Source
This commit is contained in:
maroh94 2025-06-29 20:34:53 +02:00
parent 4a03e2f924
commit 18304e9346
5 changed files with 61 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
boards/nucleo_wl55jc.overlay
View File

@ -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";
};
};

3
include/oled/oled.h
View File

@ -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

7
prj.conf
View File

@ -1,9 +1,12 @@
CONFIG_DISPLAY=y
CONFIG_SSD16XX=y
# --- Grundlagen für Ihren manuellen Treiber ---
# 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

2
src/main.c
View File

@ -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"

106
src/oled/oled.c
View File

@ -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, // WICHTIG: Keine CS-Steuerung durch den Treiber
.cs = NULL,
};
// GPIO Makros: Manuelle Kontrolle reaktiviert
#define OLED_CS_ENABLE gpio_pin_set_dt(&oled_cs, 1) // Aktiv (LOW)
#define OLED_CS_DISABLE gpio_pin_set_dt(&oled_cs, 0) // Inaktiv (HIGH)
// --- Raw GPIO Control ---
// Wir ignorieren jetzt die ACTIVE_LOW/HIGH Flags und steuern die Spannung direkt.
// Das ist der ultimative Test.
#define OLED_DC_COMMAND gpio_pin_set_dt(&oled_dc, 0) // LOW für Befehle
#define OLED_DC_DATA gpio_pin_set_dt(&oled_dc, 1) // HIGH für Daten
// Für CS (soll bei Aktivierung LOW sein)
#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...\n");
printk("OLED Init (Raw-Modus)...\n");
if (!device_is_ready(spi_dev)) {
printk("FATAL: SPI-Gerät nicht bereit!\n");
return;
printk("FATAL: SPI-Gerät nicht bereit!\n"); 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
ret = gpio_pin_configure_dt(&oled_cs, GPIO_OUTPUT);
if (ret != 0) {
printk("FEHLER %d: Konnte CS-Pin nicht konfigurieren\n", ret);
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");
printk("Konfiguriere Pins für Raw-Output...\n");
gpio_pin_configure_dt(&oled_cs, GPIO_OUTPUT_INACTIVE);
gpio_pin_configure_dt(&oled_dc, GPIO_OUTPUT_INACTIVE);
gpio_pin_configure_dt(&oled_reset, GPIO_OUTPUT_INACTIVE);
// 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
while(1) {
k_sleep(K_SECONDS(10));
}
}
printk("Display initialisiert. Fülle jetzt den Bildschirm weiß...\n");
OLED_WhiteScreen_White();
printk("Display-Finish! Der Bildschirm sollte jetzt weiß sein.\n");
}