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

Cleaning Up etc

Browse Source
This commit is contained in:
maroh94 2025-10-08 23:10:12 +02:00
parent e64477b9f0
commit 85d543d65e
13 changed files with 287 additions and 263 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/epaper/epaper.h
View File

@ -16,7 +16,7 @@ void epd_init(void);
void epd_update(void); void epd_update(void);
void epd_clear_black(void); void epd_clear_black(void);
void epd_clear_white(void); void epd_clear();
void epd_display_buffer(const unsigned char *buffer); void epd_display_buffer(const unsigned char *buffer);
void epd_draw_something(char toDraw); void epd_draw_something(char toDraw);

4
include/lora/encryption.h
View File

@ -6,7 +6,7 @@
extern const uint8_t XOR_KEY; extern const uint8_t XOR_KEY;
void xorCrypt(const char *input, char *output, uint8_t key); size_t xorCryptBytes(const uint8_t *in, uint8_t *out, size_t len, uint8_t key);
uint16_t computeCRC16(const char *data); uint16_t computeCRC16(const uint8_t *data, size_t len);
#endif #endif

8
include/lora/lorapacket.h
View File

@ -3,9 +3,13 @@
#include <stdint.h> #include <stdint.h>
#define MAX_MSG 64
typedef struct { typedef struct {
char message[20]; uint16_t len; // Länge der Nutzdaten
uint32_t timestamp; uint16_t crc; // CRC über message[0..len-1]
uint32_t timestamp; // z.B. Restzeit / Marker
uint8_t message[MAX_MSG];
} __attribute__((packed)) DataPacket; } __attribute__((packed)) DataPacket;
#endif // LORA_PACKET_H #endif // LORA_PACKET_H

1
include/lora/synch.h
View File

@ -5,7 +5,6 @@
#define MAX_SAMPLES 10 #define MAX_SAMPLES 10
// Vorwärtsdeklarationen
void synchronite(struct k_work *work); void synchronite(struct k_work *work);
#endif #endif

4
include/oled/font.h
View File

@ -5,8 +5,7 @@
#include <stdint.h> #include <stdint.h>
// Deklarationen der Bitmaps mit 'extern' // Deklarationen der Bitmaps
// 'extern' sagt dem Compiler: "Diese Variable existiert, aber sie ist in einer anderen .c-Datei definiert."
extern const uint8_t oled_fullscreen_A[]; extern const uint8_t oled_fullscreen_A[];
extern const uint8_t oled_fullscreen_B[]; extern const uint8_t oled_fullscreen_B[];
extern const uint8_t oled_fullscreen_C[]; extern const uint8_t oled_fullscreen_C[];
@ -34,7 +33,6 @@ extern const uint8_t oled_fullscreen_Y[];
extern const uint8_t oled_fullscreen_X[]; extern const uint8_t oled_fullscreen_X[];
extern const uint8_t oled_fullscreen_Z[]; extern const uint8_t oled_fullscreen_Z[];
// Falls du diese auch hast:
extern const uint8_t oled_fullscreen_allArray_LEN; extern const uint8_t oled_fullscreen_allArray_LEN;
extern const uint8_t* oled_fullscreen_allArray[]; extern const uint8_t* oled_fullscreen_allArray[];

3
include/oled/font_mini.h
View File

@ -3,16 +3,13 @@
#include <stdint.h> #include <stdint.h>
// ## 1. Konstanten ##
#define CHAR_WIDTH 32 #define CHAR_WIDTH 32
#define CHAR_HEIGHT 16 #define CHAR_HEIGHT 16
#define CHAR_BYTES 64 #define CHAR_BYTES 64
// ## 2. Globale Variablen (mit "extern") ##
extern const uint8_t fullscreen_allArray_LEN; extern const uint8_t fullscreen_allArray_LEN;
extern const unsigned char* fullscreen_allArray[36]; extern const unsigned char* fullscreen_allArray[36];
// ## 3. Funktions-Prototypen ##
typedef void (*set_pixel_func_t)(uint8_t* framebuffer, int fb_width, int x, int y); typedef void (*set_pixel_func_t)(uint8_t* framebuffer, int fb_width, int x, int y);
void set_pixel(uint8_t* framebuffer, int fb_width, int x, int y); void set_pixel(uint8_t* framebuffer, int fb_width, int x, int y);
void create_fullscreen_char(char character, uint8_t* framebuffer, int fb_width, int fb_height, uint8_t scale); void create_fullscreen_char(char character, uint8_t* framebuffer, int fb_width, int fb_height, uint8_t scale);

142
src/epaper/epaper.c
View File

@ -32,13 +32,13 @@ static struct spi_config spi_cfg = {
}; };
// GPIO Makros // GPIO Makros
#define EPD_W21_CS_0 gpio_pin_set_dt(&epd_cs, 0) #define EPD_CS_0 gpio_pin_set_dt(&epd_cs, 0)
#define EPD_W21_CS_1 gpio_pin_set_dt(&epd_cs, 1) #define EPD_CS_1 gpio_pin_set_dt(&epd_cs, 1)
#define EPD_W21_DC_0 gpio_pin_set_dt(&epd_dc, 0) #define EPD_DC_0 gpio_pin_set_dt(&epd_dc, 0)
#define EPD_W21_DC_1 gpio_pin_set_dt(&epd_dc, 1) #define EPD_DC_1 gpio_pin_set_dt(&epd_dc, 1)
#define EPD_W21_RST_0 gpio_pin_set_dt(&epd_reset, 0) #define EPD_RST_0 gpio_pin_set_dt(&epd_reset, 0)
#define EPD_W21_RST_1 gpio_pin_set_dt(&epd_reset, 1) #define EPD_RST_1 gpio_pin_set_dt(&epd_reset, 1)
#define isEPD_W21_BUSY gpio_pin_get_dt(&epd_busy) #define isEPD_BUSY gpio_pin_get_dt(&epd_busy)
const uint8_t lut_full_update[] = { const uint8_t lut_full_update[] = {
0xA0, 0x99, 0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x99, 0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -56,7 +56,7 @@ void driver_delay_xms(int32_t xms) {
void epd_spi_writeByte(uint8_t value) { void epd_spi_writeByte(uint8_t value) {
// Lokaler, nicht optimierbarer Puffer mit expliziter Größe // Lokaler, nicht optimierbarer Puffer mit expliziter Größe
volatile uint8_t tx_data[1]; // Deklariere tx_data lokal, ohne static volatile uint8_t tx_data[1]; // Deklariere tx_data lokal, ohne static
tx_data[0] = value; // Initialisiere den Puffer JEDES Mal tx_data[0] = value;
struct spi_buf buf = { struct spi_buf buf = {
.buf = (uint8_t *)tx_data, // explizit casten .buf = (uint8_t *)tx_data, // explizit casten
@ -75,25 +75,26 @@ void epd_spi_writeByte(uint8_t value) {
void epd_readbusy(void) { void epd_readbusy(void) {
while (isEPD_W21_BUSY) { while (isEPD_BUSY) {
k_msleep(100); k_msleep(100);
} }
} }
void epd_write_command(uint8_t cmd) { void epd_write_command(uint8_t cmd) {
EPD_W21_DC_0; // DC auf Command setzen EPD_DC_0; // DC auf Command setzen
epd_spi_writeByte(cmd); epd_spi_writeByte(cmd);
} }
void epd_write_data(uint8_t data) { void epd_write_data(uint8_t data) {
EPD_W21_DC_1; // DC auf Data setzen EPD_DC_1; // DC auf Data setzen
epd_spi_writeByte(data); epd_spi_writeByte(data);
} }
void epd_init_sequence(void) { void epd_init_sequence(void) {
EPD_W21_RST_0;
EPD_RST_0;
k_msleep(10); // Ein kurzer Reset-Puls ist oft besser k_msleep(10); // Ein kurzer Reset-Puls ist oft besser
EPD_W21_RST_1; EPD_RST_1;
k_msleep(100); k_msleep(100);
epd_readbusy(); epd_readbusy();
@ -138,7 +139,7 @@ void epd_init_sequence(void) {
epd_write_command(0x18); // Temperature Sensor Control epd_write_command(0x18); // Temperature Sensor Control
epd_write_data(0x80); // Internen Sensor verwenden epd_write_data(0x80); // Internen Sensor verwenden
// Schreibe die finale LUT in den Controller // Schreibe die LUT in den Controller
epd_write_command(0x32); epd_write_command(0x32);
for (int i = 0; i < sizeof(lut_full_update); i++) { for (int i = 0; i < sizeof(lut_full_update); i++) {
epd_write_data(lut_full_update[i]); epd_write_data(lut_full_update[i]);
@ -174,127 +175,106 @@ void epd_init(void){
epd_clear(); // Zweiter Clear-Durchgang epd_clear(); // Zweiter Clear-Durchgang
// vor dem Malen den Cursor auf den Anfang (0,0) setzen // vor dem Malen den Cursor auf den Anfang (0,0) setzen
EPD_W21_CS_0; EPD_CS_0;
epd_write_command(0x4E); // Setze X-Adress-Zähler auf 0 epd_write_command(0x4E); // Setze X-Adress-Zähler auf 0
epd_write_data(0x00); epd_write_data(0x00);
epd_write_command(0x4F); // Setze Y-Adress-Zähler auf 0 epd_write_command(0x4F); // Setze Y-Adress-Zähler auf 0
epd_write_data(0x00); epd_write_data(0x00);
epd_write_data(0x00); epd_write_data(0x00);
EPD_W21_CS_1; EPD_CS_1;
} }
void epd_update(void) { void epd_update(void) {
epd_write_command(0x22); epd_write_command(0x22);
epd_write_data(0xC7); //war FF epd_write_data(0xFF); //war FF
epd_write_command(0x20); epd_write_command(0x20);
epd_readbusy(); epd_readbusy();
} }
void epd_setPosition(void) {
// sicheres Set vor 0x24
epd_write_command(0x11); epd_write_data(0x01); // zeilenweise
epd_write_command(0x44); epd_write_data(0x00); epd_write_data(0x1F); // X: 0..31 (Bytes)
epd_write_command(0x45); epd_write_data(0x00); epd_write_data(0x00);
epd_write_data(0x79); epd_write_data(0x00); // Y: 0..121 (Zeilen)
epd_write_command(0x4E); epd_write_data(0x00); // X-Zähler = 0
epd_write_command(0x4F); epd_write_data(0x00); epd_write_data(0x00); // Y-Zähler = 0
}
// Beispiel für das Senden eines Bildes
void epd_whitescreen_all(const uint8_t *datas) { void epd_whitescreen_all(const uint8_t *datas) {
// sicheres Set vor 0x24 epd_setPosition();
//epd_write_command(0x11); epd_write_data(0x01); // zeilenweise EPD_CS_0; // <-- CS hier aktivieren (LOW)
//epd_write_command(0x44); epd_write_data(0x00); epd_write_data(0x1F); // X: 0..31 (Bytes)
//epd_write_command(0x45); epd_write_data(0x00); epd_write_data(0x00);
// epd_write_data(0x79); epd_write_data(0x00); // Y: 0..121 (Zeilen)
//epd_write_command(0x4E); epd_write_data(0x00); // X-Zähler = 0
//epd_write_command(0x4F); epd_write_data(0x00); epd_write_data(0x00); // Y-Zähler = 0
EPD_W21_CS_0; // <-- CS hier aktivieren (LOW)
epd_write_command(0x24); // Command: write RAM for black/white image epd_write_command(0x24); // Command: write RAM for black/white image
for (int i = 0; i < ALLSCREEN_GRAGHBYTES; i++) { for (int i = 0; i < ALLSCREEN_GRAGHBYTES; i++) {
epd_write_data(datas[i]); epd_write_data(datas[i]);
} }
EPD_W21_CS_1; // <-- CS hier deaktivieren (HIGH) EPD_CS_1; // <-- CS hier deaktivieren (HIGH)
// Der Update-Befehl ist eine eigene Transaktion // Der Update-Befehl ist eine eigene Transaktion
EPD_W21_CS_0; EPD_CS_0;
epd_update(); epd_update();
EPD_W21_CS_1; EPD_CS_1;
} }
// Beispiel für das komplette Löschen des Bildschirms // Beispiel für das komplette Löschen des Bildschirms
void epd_whitescreen_black(void) { void epd_whitescreen_black(void) {
EPD_W21_CS_0; // <-- CS hier aktivieren (LOW) epd_setPosition();
EPD_CS_0; // <-- CS hier aktivieren (LOW)
epd_write_command(0x24); epd_write_command(0x24);
for (int i = 0; i < ALLSCREEN_GRAGHBYTES; i++) { for (int i = 0; i < ALLSCREEN_GRAGHBYTES; i++) {
epd_write_data(0x00); // Schwarz epd_write_data(0x00); // Schwarz
} }
EPD_W21_CS_1; // <-- CS hier deaktivieren (HIGH) EPD_CS_1; // <-- CS hier deaktivieren (HIGH)
// Der Update-Befehl ist eine eigene Transaktion // Der Update-Befehl ist eine eigene Transaktion
EPD_W21_CS_0; EPD_CS_0;
epd_update(); epd_update();
EPD_W21_CS_1; EPD_CS_1;
}
// Dasselbe musst du für EPD_WhiteScreen_White() machen.
void epd_whitescreen_white(void) {
EPD_W21_CS_0; // <-- CS hier aktivieren (LOW)
epd_write_command(0x24);
for (int i = 0; i < ALLSCREEN_GRAGHBYTES; i++) {
epd_write_data(0xFF); // Weiß
}
EPD_W21_CS_1; // <-- CS hier deaktivieren (HIGH)
// Der Update-Befehl ist eine eigene Transaktion
EPD_W21_CS_0;
epd_update();
EPD_W21_CS_1;
} }
void epd_clear(void) { void epd_clear(void) {
epd_setPosition();
printk("Clearing display...\n"); printk("Clearing display...\n");
// sicheres Set vor 0x24
//epd_write_command(0x11); epd_write_data(0x01); // zeilenweise
//epd_write_command(0x44); epd_write_data(0x00); epd_write_data(0x1F); // X: 0..31 (Bytes)
//epd_write_command(0x45); epd_write_data(0x00); epd_write_data(0x00);
// epd_write_data(0x79); epd_write_data(0x00); // Y: 0..121 (Zeilen)
//epd_write_command(0x4E); epd_write_data(0x00); // X-Zähler = 0
//epd_write_command(0x4F); epd_write_data(0x00); epd_write_data(0x00); // Y-Zähler = 0
// RAM für das Bild mit "Weiß" füllen // RAM für das Bild mit "Weiß" füllen
EPD_W21_CS_0; EPD_CS_0;
epd_write_command(0x24); // Schreibe in den RAM epd_write_command(0x24); // Schreibe in den RAM
for (int i = 0; i < ALLSCREEN_GRAGHBYTES; i++) { for (int i = 0; i < ALLSCREEN_GRAGHBYTES; i++) {
epd_write_data(0xFF); // 0xFF = Weiß epd_write_data(0xFF); // 0xFF = Weiß
} }
EPD_W21_CS_1; EPD_CS_1;
// Physisches Update starten, um den Bildschirm zu reinigen // Physisches Update starten, um den Bildschirm zu reinigen
EPD_W21_CS_0; EPD_CS_0;
epd_update(); epd_update();
EPD_W21_CS_1; EPD_CS_1;
epd_readbusy(); // Warten, bis der Clear-Vorgang abgeschlossen ist epd_readbusy(); // Warten, bis der Clear-Vorgang abgeschlossen ist
} }
void epd_draw_something(char toDraw) { void epd_draw_something(char toDraw) {
draw_char(toDraw, epaper_framebuffer, 256, HEIGHT, 17);
epd_whitescreen_all(epaper_framebuffer); epd_whitescreen_all(epaper_framebuffer);
draw_char('K', epaper_framebuffer, 256, HEIGHT, 17);
EPD_W21_CS_0;
epd_write_command(0x24);
for (int i = 0; i < ALLSCREEN_GRAGHBYTES; i++) {
epd_write_data(epaper_framebuffer[i]);
}
EPD_W21_CS_1;
// Physisches Update
printk("Aktualisiere Display...\n");
EPD_W21_CS_0;
epd_update();
EPD_W21_CS_1;
printk("Display-Finish.\n"); printk("Display-Finish.\n");
}
epd_readbusy(); // BUSY = 0 → bereit
epd_write_command(0x02); // POWER_OFF
epd_readbusy(); // warten bis off
epd_write_command(0x10); // DEEP_SLEEP
epd_write_data(0x01);
k_msleep(5);
gpio_pin_set_dt(&epd_cs, 0);
gpio_pin_set_dt(&epd_dc, 0);
gpio_pin_set_dt(&epd_reset, 0);
}

124
src/epaper/font_mini.c
View File

@ -6,65 +6,65 @@
// STANDARD 5x7 ASCII FONT (Horizontal, MSB-first) // STANDARD 5x7 ASCII FONT (Horizontal, MSB-first)
const unsigned char font5x7[] = { const unsigned char font5x7[] = {
0x00, 0x00, 0x00, 0x00, 0x00, // sp 0x00, 0x00, 0x00, 0x00, 0x00, // sp
0x00, 0x00, 0x5F, 0x00, 0x00, // ! 0x00, 0x00, 0x5F, 0x00, 0x00, // !
0x00, 0x07, 0x00, 0x07, 0x00, // " 0x00, 0x07, 0x00, 0x07, 0x00, // "
0x14, 0x7F, 0x14, 0x7F, 0x14, // # 0x14, 0x7F, 0x14, 0x7F, 0x14, // #
0x24, 0x2A, 0x7F, 0x2A, 0x12, // $ 0x12, 0x2A, 0x7F, 0x2A, 0x24, // $
0x23, 0x13, 0x08, 0x64, 0x62, // % 0x62, 0x64, 0x08, 0x13, 0x23, // %
0x36, 0x49, 0x55, 0x22, 0x50, // & 0x50, 0x22, 0x55, 0x49, 0x36, // &
0x00, 0x05, 0x03, 0x00, 0x00, // ' 0x00, 0x00, 0x03, 0x05, 0x00, // '
0x00, 0x1C, 0x22, 0x41, 0x00, // ( 0x00, 0x41, 0x22, 0x1C, 0x00, // (
0x00, 0x41, 0x22, 0x1C, 0x00, // ) 0x00, 0x1C, 0x22, 0x41, 0x00, // )
0x08, 0x2A, 0x1C, 0x2A, 0x08, // * 0x08, 0x2A, 0x1C, 0x2A, 0x08, // *
0x08, 0x08, 0x3E, 0x08, 0x08, // + 0x08, 0x08, 0x3E, 0x08, 0x08, // +
0x00, 0x50, 0x30, 0x00, 0x00, // , 0x00, 0x00, 0x30, 0x50, 0x00, // ,
0x08, 0x08, 0x08, 0x08, 0x08, // - 0x08, 0x08, 0x08, 0x08, 0x08, // -
0x00, 0x60, 0x60, 0x00, 0x00, // . 0x00, 0x00, 0x60, 0x60, 0x00, // .
0x20, 0x10, 0x08, 0x04, 0x02, // / 0x02, 0x04, 0x08, 0x10, 0x20, // /
0x3E, 0x51, 0x49, 0x45, 0x3E, // 0 0x3E, 0x45, 0x49, 0x51, 0x3E, // 0
0x00, 0x42, 0x7F, 0x40, 0x00, // 1 0x00, 0x40, 0x7F, 0x42, 0x00, // 1
0x42, 0x61, 0x51, 0x49, 0x46, // 2 0x46, 0x49, 0x51, 0x61, 0x42, // 2
0x21, 0x41, 0x45, 0x4B, 0x31, // 3 0x31, 0x4B, 0x45, 0x41, 0x21, // 3
0x18, 0x14, 0x12, 0x7F, 0x10, // 4 0x10, 0x7F, 0x12, 0x14, 0x18, // 4
0x27, 0x45, 0x45, 0x45, 0x39, // 5 0x39, 0x45, 0x45, 0x45, 0x27, // 5
0x3C, 0x4A, 0x49, 0x49, 0x30, // 6 0x3C, 0x66, 0x66, 0x49, 0x3C, // 6
0x01, 0x71, 0x09, 0x05, 0x03, // 7 0x03, 0x05, 0x09, 0x71, 0x01, // 7
0x36, 0x49, 0x49, 0x49, 0x36, // 8 0x36, 0x49, 0x49, 0x49, 0x36, // 8
0x06, 0x49, 0x49, 0x29, 0x1E, // 9 0x1E, 0x29, 0x49, 0x49, 0x06, // 9
0x00, 0x36, 0x36, 0x00, 0x00, // : 0x00, 0x00, 0x36, 0x36, 0x00, // :
0x00, 0x56, 0x36, 0x00, 0x00, // ; 0x00, 0x00, 0x36, 0x56, 0x00, // ;
0x00, 0x08, 0x14, 0x22, 0x41, // < 0x41, 0x22, 0x14, 0x08, 0x00, // <
0x14, 0x14, 0x14, 0x14, 0x14, // = 0x14, 0x14, 0x14, 0x14, 0x14, // =
0x41, 0x22, 0x14, 0x08, 0x00, // > 0x00, 0x08, 0x14, 0x22, 0x41, // >
0x02, 0x01, 0x51, 0x09, 0x06, // ? 0x06, 0x09, 0x51, 0x01, 0x02, // ?
0x32, 0x49, 0x79, 0x41, 0x3E, // @ 0x3E, 0x41, 0x79, 0x49, 0x32, // @
0x7E, 0x11, 0x11, 0x11, 0x7E, // A 0x7E, 0x11, 0x11, 0x11, 0x7E, // A
0x7F, 0x49, 0x49, 0x49, 0x36, // B 0x36, 0x49, 0x49, 0x49, 0x7F, // B
0x3E, 0x41, 0x41, 0x41, 0x22, // C 0x22, 0x41, 0x41, 0x41, 0x3E, // C
0x7F, 0x41, 0x41, 0x22, 0x1C, // D 0x1C, 0x22, 0x41, 0x41, 0x7F, // D
0x7F, 0x49, 0x49, 0x49, 0x41, // E 0x41, 0x49, 0x49, 0x49, 0x7F, // E
0x7F, 0x09, 0x09, 0x01, 0x01, // F 0x01, 0x01, 0x09, 0x09, 0x7F, // F
0x3E, 0x41, 0x41, 0x51, 0x32, // G 0x32, 0x51, 0x41, 0x41, 0x3E, // G
0x7F, 0x08, 0x08, 0x08, 0x7F, // H 0x7F, 0x08, 0x08, 0x08, 0x7F, // H
0x00, 0x41, 0x7F, 0x41, 0x00, // I 0x00, 0x41, 0x7F, 0x41, 0x00, // I
0x20, 0x40, 0x41, 0x3F, 0x01, // J 0x01, 0x3F, 0x41, 0x40, 0x20, // J
0x7F, 0x08, 0x14, 0x22, 0x41, // K 0x41, 0x22, 0x14, 0x08, 0x7F, // K
0x7F, 0x40, 0x40, 0x40, 0x40, // L 0x40, 0x40, 0x40, 0x40, 0x7F, // L
0x7F, 0x02, 0x04, 0x02, 0x7F, // M 0x7F, 0x02, 0x04, 0x02, 0x7F, // M
0x7F, 0x04, 0x08, 0x10, 0x7F, // N 0x7F, 0x10, 0x08, 0x04, 0x7F, // N
0x3E, 0x41, 0x41, 0x41, 0x3E, // O 0x3E, 0x41, 0x41, 0x41, 0x3E, // O
0x7F, 0x09, 0x09, 0x09, 0x06, // P 0x06, 0x09, 0x09, 0x09, 0x7F, // P
0x3E, 0x41, 0x51, 0x21, 0x5E, // Q 0x5E, 0x21, 0x51, 0x41, 0x3E, // Q
0x7F, 0x09, 0x19, 0x29, 0x46, // R 0x46, 0x29, 0x19, 0x09, 0x7F, // R
0x46, 0x49, 0x49, 0x49, 0x31, // S 0x31, 0x49, 0x49, 0x49, 0x46, // S
0x01, 0x01, 0x7F, 0x01, 0x01, // T 0x01, 0x01, 0x7F, 0x01, 0x01, // T
0x3F, 0x40, 0x40, 0x40, 0x3F, // U 0x3F, 0x40, 0x40, 0x40, 0x3F, // U
0x1F, 0x20, 0x40, 0x20, 0x1F, // V 0x1F, 0x20, 0x40, 0x20, 0x1F, // V
0x3F, 0x40, 0x38, 0x40, 0x3F, // W 0x3F, 0x40, 0x38, 0x40, 0x3F, // W
0x63, 0x14, 0x08, 0x14, 0x63, // X 0x63, 0x14, 0x08, 0x14, 0x63, // X
0x03, 0x04, 0x78, 0x04, 0x03, // Y 0x03, 0x04, 0x78, 0x04, 0x03, // Y
0x61, 0x51, 0x49, 0x45, 0x43, // Z 0x43, 0x45, 0x49, 0x51, 0x61, // Z
}; };
void draw_char(char character, uint8_t* framebuffer, int fb_width, int fb_height, uint8_t scale) { void draw_char(char character, uint8_t* framebuffer, int fb_width, int fb_height, uint8_t scale) {
@ -77,10 +77,8 @@ void draw_char(char character, uint8_t* framebuffer, int fb_width, int fb_height
} }
const uint8_t* font_ptr = font5x7 + (character - ' ') * 5; const uint8_t* font_ptr = font5x7 + (character - ' ') * 5;
int scaled_width = 5 * scale; int start_x = 0;
int scaled_height = 7 * scale; int start_y = 0;
int start_x = 0;//(fb_width - scaled_width) / 2;
int start_y = 0;//(fb_height - scaled_height) / 2;
// Zeichen Pixel für Pixel malen // Zeichen Pixel für Pixel malen
for (int y = 0; y < 7; y++) { // Höhe des Fonts ist 7 for (int y = 0; y < 7; y++) { // Höhe des Fonts ist 7

22
src/lora/encryption.c
View File

@ -7,25 +7,19 @@
#include "lora/encryption.h" #include "lora/encryption.h"
const uint8_t XOR_KEY = 0x5Au;
void xorCrypt(const char *input, char *output, uint8_t key) { size_t xorCryptBytes(const uint8_t *in, uint8_t *out, size_t len, uint8_t key) {
size_t len = strlen(input); for (size_t i = 0; i < len; i++) out[i] = in[i] ^ key;
for (size_t i = 0; i < len; i++) { return len;
output[i] = input[i] ^ key;
}
output[len] = '\0'; // Null-Terminierung für gültige C-Strings
} }
uint16_t computeCRC16(const char *data) {
uint16_t computeCRC16(const uint8_t *data, size_t len) {
uint16_t crc = 0xFFFF; uint16_t crc = 0xFFFF;
for (size_t i = 0; i < strlen(data); i++) { for (size_t i = 0; i < len; i++) {
crc ^= (uint8_t)data[i] << 8; crc ^= (uint16_t)data[i] << 8;
for (int j = 0; j < 8; j++) { for (int j = 0; j < 8; j++) {
if (crc & 0x8000) crc = (crc & 0x8000) ? (uint16_t)((crc << 1) ^ 0x1021) : (uint16_t)(crc << 1);
crc = (crc << 1) ^ 0x1021;
else
crc <<= 1;
} }
} }
return crc; return crc;

57
src/lora/lora.c
View File

@ -1,6 +1,7 @@
#include <zephyr/kernel.h> #include <zephyr/kernel.h>
#include <zephyr/sys/printk.h> #include <zephyr/sys/printk.h>
#include <zephyr/drivers/lora.h> #include <zephyr/drivers/lora.h>
#include <zephyr/sys/byteorder.h>
#include <string.h> #include <string.h>
#include "utils/displayController.h" #include "utils/displayController.h"
@ -17,7 +18,7 @@ const struct device *lora_dev = DEVICE_DT_GET(DT_ALIAS(lora0));
static volatile int rx_count = 0; static volatile int rx_count = 0;
static volatile bool message_received = false; static volatile bool message_received = false;
char decoded[128]; static char decoded[MAX_MSG + 1];
uint32_t sleep_intervall_ms = 1; uint32_t sleep_intervall_ms = 1;
uint32_t start = 0; uint32_t start = 0;
@ -36,26 +37,41 @@ static struct lora_modem_config config = {
.tx = false, .tx = false,
}; };
static DataPacket packet;
void lora_receive_cb(const struct device *dev, void lora_receive_cb(const struct device *dev,
uint8_t *data, uint16_t size, uint8_t *data, uint16_t size,
int16_t rssi, int8_t snr) int16_t rssi, int8_t snr)
{ {
if (size == sizeof(DataPacket)) { // Minimaler Header: 2(len)+2(crc)+4(ts) = 8
memcpy(&packet, data, sizeof(DataPacket)); if (size < 8) return;
rx_count++;
sleep_intervall_ms = (120000 + packet.timestamp); // Felder aus Big-Endian lesen
printk("timestamp: %d, next: %d\n", packet.timestamp, sleep_intervall_ms); uint16_t len = sys_get_be16(&data[0]);
printk("Nachricht empfangen (%d Bytes): %s\n", rx_count, packet.message); uint16_t rx_crc = sys_get_be16(&data[2]);
uint32_t stop = k_uptime_get() - start; uint32_t ts_ms = sys_get_be32(&data[4]);
xorCrypt(data, decoded, 0x5A); if (len > MAX_MSG) return;
message_received = true; if (size < 8 + len) return; // unvollständig
printk("Zeitpunkt: %d\n", stop); const uint8_t *msg = &data[8];
disable_lora_receive();
// CRC prüfen (über verschlüsselte Payload)
uint16_t calc = computeCRC16(msg, len);
if (calc != rx_crc) {
printk("CRC-Fehler: %04x != %04x\n", rx_crc, calc);
return;
} }
// Entschlüsseln (erst NACH erfolgreicher CRC)
size_t out_len = xorCryptBytes(msg, (uint8_t*)decoded, len, 0x5A);
decoded[out_len] = '\0';
sleep_intervall_ms = (120000 + ts_ms);
message_received = true;
disable_lora_receive();
} }
int enable_lora_receive(void) int enable_lora_receive(void)
@ -103,11 +119,18 @@ void lora_thread(void *p1, void *p2, void *p3)
disable_lora_receive(); disable_lora_receive();
int64_t t0 = k_uptime_get();
if (message_received) { if (message_received) {
dc_draw_something(decoded); dc_draw_something(decoded);
} }
int64_t timeToDraw = k_uptime_get() - t0;
int64_t to_sleep = (int64_t)sleep_intervall_ms - timeToDraw;
k_msleep(sleep_intervall_ms); if (to_sleep > 0) {
k_msleep((int32_t)to_sleep);
}
} }
} }

172
src/master/master.c
View File

@ -1,9 +1,10 @@
#include <zephyr/console/console.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/kernel.h> #include <zephyr/kernel.h>
#include <zephyr/sys/printk.h>
#include <zephyr/device.h> #include <zephyr/device.h>
#include <zephyr/sys/printk.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/drivers/lora.h> #include <zephyr/drivers/lora.h>
#include <zephyr/sys/byteorder.h> // sys_cpu_to_be16/32, sys_be16_to_cpu
#include <ctype.h>
#include <string.h> #include <string.h>
#include <stdio.h> #include <stdio.h>
@ -11,129 +12,145 @@
#include "lora/lorapacket.h" #include "lora/lorapacket.h"
#define DEFAULT_RADIO_NODE DT_ALIAS(lora0) #define DEFAULT_RADIO_NODE DT_ALIAS(lora0)
#define SEND_INTERVAL_MS 1000 // Sendeintervall in ms #define UART_DEVICE_NODE DT_CHOSEN(zephyr_console)
#define STACK_SIZE 1024
#define INPUT_STACK_SIZE 1024
#define INPUT_PRIORITY 5
#define ACTIVE_TIME_MS 10000
#define SEND_INTERVAL_MS 1000
#define SLEEP_INTERVAL_MS 120000 #define SLEEP_INTERVAL_MS 120000
#define STACK_SIZE 1024 #define MAX_MSG 64
#define INPUT_STACK_SIZE 1024
#define INPUT_PRIORITY 5
struct k_thread send_thread_data;
const struct device *lora_dev_master = DEVICE_DT_GET(DEFAULT_RADIO_NODE); const struct device *lora_dev_master = DEVICE_DT_GET(DEFAULT_RADIO_NODE);
const struct device *uart_console = DEVICE_DT_GET(UART_DEVICE_NODE);
K_THREAD_STACK_DEFINE(send_stack_area, STACK_SIZE); K_THREAD_STACK_DEFINE(send_stack_area, STACK_SIZE);
K_THREAD_STACK_DEFINE(input_stack_area, INPUT_STACK_SIZE); K_THREAD_STACK_DEFINE(input_stack_area, INPUT_STACK_SIZE);
struct k_thread input_thread_data; static struct k_thread send_thread_data;
static struct k_thread input_thread_data;
static struct k_mutex word_mutex;
char latest_word[32] = "Hello!"; static char latest_word[32] = "HALLO!";
char encrypted[64];
struct k_mutex word_mutex;
struct lora_modem_config tx_config_master = { static struct lora_modem_config tx_config_master = {
.frequency = 868100000, .frequency = 868100000,
.bandwidth = BW_125_KHZ, .bandwidth = BW_125_KHZ,
.datarate = SF_7, .datarate = SF_7,
.preamble_len = 8, .preamble_len = 8,
.coding_rate = CR_4_5, .coding_rate = CR_4_5,
.tx_power = 14, .tx_power = 14,
.tx = true, .tx = true,
}; };
#define UART_DEVICE_NODE DT_CHOSEN(zephyr_console) static void uart_input_get_line(char *buf, size_t max_len)
const struct device *uart_console = DEVICE_DT_GET(UART_DEVICE_NODE);
void uart_input_get_line(char *buf, size_t max_len)
{ {
size_t len = 0; size_t len = 0;
char c; char c;
while (len < max_len - 1) { while (len < max_len - 1) {
if (uart_poll_in(uart_console, &c) == 0) { if (uart_poll_in(uart_console, &c) == 0) {
if (c == '\r' || c == '\n') { if (c == '\r' || c == '\n') break;
break;
}
buf[len++] = c; buf[len++] = c;
printk("%c", c); // Echo printk("%c", c); // Echo
} }
k_msleep(1); k_msleep(1);
} }
buf[len] = '\0'; buf[len] = '\0';
printk("\n"); printk("\n");
} }
static int build_packet_snapshot(DataPacket *out_pkt, uint32_t timer_ms, char *dbg_plain, size_t dbg_sz)
void send_lora_message(const char* text, uint32_t timer)
{ {
int ret = lora_config(lora_dev_master, &tx_config_master); char local_plain[sizeof(latest_word)];
if (ret != 0) { k_mutex_lock(&word_mutex, K_FOREVER);
printk("LoRa-Konfiguration fehlgeschlagen: %d\n", ret); strncpy(local_plain, latest_word, sizeof(local_plain));
return; local_plain[sizeof(local_plain)-1] = '\0';
k_mutex_unlock(&word_mutex);
for (size_t i = 0; local_plain[i] != '\0'; ++i) {
local_plain[i] = (char)toupper((unsigned char)local_plain[i]);
} }
DataPacket pkt; uint8_t local_enc[MAX_MSG];
size_t plain_len = strnlen(local_plain, sizeof(local_plain));
if (plain_len > MAX_MSG) plain_len = MAX_MSG;
memset(&pkt, 0, sizeof(pkt)); size_t local_len = xorCryptBytes((const uint8_t*)local_plain, local_enc, plain_len, 0x5A);
strncpy(pkt.message, encrypted, sizeof(pkt.message)); uint16_t local_crc = computeCRC16(local_enc, local_len);
pkt.timestamp = timer;
ret = lora_send(lora_dev_master, (uint8_t *)&pkt, sizeof(pkt)); memset(out_pkt, 0, sizeof(*out_pkt));
if (ret < 0) { out_pkt->len = sys_cpu_to_be16((uint16_t)local_len);
printk("Senden fehlgeschlagen: %d\n", ret); out_pkt->crc = sys_cpu_to_be16(local_crc);
} else { out_pkt->timestamp = sys_cpu_to_be32(timer_ms);
printk("Gesendet: \"%s\"\n", encrypted); memcpy(out_pkt->message, local_enc, local_len);
if (dbg_plain && dbg_sz) {
strncpy(dbg_plain, local_plain, dbg_sz);
dbg_plain[dbg_sz - 1] = '\0';
} }
return (int)local_len;
} }
void send_loop_thread(void *p1, void *p2, void *p3) static int send_packet_snapshot(const DataPacket *pkt, size_t payload_len)
{ {
const int active_time_ms = 10000; size_t total = sizeof(pkt->len) + sizeof(pkt->crc) + sizeof(pkt->timestamp) + payload_len;
const int interval_ms = 1000; return lora_send(lora_dev_master, (uint8_t *)pkt, total);
}
char local_copy[32]; static void send_loop_thread(void *p1, void *p2, void *p3)
{
DataPacket snapshot;
size_t snap_len = 0;
while (1) { while (1) {
printk("Sendephase gestartet\n"); printk("Sendephase gestartet\n");
// Wort einfrieren
k_mutex_lock(&word_mutex, K_FOREVER);
strncpy(local_copy, encrypted, sizeof(local_copy));
local_copy[sizeof(local_copy) - 1] = '\0';
k_mutex_unlock(&word_mutex);
uint32_t start = k_uptime_get(); uint32_t start = k_uptime_get();
while ((k_uptime_get() - start) < active_time_ms) {
send_lora_message(local_copy, (active_time_ms - (k_uptime_get() - start))); // Vor dem aktiven Fenster: Snapshot bauen
k_msleep(interval_ms); char dbg[33];
snap_len = (size_t)build_packet_snapshot(&snapshot, /*timer*/ACTIVE_TIME_MS, dbg, sizeof(dbg));
printk("Snapshot von \"%s\" (len=%u)\n", dbg, (unsigned)snap_len);
while ((k_uptime_get() - start) < ACTIVE_TIME_MS) {
uint32_t remaining = ACTIVE_TIME_MS - (k_uptime_get() - start);
((DataPacket*)&snapshot)->timestamp = sys_cpu_to_be32(remaining);
int ret = send_packet_snapshot(&snapshot, snap_len);
if (ret < 0) {
printk("Senden fehlgeschlagen: %d\n", ret);
}
k_msleep(SEND_INTERVAL_MS);
} }
printk("Sendephase beendet\n"); printk("Sendephase beendet\n");
printk("Warte 120 Sekunden...\n"); printk("Schlafe %u ms…\n", (unsigned)SLEEP_INTERVAL_MS);
k_msleep(SLEEP_INTERVAL_MS); k_msleep(SLEEP_INTERVAL_MS);
} }
} }
void input_thread(void *p1, void *p2, void *p3) static void input_thread(void *p1, void *p2, void *p3)
{ {
char buffer[32]; char buffer[sizeof(latest_word)];
while (1) { while (1) {
printk("Neues Wort eingeben:\n"); printk("Neues Wort eingeben:\n");
uart_input_get_line(buffer, sizeof(buffer)); uart_input_get_line(buffer, sizeof(buffer));
for (size_t i = 0; buffer[i] != '\0'; ++i) {
buffer[i] = (char)toupper((unsigned char)buffer[i]);
}
k_mutex_lock(&word_mutex, K_FOREVER); k_mutex_lock(&word_mutex, K_FOREVER);
strncpy(latest_word, buffer, sizeof(latest_word)); strncpy(latest_word, buffer, sizeof(latest_word));
latest_word[sizeof(latest_word) - 1] = '\0'; latest_word[sizeof(latest_word) - 1] = '\0';
k_mutex_unlock(&word_mutex); k_mutex_unlock(&word_mutex);
printk("Neues Wort gespeichert: \"%s\"\n", latest_word); printk("Neues Wort gespeichert: \"%s\"\n", latest_word);
xorCrypt(latest_word, encrypted, 0x5A);
} }
} }
void master_init(void) void master_init(void)
@ -142,11 +159,24 @@ void master_init(void)
printk("LoRa-Gerät nicht bereit\n"); printk("LoRa-Gerät nicht bereit\n");
return; return;
} }
if (!device_is_ready(uart_console)) {
printk("UART-Konsole nicht bereit\n");
return;
}
int ret = lora_config(lora_dev_master, &tx_config_master);
if (ret) {
printk("LoRa-Konfiguration fehlgeschlagen: %d\n", ret);
return;
}
k_mutex_init(&word_mutex); k_mutex_init(&word_mutex);
xorCrypt(latest_word, encrypted, 0x5A);
k_thread_create(&input_thread_data, input_stack_area, INPUT_STACK_SIZE, k_thread_create(&input_thread_data, input_stack_area, INPUT_STACK_SIZE,
input_thread, NULL, NULL, NULL, INPUT_PRIORITY, 0, K_NO_WAIT); input_thread, NULL, NULL, NULL,
k_thread_create(&send_thread_data, send_stack_area, STACK_SIZE, INPUT_PRIORITY, 0, K_NO_WAIT);
send_loop_thread, NULL, NULL, NULL, INPUT_PRIORITY, 0, K_NO_WAIT);
k_thread_create(&send_thread_data, send_stack_area, STACK_SIZE,
send_loop_thread, NULL, NULL, NULL,
INPUT_PRIORITY, 0, K_NO_WAIT);
} }

6
src/oled/oled.c
View File

@ -108,12 +108,12 @@ void oled_init(void) {
oled_write_cmd(0xDA); // Set COM Pins oled_write_cmd(0xDA); // Set COM Pins
oled_write_cmd(0x12); oled_write_cmd(0x12);
oled_write_cmd(0x81); // Set Contrast oled_write_cmd(0x81); // Set Contrast
oled_write_cmd(0xCF); oled_write_cmd(0x80);
oled_write_cmd(0xD9); // Set Pre-charge Period oled_write_cmd(0xD9); // Set Pre-charge Period
oled_write_cmd(0xF1); oled_write_cmd(0x22);
oled_write_cmd(0xDB); // Set VCOMH oled_write_cmd(0xDB); // Set VCOMH
oled_write_cmd(0x40); oled_write_cmd(0x40);
oled_write_cmd(0xA4); // Entire Display ON oled_write_cmd(0x34); // Entire Display ON
oled_write_cmd(0xA6); // Normal Display oled_write_cmd(0xA6); // Normal Display
oled_write_cmd(0x8D); // Charge Pump oled_write_cmd(0x8D); // Charge Pump
oled_write_cmd(0x14); // Enable oled_write_cmd(0x14); // Enable

5
src/utils/displayController.c
View File

@ -22,7 +22,7 @@ void dc_init(const char *type_str, int slot) {
if (strcmp(type_str, "EPD") == 0) { if (strcmp(type_str, "EPD") == 0) {
#if DT_NODE_EXISTS(DT_NODELABEL(epd)) #if DT_NODE_EXISTS(DT_NODELABEL(epd))
epd_init(); epd_init();
epd_draw_something(' '); epd_draw_something(' ');
display_type = DISPLAY_EPD; display_type = DISPLAY_EPD;
printk("EPD Display initialisiert (Slot %d)\n", slot); printk("EPD Display initialisiert (Slot %d)\n", slot);
#else #else
@ -34,7 +34,7 @@ void dc_init(const char *type_str, int slot) {
} else if (strcmp(type_str, "OLED") == 0) { } else if (strcmp(type_str, "OLED") == 0) {
#if DT_NODE_EXISTS(DT_NODELABEL(oled)) #if DT_NODE_EXISTS(DT_NODELABEL(oled))
oled_init(); oled_init();
oled_draw_something(' '); oled_draw_something(' ');
display_type = DISPLAY_OLED; display_type = DISPLAY_OLED;
printk("OLED Display initialisiert (Slot %d)\n", slot); printk("OLED Display initialisiert (Slot %d)\n", slot);
#endif #endif
@ -51,6 +51,7 @@ void dc_draw_something(const char *message) {
switch (display_type) { switch (display_type) {
case DISPLAY_EPD: case DISPLAY_EPD:
#if DT_NODE_EXISTS(DT_NODELABEL(epd)) #if DT_NODE_EXISTS(DT_NODELABEL(epd))
epd_init();
epd_draw_something(to_draw); epd_draw_something(to_draw);
break; break;
#endif #endif