cpp_sucks

// display.hpp

#ifndef __DISPLAY_H__
#define __DISPLAY_H__

#include "SPIbus.hpp"
#include "abstract_io.hpp"

#define DISPLAY_CS 5
#define DISPLAY_SPI_MODE 0
#define DISPLAY_SPI_CLOCK 1000000

class EINK;

extern EINK display;

typedef class EINK
{
private:
    spi_device_handle_t spi;

public:
    explicit EINK();
    ~EINK();
    void write_command(unsigned char data);
    void write_data(unsigned char data);
    void init(void);
    void lcd_reset();
    void delay_ms(double millis);
    void draw_bitmap(const unsigned char *buff, int x, int y, int width, int height);
    void clear();
    void refresh();
    // void draw_pixel(char x, char y, unsigned int colour);
    void fill_rectangle(char x1, char y1, char x2, char y2, unsigned int colour);
    void draw_char(char x, char y, char c, unsigned int colour);
    void draw_string(char x, char y, char *str, unsigned int colour);
    void sleep();
} EINK_t;

#endif

// display.cpp - jeszcze nie uzupełniony

#include "esp_err.h"

#include "display.hpp"

EINK_t display; // <- tu jest elegancko

EINK::EINK()
{
    ESP_ERROR_CHECK(vspi.begin(VSPI_MOSI, VSPI_MISO, VSPI_SCK));
    ESP_ERROR_CHECK(vspi.addDevice(DISPLAY_SPI_MODE, DISPLAY_SPI_CLOCK, DISPLAY_CS, &spi));
}

EINK::~EINK() {
    vspi.close();
}

void EINK::init() {

}

// abstract_io.hpp

#ifndef __GPIO_H__
#define __GPIO_H__

#define HIGH pin_state_t::PIN_HIGH
#define LOW pin_state_t::PIN_LOW

class AbstractIO;

extern AbstractIO aio;

enum class pin_mode_t {
    OUTPUT = 0,
    INPUT_HIZ = 1,
    INPUT_PULL_UP = 2,
    INPUT_PULL_DOWN = 3
};

enum class pin_state_t {
    PIN_LOW = 0,
    PIN_HIGH = 1
};

class AbstractIO
{
public:
    void pinMode(unsigned int pin, pin_mode_t mode);
    void digitalWrite(unsigned int pin, pin_state_t state);
    pin_state_t digitalRead(unsigned int pin);
    void setHigh(unsigned int pin);
    void setLow(unsigned int pin);
} AbstractIO_t;

#endif

// abstract_io.cpp

#include "esp_err.h"
#include "driver/gpio.h"
#include "abstract_io.hpp"

AbstractIO_t aio; // <- tu się kasztani

void AbstractIO::pinMode(unsigned int pin, pin_mode_t mode) {
    ESP_ERROR_CHECK(gpio_set_direction((gpio_num_t)pin, mode == pin_mode_t::OUTPUT ? GPIO_MODE_OUTPUT : GPIO_MODE_INPUT));
    gpio_pull_mode_t pullMode = GPIO_FLOATING;
    if(mode == pin_mode_t::INPUT_PULL_UP)
        pullMode = GPIO_PULLUP_ONLY;
    else if(mode == pin_mode_t::INPUT_PULL_DOWN)
        pullMode = GPIO_PULLDOWN_ONLY;
    ESP_ERROR_CHECK(gpio_set_pull_mode((gpio_num_t)pin, pullMode));
}

void AbstractIO::digitalWrite(unsigned int pin, pin_state_t state) {
    ESP_ERROR_CHECK(gpio_set_level((gpio_num_t)pin, (uint32_t)state));
}

pin_state_t AbstractIO::digitalRead(unsigned int pin) {
    return (pin_state_t)gpio_get_level((gpio_num_t)pin);
}

void AbstractIO::setHigh(unsigned int pin) {
    digitalWrite(pin, pin_state_t::PIN_HIGH);
}

void AbstractIO::setLow(unsigned int pin) {
    digitalWrite(pin, pin_state_t::PIN_LOW);
}