Driver Required for the Display Sitronix ST7305

[dkjLC]

I am currently working on the project where in I require the Zephyr driver for the Sitronix ST7305 Monochromic display.

Link to Datasheet : https://v4.cecdn.yun300.cn/100001_1909185148/ST_7305_V0_2.pdf

It will be Very helpful for me if you can help me with drivers.

[dkjLC]

Hii,
We got started with the program i have attached the files below. can you check for me where i am wrong as i dont see anything on screen.

For testing i have used name as examplesensor

---

examplesensor.c

---

#define DT_DRV_COMPAT zephyr_examplesensor

#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(st7305, CONFIG_DISPLAY_LOG_LEVEL);

#include <string.h>
#include <zephyr/device.h>
#include <zephyr/drivers/display.h>
#include <zephyr/init.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/sys/byteorder.h>

#define ST7305_PANEL_WIDTH DT_INST_PROP(0, width)
#define ST7305_PANEL_HEIGHT DT_INST_PROP(0, height)

#define ST7305_PIXELS_PER_BYTE 8U
/* Adding 2 for the line number and dummy byte

• line_buf format for each row.
• +-------------------+-------------------+----------------+
• | line num (8 bits) | data (WIDTH bits) | dummy (8 bits) |
• +-------------------+-------------------+----------------+
  */
  #define ST7305_BYTES_PER_LINE ((ST7305_PANEL_WIDTH / ST7305_PIXELS_PER_BYTE) + 2) // KEPT AS IT IS

// #if DT_INST_NODE_HAS_PROP(0, disp_miso_en_gpios)
// struct gpio_dt_spec miso_gpio;
// #endif

struct ST7305_config {
struct spi_dt_spec bus;
#if DT_INST_NODE_HAS_PROP(0, disp_miso_en_gpios)
struct gpio_dt_spec disp_miso_en_gpios;
#endif
};

static int ST7305_blanking_off(const struct device *dev)
{
const struct ST7305_config *config = dev->config;
const struct spi_dt_spec *spi = &config->bus;

uint8_t display_on_command = 0x29; // Display ON command for ST7305

struct spi_buf tx_buf = {
    .buf = &display_on_command,
    .len = sizeof(display_on_command),
};

struct spi_buf_set tx = {
    .buffers = &tx_buf,
    .count = 1,
};

int ret = spi_write_dt(spi, &tx);
if (ret < 0) {
    LOG_ERR("Failed to send Display ON command over SPI: %d", ret);
    return ret;
}

return 0;

}

static int ST7305_blanking_on(const struct device *dev)
{
const struct ST7305_config *config = dev->config;
const struct spi_dt_spec *spi = &config->bus;

uint8_t display_off_command = 0x28; // Display OFF command for ST7305

struct spi_buf tx_buf = {
    .buf = &display_off_command,
    .len = sizeof(display_off_command),
};

struct spi_buf_set tx = {
    .buffers = &tx_buf,
    .count = 1,
};

int ret = spi_write_dt(spi, &tx);
if (ret < 0) {
    LOG_ERR("Failed to send Display OFF command over SPI: %d", ret);
    return ret;
}

return 0;

}

// ST7305_CMD COMMAND
// ST7305_CMD COMMAND

static int ST7305_cmd(const struct device *dev, uint8_t *buf, uint8_t len)
{
const struct ST7305_config *config = dev->config;
struct spi_buf cmd_buf = { .buf = buf, .len = len };
struct spi_buf_set buf_set = { .buffers = &cmd_buf, .count = 1 };
#if DT_INST_NODE_HAS_PROP(0, disp_miso_en_gpios)
return gpio_pin_set_dt(&config->disp_miso_en_gpios, 0);
#else
LOG_WRN("Unsupported");
return -ENOTSUP;
#endif
return spi_write_dt(&config->bus, &buf_set);
}

static int ST7305_data(const struct device *dev, uint8_t *buf, uint8_t len)
{
const struct ST7305_config *config = dev->config;
struct spi_buf cmd_buf = { .buf = buf, .len = len };
struct spi_buf_set buf_set = { .buffers = &cmd_buf, .count = 1 };
#if DT_INST_NODE_HAS_PROP(1, disp_miso_en_gpios)
return gpio_pin_set_dt(&config->disp_miso_en_gpios, 1);
#else
LOG_WRN("Unsupported");
return -ENOTSUP;
#endif
return spi_write_dt(&config->bus, &buf_set);
}

static int ST7305_clear(const struct device *dev)
{
const struct ST7305_config *config = dev->config;

// Create the commands to "clear" the display.
uint8_t clear_cmd_off[1] = { 0x28 };  // Display OFF (Blanking ON)
uint8_t clear_cmd_on[1] = { 0x29 };  // Display ON (Blanking OFF)

int err;

// Send the Display OFF command to blank the screen.
err = ST7305_cmd(dev, clear_cmd_off, sizeof(clear_cmd_off));
if (err < 0) {
    LOG_ERR("Failed to send Display OFF command");
    return err;
}

// Optional delay, if required by the display hardware
k_msleep(100);  // Adjust the delay based on the datasheet or requirements.

// Send the Display ON command to bring the display back.
err = ST7305_cmd(dev, clear_cmd_on, sizeof(clear_cmd_on));
if (err < 0) {
    LOG_ERR("Failed to send Display ON command");
    return err;
}

// Release the SPI bus (if necessary).
spi_release_dt(&config->bus);

return 0;

}

static int ST7305_update_display(const struct device *dev,
uint16_t start_line,
uint16_t num_lines,
const uint8_t *data)
{
const struct ST7305_config *config = dev->config;
uint8_t set_column_address_cmd[3] = { 0x2A, 0x00, 0x00 }; // CASET: Column Address Set (starting from 0)
uint8_t set_row_address_cmd[3] = { 0x2B, 0x00, 0x00 }; // RASET: Row Address Set (starting row)
uint8_t write_mem_cmd[1] = { 0x2C }; // RAMWR: Memory Write command
uint8_t ln = start_line;
struct spi_buf line_buf[3] = {
{
.len = sizeof(set_column_address_cmd),
.buf = set_column_address_cmd, // Send column address set command
},
{
.len = sizeof(set_row_address_cmd),
.buf = set_row_address_cmd, // Send row address set command
},
{
.len = sizeof(write_mem_cmd),
.buf = write_mem_cmd, // Send memory write command
},
};
struct spi_buf_set line_set = {
.buffers = line_buf,
.count = ARRAY_SIZE(line_buf),
};
int err = 0;

LOG_DBG("Lines %d to %d", start_line, start_line + num_lines - 1);

// Loop through each line and update the display
for (; ln <= start_line + num_lines - 1; ln++) {
    // Update column and row addresses for the current line
    set_column_address_cmd[1] = (ln * ST7305_PANEL_WIDTH) >> 8; // Set higher byte of column address
    set_column_address_cmd[2] = (ln * ST7305_PANEL_WIDTH) & 0xFF; // Set lower byte of column address
    set_row_address_cmd[1] = ln >> 8; // Set higher byte of row address
    set_row_address_cmd[2] = ln & 0xFF; // Set lower byte of row address

    //miso low

    // Now, send the column and row address set commands
    err = spi_write_dt(&config->bus, &line_set);

    //miso high
    
    // Send the pixel data for this line
    line_buf[1].buf = (uint8_t *)data;
    err |= spi_write_dt(&config->bus, &line_set);

    // Move data pointer for next line
    data += ST7305_PANEL_WIDTH / ST7305_PIXELS_PER_BYTE;
}

// Send the final memory write command to finish writing to the display
err |= ST7305_cmd(dev, write_mem_cmd, sizeof(write_mem_cmd));

// Release the SPI bus
spi_release_dt(&config->bus);

return err;

}

static int ST7305_write(const struct device *dev, const uint16_t x,
const uint16_t y,
const struct display_buffer_descriptor *desc,
const void *buf)
{
LOG_DBG("X: %d, Y: %d, W: %d, H: %d", x, y, desc->width, desc->height);

//const struct ST7305_config *config = dev->config;
if (buf == NULL) {
    LOG_WRN("Display buffer is not available");
    return -EINVAL;
}

// Ensure the width of the buffer is the same as the panel width
if (desc->width != ST7305_PANEL_WIDTH) {
    LOG_ERR("Width not a multiple of %d", ST7305_PANEL_WIDTH);
    return -EINVAL;
}

// Ensure the pitch matches the width of the display buffer
if (desc->pitch != desc->width) {
    LOG_ERR("Unsupported mode");
    return -ENOTSUP;
}

// Ensure the height fits within the display bounds
if ((y + desc->height) > ST7305_PANEL_HEIGHT) {
    LOG_ERR("Buffer out of bounds (height)");
    return -EINVAL;
}

// Ensure the x-coordinate is 0 (assuming only full-screen writes are supported)
if (x != 0) {
    LOG_ERR("X-coordinate has to be 0");
    return -EINVAL;
}

return ST7305_update_display(dev, y + 1, desc->height, buf);

}

static void ST7305_get_capabilities(const struct device *dev,
struct display_capabilities *caps)
{
memset(caps, 0, sizeof(struct display_capabilities));

// Set the resolution based on the ST7305's screen width and height
// Example: assuming the display resolution is 122x250
caps->x_resolution = 250;  // Adjust based on actual display resolution
caps->y_resolution = 122;  // Adjust based on actual display resolution

// Define the supported pixel format for monochrome display
caps->supported_pixel_formats = PIXEL_FORMAT_MONO01;  // Monochrome format
caps->current_pixel_format = PIXEL_FORMAT_MONO01;     // Set as the current format for the display

// Set screen info (this could include various display features such as screen rotation, etc.)
caps->current_orientation = DISPLAY_ORIENTATION_NORMAL;

}
// static int ST7305_set_orientation(const struct device *dev,
// const enum display_orientation orientation)
// {
// if (orientation == DISPLAY_ORIENTATION_NORMAL) {
// return 0;
// }
// LOG_ERR("Changing display orientation not implemented");
// return -ENOTSUP;
// }

static int ST7305_set_pixel_format(const struct device *dev,
const enum display_pixel_format pf)
{
// Check if the requested pixel format is MONO01, which is supported for monochrome displays
if (pf == PIXEL_FORMAT_MONO01) {
LOG_DBG("Pixel format set to MONO01");
return 0; // Success, as MONO01 is the supported format for monochrome displays
}

// If a different pixel format is requested, log an error and return unsupported
LOG_ERR("Pixel format %d not supported", pf);
return -ENOTSUP; // Return error if the pixel format is not supported

}

// LET'S SEE IF WORK
static int ST7305_init(const struct device *dev)
{
const struct ST7305_config *config = dev->config;

if (!spi_is_ready_dt(&config->bus)) {
    LOG_ERR("SPI bus %s not ready", config->bus.bus->name);
    return -ENODEV;
}

int err;

// NVM Load Control
err = ST7305_cmd(dev, (uint8_t[]){0xD6}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x17, 0x02}, 2);
if (err) return err;

// Booster Enable
err = ST7305_cmd(dev, (uint8_t[]){0xD1}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x01}, 1);
if (err) return err;

// Gate Voltage Control
err = ST7305_cmd(dev, (uint8_t[]){0xC0}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x0E, 0x0A}, 2);
if (err) return err;

// VSHP Setting
err = ST7305_cmd(dev, (uint8_t[]){0xC1}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x41, 0x41, 0x41, 0x41}, 4);
if (err) return err;

// VSLP Setting
err = ST7305_cmd(dev, (uint8_t[]){0xC2}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x32, 0x32, 0x32, 0x32}, 4);
if (err) return err;

// VSHN Setting
err = ST7305_cmd(dev, (uint8_t[]){0xC4}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x46, 0x46, 0x46, 0x46}, 4);
if (err) return err;

// VSLN Setting
err = ST7305_cmd(dev, (uint8_t[]){0xC5}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x46, 0x46, 0x46, 0x46}, 4);
if (err) return err;

// Frame Rate Control
err = ST7305_cmd(dev, (uint8_t[]){0xB2}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x12}, 1);
if (err) return err;

// Update Period Gate EQ Control in HPM
err = ST7305_cmd(dev, (uint8_t[]){0xB3}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0xE5, 0xF6, 0x05, 0x46, 0x77, 0x77, 0x77, 0x77, 0x76, 0x45}, 10);
if (err) return err;

// Update Period Gate EQ Control in LPM
err = ST7305_cmd(dev, (uint8_t[]){0xB4}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x05, 0x46, 0x77, 0x77, 0x77, 0x77, 0x76, 0x45}, 8);
if (err) return err;

// Source EQ Enable
err = ST7305_cmd(dev, (uint8_t[]){0xB7}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x13}, 1);
if (err) return err;

// Gate Line Setting
err = ST7305_cmd(dev, (uint8_t[]){0xB0}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x50}, 1);
if (err) return err;

// Sleep-out
err = ST7305_cmd(dev, (uint8_t[]){0x11}, 1);
if (err) return err;
k_msleep(120);

// OSC Setting
err = ST7305_cmd(dev, (uint8_t[]){0xD8}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x80, 0xE9}, 2);
if (err) return err;

// Source Voltage Select
err = ST7305_cmd(dev, (uint8_t[]){0xC9}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x00}, 1);
if (err) return err;

// Memory Data Access Control
err = ST7305_cmd(dev, (uint8_t[]){0x36}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x48}, 1);
if (err) return err;

// Data Format Select
err = ST7305_cmd(dev, (uint8_t[]){0x3A}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x10}, 1);
if (err) return err;

// Gamma Mode Setting
err = ST7305_cmd(dev, (uint8_t[]){0xB9}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x20}, 1);
if (err) return err;

// Panel Setting
err = ST7305_cmd(dev, (uint8_t[]){0xB8}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x00}, 1);
if (err) return err;

// Column Address Setting
err = ST7305_cmd(dev, (uint8_t[]){0x2A}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x13, 0x28}, 2);
if (err) return err;

// Row Address Setting
err = ST7305_cmd(dev, (uint8_t[]){0x2B}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x00, 0x9F}, 2);
if (err) return err;

// TE Setting
err = ST7305_cmd(dev, (uint8_t[]){0x35}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0x00}, 1);
if (err) return err;

// Enable Auto Power Down
err = ST7305_cmd(dev, (uint8_t[]){0xD0}, 1);
if (err) return err;
err = ST7305_data(dev, (uint8_t[]){0xFF}, 1);
if (err) return err;

// LPM ON
err = ST7305_cmd(dev, (uint8_t[]){0x39}, 1);
if (err) return err;

// Display ON
err = ST7305_cmd(dev, (uint8_t[]){0x29}, 1);
if (err) return err;

return ST7305_clear(dev);

}

static const struct ST7305_config ST7305_config = {
.bus = SPI_DT_SPEC_INST_GET(
0, SPI_OP_MODE_MASTER | SPI_WORD_SET(8) |
SPI_TRANSFER_LSB | SPI_CS_ACTIVE_HIGH |
SPI_HOLD_ON_CS | SPI_LOCK_ON, 0),
#if DT_INST_NODE_HAS_PROP(0, disp_miso_en_gpios)
.disp_miso_en_gpios = GPIO_DT_SPEC_INST_GET(0, disp_miso_en_gpios),
#endif
};

static const struct display_driver_api ST7305_driver_api = {
.blanking_on = ST7305_blanking_on,
.blanking_off = ST7305_blanking_off,
.write = ST7305_write,
.get_capabilities = ST7305_get_capabilities,
.set_pixel_format = ST7305_set_pixel_format,
};

DEVICE_DT_INST_DEFINE(0, ST7305_init, NULL, NULL, &ST7305_config, POST_KERNEL,
CONFIG_DISPLAY_INIT_PRIORITY, &ST7305_driver_api);

---

Zephyr,examplesensor.yaml

---

description: |
An example sensor that communicates over SPI.

Example definition in devicetree:

examplesensor {
    compatible = "zephyr,examplesensor";
    reg = <0>; 
    spi-max-frequency = <1000000>;
    height = <480>;
    width = <320>;
};

compatible: "zephyr,examplesensor"

include: [spi-device.yaml, display-controller.yaml]

properties:
reg:
type: array
required: true
description: SPI chip select for the display

spi-max-frequency:
type: int
required: true
description: Maximum SPI clock frequency in Hz

display-type:
type: string
required: true
description: Type of display connected
enum: [LCD, OLED]

status:
type: string
description: Device status
default: "okay"

height:
type: int
required: true
description: Height of the display in pixels

width:
type: int
required: true
description: Width of the display in pixels

disp_miso_en_gpios:
description: Data/Command (DC) GPIO pin for the display
type: phandle-array
required: true

---

Kconfig for examplesensor

---

Copyright (c) 2021 Nordic Semiconductor ASA

SPDX-License-Identifier: Apache-2.0

menu "Sensor Drivers"

config SENSOR_EXAMPLESENSOR
bool "Example Sensor Driver"
depends on SENSOR
help
Enable support for the Example Sensor.

if SENSOR_EXAMPLESENSOR
source "drivers/sensor/examplesensor/Kconfig"
endif

endmenu

---

dts file

---

/dts-v1/;
#include <nordic/nrf52840_qiaa.dtsi>
#include "f200-pinctrl.dtsi"

/ {
model = "Custom Board auto generated by nRF Connect for VS Code";
compatible = "blinky_1,f200";

chosen {
    zephyr,sram = &sram0;
    zephyr,flash = &flash0;
    zephyr,code-partition = &slot0_partition;
    zephyr,display = &mdispidisplay;
};

};

&flash0 {
partitions {
compatible = "fixed-partitions";
#address-cells = <1>;
#size-cells = <1>;

    boot_partition: partition@0 {
        label = "mcuboot";
        reg = <0x00000000 DT_SIZE_K(48)>;
    };

    slot0_partition: partition@c000 {
        label = "image-0";
        reg = <0x0000c000 DT_SIZE_K(472)>;
    };

    slot1_partition: partition@82000 {
        label = "image-1";
        reg = <0x00082000 DT_SIZE_K(472)>;
    };

    storage_partition: partition@f8000 {
        label = "storage";
        reg = <0x000f8000 DT_SIZE_K(32)>;
    };
};

};

&pinctrl {
spi0_default: spi0_default {
};
};

&spi0 {
status = "okay";
pinctrl-0 = <&spi0_default>;
pinctrl-names = "default";
};

&gpio0 {
status = "okay";
};

&gpiote0 {
status = "okay";
};

&spi1 {
mdispidisplay: examplesensor@0 {
compatible = "zephyr,examplesensor";
reg = <0x0>;
spi-max-frequency = <1000000>;
display-type = "LCD";
height = <122>;
width = <250>;
status = "okay";
disp_miso_en_gpios = <&gpio0 8 GPIO_ACTIVE_HIGH>;
};

status = "okay";
pinctrl-0 = <&spi1_default>;
pinctrl-names = "default";
cs-gpios = <&gpio0 16 GPIO_ACTIVE_HIGH>;

};

&pinctrl {
spi1_default: spi1_default {
group1 {
psels = <NRF_PSEL(SPIM_MOSI, 0, 12)>, <NRF_PSEL(SPIM_SCK, 0, 11)>;
};
};
};

---

main.c

---

/*

• Copyright (c) 2018 Jan Van Winkel [email protected]
• SPDX-License-Identifier: Apache-2.0
  */

#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/display.h>
#include <zephyr/drivers/gpio.h>
#include <lvgl.h>
#include <stdio.h>
#include <string.h>
#include <zephyr/kernel.h>
#include <lvgl_input_device.h>
#include <zephyr/drivers/pwm.h>

#define LOG_LEVEL CONFIG_LOG_DEFAULT_LEVEL
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(app);

static uint32_t count;

// #ifdef CONFIG_GPIO
// static struct gpio_dt_spec button_gpio = GPIO_DT_SPEC_GET_OR(
// DT_ALIAS(sw0), gpios, {0});
// static struct gpio_callback button_callback;

// static void button_isr_callback(const struct device *port,
// struct gpio_callback *cb,
// uint32_t pins)
// {
// ARG_UNUSED(port);
// ARG_UNUSED(cb);
// ARG_UNUSED(pins);

// count = 0;
// }
// static void lv_btn_click_callback(lv_event_t *e)
// {
// ARG_UNUSED(e);

// count = 0;
// }

int main(void)
{
char count_str[11] = {0};
const struct device *display_dev;
lv_obj_t *hello_world_label;
lv_obj_t *count_label;

// const struct pwm_dt_spec EXTCOMIN = PWM_DT_SPEC_GET(DT_NODELABEL(pwm_led1));
// LOG_INF("EXTCOMIN:%i", pwm_set_dt(&EXTCOMIN, PWM_MSEC(16), PWM_MSEC(1)));

display_dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_display));
if (!device_is_ready(display_dev)) {
	LOG_ERR("Device not ready, aborting test");
	return 0;
}

// #ifdef CONFIG_GPIO
// if (gpio_is_ready_dt(&button_gpio)) {
// int err;

// err = gpio_pin_configure_dt(&button_gpio, GPIO_INPUT);
// if (err) {
// LOG_ERR("failed to configure button gpio: %d", err);
// return 0;
// }

// gpio_init_callback(&button_callback, button_isr_callback,
// BIT(button_gpio.pin));

// err = gpio_add_callback(button_gpio.port, &button_callback);
// if (err) {
// LOG_ERR("failed to add button callback: %d", err);
// return 0;
// }

// err = gpio_pin_interrupt_configure_dt(&button_gpio,
// GPIO_INT_EDGE_TO_ACTIVE);
// if (err) {
// LOG_ERR("failed to enable button callback: %d", err);
// return 0;
// }
// }
// #endif /* CONFIG_GPIO */

#ifdef CONFIG_LV_Z_ENCODER_INPUT
lv_obj_t *arc;
lv_group_t *arc_group;

arc = lv_arc_create(lv_scr_act());
lv_obj_align(arc, LV_ALIGN_CENTER, 0, 0);
lv_obj_set_size(arc, 150, 150);

arc_group = lv_group_create();
lv_group_add_obj(arc_group, arc);
lv_indev_set_group(lvgl_input_get_indev(lvgl_encoder), arc_group);

#endif /* CONFIG_LV_Z_ENCODER_INPUT */

if (IS_ENABLED(CONFIG_LV_Z_POINTER_KSCAN) || IS_ENABLED(CONFIG_LV_Z_POINTER_INPUT)) {
	lv_obj_t *hello_world_button;

	hello_world_button = lv_btn_create(lv_scr_act());
	lv_obj_align(hello_world_button, LV_ALIGN_CENTER, 0, 0);
	// lv_obj_add_event_cb(hello_world_button, lv_btn_click_callback, LV_EVENT_CLICKED,
	// 				NULL);
	hello_world_label = lv_label_create(hello_world_button);
} else {
	hello_world_label = lv_label_create(lv_scr_act());
}

lv_label_set_text(hello_world_label, "Hello Patrick!");
lv_obj_align(hello_world_label, LV_ALIGN_CENTER, 0, 0);

count_label = lv_label_create(lv_scr_act());
lv_obj_align(count_label, LV_ALIGN_BOTTOM_MID, 0, 0);

lv_task_handler();
display_blanking_off(display_dev);

while (1) {
	if ((count % 100) == 0U) {
		sprintf(count_str, "%d", count/100U);
		lv_label_set_text(count_label, count_str);
	}
	lv_task_handler();
	++count;
	k_sleep(K_MSEC(10));
}

}

---

CMakeLists.txt (TOP Level)

---

cmake_minimum_required(VERSION 3.20.0)

Find and include Zephyr

find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(blinky_1)

Include application source files

target_sources(app PRIVATE src/main.c drivers/sensor/examplesensor/examplesensor.c)

Add subdirectory for custom drivers if they exist

if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/drivers)
add_subdirectory(drivers)
endif()

Include directories for custom drivers

zephyr_include_directories(drivers/sensor/examplesensor)

Link application to Zephyr

target_link_libraries(app PRIVATE zephyr)

Optional: Suppress regeneration messages

set(CMAKE_SUPPRESS_REGENERATION TRUE)

---

CMakeLists.txt (examplesensor)

---

add_subdirectory_ifdef(CONFIG_EXAMPLESENSOR examplesensor)

---

Hoping to get help fast as my project is much delayed.

[faxe1008]

Hi @dkjLC

Contributions are always welcome, but please open a pull request. If you want to a new driver you do not need to create an issue beforehand. Issues are for RFCs and bugreports primarily.

If you are not sure how to do that (saw that you do not have any repo on your profile) I'd suggest on reading and practicing git.

Happy hacking :^)

[dkjLC]

How to open pull request i don't know and when i tried to open it shows that you are not a collaborator.

[pdgendt]

The documentation doesn't describe how to open pull requests on Github, I think, but you should read up on https://docs.zephyrproject.org/latest/contribute/index.html for contribution guidelines.

For creating a pull request, read the Github documentation at https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request

[dkjLC]

Can anyone help i have developed it but its not compiling showing "_device_dts_ord_19" error due to which i cannot test on my device.

I have attached the zip file which contain whole my project.

Thanks in advance!!

ST7305.zip