screen_test_disp_mem.c File Reference

#include "gui.h"
#include "config.h"
#include "window_logo.h"
#include "stm32f4xx_hal.h"
#include "st7789v.h"
#include "sys.h"
#include <assert.h>

Classes
struct	screen_test_disp_mem_data_t

Macros
#define	pd   ((screen_test_disp_mem_data_t *)screen->pdata)
#define	opt_spi_sz   (sizeof(opt_spi) / sizeof(const char *))
#define	modes_sz   (sizeof(modes) / sizeof(const char *))
#define	inversions_sz   (sizeof(inversions) / sizeof(const char *))
#define	bright_enas_sz   (sizeof(bright_enas) / sizeof(const char *))
#define	fptrArr_sz   (sizeof(fptrArr) / sizeof(drawCol_t *))
#define	RECT_MACRO(col)   rect_ui16(col_##col, row2draw, col_##col##_w, row_h)
#define	directColorBuff_sz   20

Typedefs
typedef void()	drawCol_t(size_t rect_index, size_t rect_count, size_t col, size_t row2draw, size_t row_space)

Enumerations
enum	{ col_0 = 2, col_1 = 96 }
enum	{ col_0_w = col_1 - col_0, col_1_w = 240 - col_1 - col_0 }
enum	{ col_2_w = 38 }
enum	{ TAG_QUIT = 10, TAG_BRIGHTNESS }

Functions
int	sim_heater_temp2val (float temp)
void	window_list_spi_item (window_list_t *pwindow_list, uint16_t index, const char **pptext, uint16_t *pid_icon)
void	window_list_modes_item (window_list_t *pwindow_list, uint16_t index, const char **pptext, uint16_t *pid_icon)
void	window_list_inversions_item (window_list_t *pwindow_list, uint16_t index, const char **pptext, uint16_t *pid_icon)
void	window_list_bright_enas_item (window_list_t *pwindow_list, uint16_t index, const char **pptext, uint16_t *pid_icon)
void	drawCol (size_t col, size_t row, size_t len, uint16_t directColor)
void	drawCol_buff (size_t col, size_t row, size_t len, uint16_t *directColorBuff)
void	readCol (size_t col, size_t row, size_t len, uint16_t *directColorBuff)
void	draw_read_drawCol (size_t col, size_t row, size_t row_space, size_t len, uint16_t directColor, uint16_t *directColorBuff)
void	draw_read_drawRect (size_t col, size_t row, size_t len, size_t w, uint16_t directColor, uint16_t *directColorBuff)
size_t	dispRamTest_NextCol (size_t row_pos, size_t rect_w, size_t rect_space, size_t rect_count, size_t border_w)
int	_getRectIndex (size_t col_x, size_t rect_w, size_t rect_space, size_t border_w)
void	dispRamTest (size_t test_ID, size_t row)
void	printRGBWscale (size_t rect_index, size_t rect_count, size_t col, size_t row, size_t row_space)
void	printDirectHex (size_t rect_index, size_t rect_count, size_t col, size_t row, size_t row_space)
void	printRGB (size_t rect_index, size_t rect_count, size_t col, size_t row, size_t row_space)
void	printRGB_DirHx (size_t rect_index, size_t rect_count, size_t col, size_t row, size_t row_space)
void	screen_test_disp_mem_init (screen_t *screen)
void	screen_test_disp_mem_done (screen_t *screen)
void	screen_test_disp_mem_draw (screen_t *screen)
int	screen_test_disp_mem_event (screen_t *screen, window_t *window, uint8_t event, void *param)

Variables
int16_t	spi_prescaler
static const char *	opt_spi [] = { "21M", "10.5M", "5.25M", "2.63M", "1.31M", "656k", "328k", "164k" }
static const char *	modes [] = { "RGBW scale", "WrRdWr + RGB" }
static const char *	inversions [] = { "Inv. DIS.", "Inv. ENA." }
static const char *	bright_enas [] = { "Bri. DIS.", "Bri. ENA." }
static int16_t	spinSpiClkVal_last = -1
static int16_t	spinSpiClkVal_actual = -1
static int16_t	mode = 0
static int16_t	user_value = 0
static int16_t	row2draw
static uint8_t	clrR = 0
static uint8_t	clrG = 0
static uint8_t	clrB = 0
static int16_t	gamma_last = -1
static int16_t	gamma_actual = -1
static int16_t	brightness_last = -1
static int16_t	brightness_actual = -1
static int8_t	isInverted_last = -1
static int8_t	isInverted_actual = -1
static int8_t	isBrightness_ena_last = -1
static int8_t	isBrightness_ena_actual = -1
drawCol_t *	fptrArr [] = { printRGBWscale, printRGB_DirHx }
uint16_t	directColorBuff [directColorBuff_sz]
screen_t	screen_test_disp_mem
const screen_t *	pscreen_test_disp_mem = &screen_test_disp_mem

Macro Definition Documentation

pd

#define pd   ((screen_test_disp_mem_data_t *)screen->pdata)

opt_spi_sz

#define opt_spi_sz   (sizeof(opt_spi) / sizeof(const char *))

modes_sz

#define modes_sz   (sizeof(modes) / sizeof(const char *))

inversions_sz

#define inversions_sz   (sizeof(inversions) / sizeof(const char *))

bright_enas_sz

#define bright_enas_sz   (sizeof(bright_enas) / sizeof(const char *))

fptrArr_sz

#define fptrArr_sz   (sizeof(fptrArr) / sizeof(drawCol_t *))

RECT_MACRO

#define RECT_MACRO

(

col

)

rect_ui16(col_##col, row2draw, col_##col##_w, row_h)

directColorBuff_sz

#define directColorBuff_sz   20

Typedef Documentation

drawCol_t

typedef void() drawCol_t(size_t rect_index, size_t rect_count, size_t col, size_t row2draw, size_t row_space)

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
col_0
col_1

     { col_0 = 2,
    col_1 = 96 };

anonymous enum

anonymous enum

Enumerator
col_0_w
col_1_w

     { col_0_w = col_1 - col_0,
    col_1_w = 240 - col_1 - col_0 };

anonymous enum

anonymous enum

Enumerator
col_2_w

{ col_2_w = 38 };

anonymous enum

anonymous enum

Enumerator
TAG_QUIT
TAG_BRIGHTNESS

     {
    TAG_QUIT = 10,
    TAG_BRIGHTNESS
 
};

Function Documentation

sim_heater_temp2val()

int sim_heater_temp2val

(

float

temp

)

window_list_spi_item()

void window_list_spi_item	(	window_list_t *	pwindow_list,
		uint16_t	index,
		const char **	pptext,
		uint16_t *	pid_icon
	)

                                             {
    if (index < opt_spi_sz)
        *pptext = (char *)opt_spi[index];
    else
        *pptext = "Index ERROR";
    *pid_icon = 0;
}

Here is the caller graph for this function:

window_list_modes_item()

void window_list_modes_item	(	window_list_t *	pwindow_list,
		uint16_t	index,
		const char **	pptext,
		uint16_t *	pid_icon
	)

                                             {
    if (index < modes_sz)
        *pptext = (char *)modes[index];
    else
        *pptext = "Index ERROR";
    *pid_icon = 0;
}

Here is the caller graph for this function:

window_list_inversions_item()

void window_list_inversions_item	(	window_list_t *	pwindow_list,
		uint16_t	index,
		const char **	pptext,
		uint16_t *	pid_icon
	)

                                             {
    if (index < inversions_sz)
        *pptext = (char *)inversions[index];
    else
        *pptext = "Index ERROR";
    *pid_icon = 0;
}

Here is the caller graph for this function:

window_list_bright_enas_item()

void window_list_bright_enas_item	(	window_list_t *	pwindow_list,
		uint16_t	index,
		const char **	pptext,
		uint16_t *	pid_icon
	)

                                             {
    if (index < bright_enas_sz)
        *pptext = (char *)bright_enas[index];
    else
        *pptext = "Index ERROR";
    *pid_icon = 0;
}

Here is the caller graph for this function:

drawCol()

void drawCol	(	size_t	col,
		size_t	row,
		size_t	len,
		uint16_t	directColor
	)

                                                                       {
    for (size_t i = 0; i < len; ++i) {
        st7789v_set_pixel_directColor(point_ui16(col, row + i), directColor);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

drawCol_buff()

void drawCol_buff	(	size_t	col,
		size_t	row,
		size_t	len,
		uint16_t *	directColorBuff
	)

                                                                                 {
    for (size_t i = 0; i < len; ++i) {
        st7789v_set_pixel_directColor(point_ui16(col, row + i), directColorBuff[i]);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

readCol()

void readCol	(	size_t	col,
		size_t	row,
		size_t	len,
		uint16_t *	directColorBuff
	)

                                                                            {
    for (size_t i = 0; i < len; ++i) {
        directColorBuff[i] = st7789v_get_pixel_directColor(point_ui16(col, row + i));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

draw_read_drawCol()

void draw_read_drawCol	(	size_t	col,
		size_t	row,
		size_t	row_space,
		size_t	len,
		uint16_t	directColor,
		uint16_t *	directColorBuff
	)

                                                                                                                              {
    drawCol(col, row, len, directColor);
    readCol(col, row, len, directColorBuff);
    drawCol_buff(col, row + len + row_space, len, directColorBuff);
}

Here is the call graph for this function:

Here is the caller graph for this function:

draw_read_drawRect()

void draw_read_drawRect	(	size_t	col,
		size_t	row,
		size_t	len,
		size_t	w,
		uint16_t	directColor,
		uint16_t *	directColorBuff
	)

dispRamTest_NextCol()

size_t dispRamTest_NextCol	(	size_t	row_pos,
		size_t	rect_w,
		size_t	rect_space,
		size_t	rect_count,
		size_t	border_w
	)

                                                                                                                 {
    const size_t col_pos_end = border_w + rect_count * rect_w + (rect_count - 1) * rect_space;
 
    ++col_pos;
    if (col_pos >= col_pos_end)
        return border_w;
    if (col_pos < border_w)
        return border_w;
 
    if (_getRectIndex(col_pos, rect_w, rect_space, border_w) == -1)
        col_pos += rect_space;
    return col_pos;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_getRectIndex()

int _getRectIndex	(	size_t	col_x,
		size_t	rect_w,
		size_t	rect_space,
		size_t	border_w
	)

                                                                                   {
    col_x -= border_w;
    size_t mod = col_x % (rect_w + rect_space);
    size_t div = col_x / (rect_w + rect_space);
    if (mod >= rect_w)
        return -1;
    return div;
}

Here is the caller graph for this function:

dispRamTest()

void dispRamTest	(	size_t	test_ID,
		size_t	row
	)

                                             {
    //const size_t wr_rows       = 20;
 
    const size_t rect_w = 12;
    const size_t rect_space = 1;
    const size_t rect_count = 16;
    const size_t border_w = (display->w - (rect_w + rect_space) * rect_count) / 2;
    const size_t row_space = 1;
    const uint32_t ttl = 45; //time to live
 
    static size_t col_pos = -1;
    static uint32_t start_time = 0;
 
    start_time = HAL_GetTick();
 
    //ttl check - to be responsive
    while (start_time + ttl >= HAL_GetTick()) {
        col_pos = dispRamTest_NextCol(col_pos, rect_w, rect_space, rect_count, border_w);
        size_t rect_index = _getRectIndex(col_pos, rect_w, rect_space, border_w);
 
        if (test_ID < sizeof(fptrArr) / sizeof(drawCol_t *))
            fptrArr[test_ID](rect_index, rect_count, col_pos, row, row_space);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

printRGBWscale()

void printRGBWscale	(	size_t	rect_index,
		size_t	rect_count,
		size_t	col,
		size_t	row,
		size_t	row_space
	)

                                                                                                    {
    color_t clr;
    uint32_t val = 0xff * rect_index / rect_count;
 
    //R
    clr = color_rgb(val, 0, 0);
    display->draw_line(point_ui16(col, row), point_ui16(col, row + directColorBuff_sz), clr);
 
    //G
    clr = color_rgb(0, val, 0);
    row += directColorBuff_sz + row_space;
    display->draw_line(point_ui16(col, row), point_ui16(col, row + directColorBuff_sz), clr);
 
    //B
    clr = color_rgb(0, 0, val);
    row += directColorBuff_sz + row_space;
    display->draw_line(point_ui16(col, row), point_ui16(col, row + directColorBuff_sz), clr);
 
    //W
    clr = color_rgb(val, val, val);
    row += directColorBuff_sz + row_space;
    display->draw_line(point_ui16(col, row), point_ui16(col, row + directColorBuff_sz), clr);
}

Here is the call graph for this function:

printDirectHex()

void printDirectHex	(	size_t	rect_index,
		size_t	rect_count,
		size_t	col,
		size_t	row,
		size_t	row_space
	)

                                                                                                    {
    draw_read_drawCol(col, row, row_space, directColorBuff_sz, user_value, directColorBuff);
}

Here is the call graph for this function:

Here is the caller graph for this function:

printRGB()

void printRGB	(	size_t	rect_index,
		size_t	rect_count,
		size_t	col,
		size_t	row,
		size_t	row_space
	)

                                                                                              {
    color_t clr = color_rgb(clrR, clrG, clrB);
    display->draw_line(point_ui16(col, row), point_ui16(col, row + directColorBuff_sz), clr);
 
    clr = color_rgb((uint8_t)(~clrR), (uint8_t)(~clrG), (uint8_t)(~clrB));
    row += directColorBuff_sz + row_space;
    display->draw_line(point_ui16(col, row), point_ui16(col, row + directColorBuff_sz), clr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

printRGB_DirHx()

void printRGB_DirHx	(	size_t	rect_index,
		size_t	rect_count,
		size_t	col,
		size_t	row,
		size_t	row_space
	)

                                                                                                    {
    printDirectHex(rect_index, rect_count, col, row, row_space);
    printRGB(rect_index, rect_count, col, row + 2 * (directColorBuff_sz + row_space), row_space);
}

Here is the call graph for this function:

screen_test_disp_mem_init()

void screen_test_disp_mem_init

(

screen_t *

screen

)

                                                 {
    row2draw = 0;
    int16_t id;
    int16_t row_h = 22; //item_height from list
 
    int16_t id0 = window_create_ptr(WINDOW_CLS_FRAME, -1, rect_ui16(0, 0, 0, 0), &(pd->frame));
 
    id = window_create_ptr(WINDOW_CLS_TEXT, id0, rect_ui16(0, 0, display->w, 22), &(pd->textMenuName));
    pd->textMenuName.font = resource_font(IDR_FNT_BIG);
    window_set_text(id, (const char *)"Disp. TEST rd mem.");
 
    row2draw += 25;
 
    //write pattern
    id = window_create_ptr(WINDOW_CLS_TEXT, id0, RECT_MACRO(0), &(pd->textMode));
    pd->textMode.font = resource_font(IDR_FNT_NORMAL);
    window_set_text(id, (const char *)"MODE");
 
    id = window_create_ptr(WINDOW_CLS_LIST, id0, RECT_MACRO(1), &(pd->spinMode));
    window_set_item_count(id, modes_sz);
    window_set_item_index(id, 0);
    window_set_item_callback(id, window_list_modes_item);
 
    row2draw += 25;
 
    //clk setting
    id = window_create_ptr(WINDOW_CLS_TEXT, id0, RECT_MACRO(0), &(pd->textSpiClk));
    pd->textSpiClk.font = resource_font(IDR_FNT_NORMAL);
    window_set_text(id, (const char *)"SPI clk");
 
    id = window_create_ptr(WINDOW_CLS_LIST, id0, RECT_MACRO(1), &(pd->spinSpiClk));
    window_set_item_count(id, opt_spi_sz);
    window_set_item_index(id, 0);
    window_set_item_callback(id, window_list_spi_item);
 
    row2draw += 25;
 
    //Gamma setting
    id = window_create_ptr(WINDOW_CLS_TEXT, id0, RECT_MACRO(0), &(pd->textGamma));
    pd->textMode.font = resource_font(IDR_FNT_NORMAL);
    window_set_text(id, (const char *)"Gamma");
 
    id = window_create_ptr(WINDOW_CLS_SPIN, id0, rect_ui16(col_1, row2draw, col_2_w, row_h), &(pd->spinGamma));
    window_set_format(id, "%1.0f");
    window_set_min_max_step(id, 0.0F, 3.0F, 1.0F);
    window_set_value(id, (float)st7789v_gamma_get());
 
    //INVERSION
    id = window_create_ptr(WINDOW_CLS_LIST, id0, rect_ui16(col_1 + col_2_w, row2draw, col_1_w - col_2_w, row_h), &(pd->spinInversion));
    window_set_item_count(id, inversions_sz);
    window_set_item_index(id, 0);
    window_set_item_callback(id, window_list_inversions_item);
 
    row2draw += 25;
    //Brightness setting
    id = window_create_ptr(WINDOW_CLS_TEXT, id0, RECT_MACRO(0), &(pd->textBrightness));
    pd->textMode.font = resource_font(IDR_FNT_NORMAL);
    window_set_text(id, (const char *)"Brightn.");
 
    id = window_create_ptr(WINDOW_CLS_SPIN, id0, rect_ui16(col_1, row2draw, col_2_w, row_h), &(pd->spinBrightness));
    window_set_format(id, "%1.0f");
    window_set_min_max_step(id, 0.0F, 255.0F, 5.0F);
    window_set_value(id, (float)st7789v_brightness_get());
    window_set_tag(id, TAG_BRIGHTNESS);
 
    //Brightness enabled
    id = window_create_ptr(WINDOW_CLS_LIST, id0, rect_ui16(col_1 + col_2_w, row2draw, col_1_w - col_2_w, row_h), &(pd->spinBrigt_ena));
    window_set_item_count(id, bright_enas_sz);
    window_set_item_index(id, 0);
    window_set_item_callback(id, window_list_bright_enas_item);
    window_set_tag(id, TAG_BRIGHTNESS);
 
    row2draw += 25;
    int16_t w_of_0x = 23;
    int16_t col = col_1 + w_of_0x;
    int16_t offset = 12;
    //user write pattern
    id = window_create_ptr(WINDOW_CLS_TEXT, id0, RECT_MACRO(0), &(pd->textSpiUserPattern1));
    pd->textMode.font = resource_font(IDR_FNT_NORMAL);
    window_set_text(id, (const char *)"Wr-Rd-Wr");
    id = window_create_ptr(WINDOW_CLS_TEXT, id0, RECT_MACRO(1), &(pd->text0x));
    pd->textMode.font = resource_font(IDR_FNT_NORMAL);
    window_set_text(id, (const char *)"0x");
 
    //cannot use normal spin with window_set_format(id, "%A");
    id = window_create_ptr(WINDOW_CLS_SPIN, id0, rect_ui16(col, row2draw, offset, row_h), &(pd->spinStrHx3));
    pd->spinStrHx3.window.win.flg |= WINDOW_FLG_NUMB_FLOAT2INT;
    window_set_format(id, "%X");
    window_set_min_max_step(id, 0.0F, 15.0F, 1.0F);
    window_set_value(id, 0.0F);
    col += offset;
    id = window_create_ptr(WINDOW_CLS_SPIN, id0, rect_ui16(col, row2draw, offset, row_h), &(pd->spinStrHx2));
    pd->spinStrHx2.window.win.flg |= WINDOW_FLG_NUMB_FLOAT2INT;
    window_set_format(id, "%X");
    window_set_min_max_step(id, 0.0F, 15.0F, 1.0F);
    window_set_value(id, 0.0F);
    col += offset;
    id = window_create_ptr(WINDOW_CLS_SPIN, id0, rect_ui16(col, row2draw, offset, row_h), &(pd->spinStrHx1));
    pd->spinStrHx1.window.win.flg |= WINDOW_FLG_NUMB_FLOAT2INT;
    window_set_format(id, "%X");
    window_set_min_max_step(id, 0.0F, 15.0F, 1.0F);
    window_set_value(id, 0.0F);
    col += offset;
    id = window_create_ptr(WINDOW_CLS_SPIN, id0, rect_ui16(col, row2draw, offset, row_h), &(pd->spinStrHx0));
    pd->spinStrHx0.window.win.flg |= WINDOW_FLG_NUMB_FLOAT2INT;
    window_set_format(id, "%X");
    window_set_min_max_step(id, 0.0F, 15.0F, 1.0F);
    window_set_value(id, 0.0F);
 
    //write pixels
    row2draw += 25;
    int16_t w_of_0xX = 48;
    int16_t RGBspaceW = 5;
 
    col = col_0;
    id = window_create_ptr(WINDOW_CLS_TEXT, id0, rect_ui16(col, row2draw, w_of_0xX, row_h), &(pd->textR0x));
    pd->textMode.font = resource_font(IDR_FNT_NORMAL);
    window_set_text(id, (const char *)"R 0x");
    window_set_color_text(id, COLOR_RED);
 
    col += w_of_0xX;
    id = window_create_ptr(WINDOW_CLS_SPIN, id0, rect_ui16(col, row2draw, offset, row_h), &(pd->spinStrR0));
    pd->spinStrR0.window.win.flg |= WINDOW_FLG_NUMB_FLOAT2INT;
    window_set_format(id, "%X");
    window_set_min_max_step(id, 0.0F, 15.0F, 1.0F);
    window_set_value(id, 0.0F);
 
    col += offset;
    id = window_create_ptr(WINDOW_CLS_SPIN, id0, rect_ui16(col, row2draw, offset, row_h), &(pd->spinStrR1));
    pd->spinStrR1.window.win.flg |= WINDOW_FLG_NUMB_FLOAT2INT;
    window_set_format(id, "%X");
    window_set_min_max_step(id, 0.0F, 15.0F, 1.0F);
    window_set_value(id, 0.0F);
    col += offset;
    col += RGBspaceW;
 
    id = window_create_ptr(WINDOW_CLS_TEXT, id0, rect_ui16(col, row2draw, w_of_0xX, row_h), &(pd->textG0x));
    pd->textMode.font = resource_font(IDR_FNT_NORMAL);
    window_set_text(id, (const char *)"G 0x");
    window_set_color_text(id, COLOR_GREEN);
 
    col += w_of_0xX;
    id = window_create_ptr(WINDOW_CLS_SPIN, id0, rect_ui16(col, row2draw, offset, row_h), &(pd->spinStrG0));
    pd->spinStrG0.window.win.flg |= WINDOW_FLG_NUMB_FLOAT2INT;
    window_set_format(id, "%X");
    window_set_min_max_step(id, 0.0F, 15.0F, 1.0F);
    window_set_value(id, 0.0F);
    col += offset;
    id = window_create_ptr(WINDOW_CLS_SPIN, id0, rect_ui16(col, row2draw, offset, row_h), &(pd->spinStrG1));
    pd->spinStrG1.window.win.flg |= WINDOW_FLG_NUMB_FLOAT2INT;
    window_set_format(id, "%X");
    window_set_min_max_step(id, 0.0F, 15.0F, 1.0F);
    window_set_value(id, 0.0F);
    col += offset;
    col += RGBspaceW;
 
    id = window_create_ptr(WINDOW_CLS_TEXT, id0, rect_ui16(col, row2draw, w_of_0xX, row_h), &(pd->textB0x));
    pd->textMode.font = resource_font(IDR_FNT_NORMAL);
    window_set_text(id, (const char *)"B 0x");
    window_set_color_text(id, COLOR_BLUE);
 
    col += w_of_0xX;
    id = window_create_ptr(WINDOW_CLS_SPIN, id0, rect_ui16(col, row2draw, offset, row_h), &(pd->spinStrB0));
    pd->spinStrB0.window.win.flg |= WINDOW_FLG_NUMB_FLOAT2INT;
    window_set_format(id, "%X");
    window_set_min_max_step(id, 0.0F, 15.0F, 1.0F);
    window_set_value(id, 0.0F);
    col += offset;
    id = window_create_ptr(WINDOW_CLS_SPIN, id0, rect_ui16(col, row2draw, offset, row_h), &(pd->spinStrB1));
    pd->spinStrB1.window.win.flg |= WINDOW_FLG_NUMB_FLOAT2INT;
    window_set_format(id, "%X");
    window_set_min_max_step(id, 0.0F, 15.0F, 1.0F);
    window_set_value(id, 0.0F);
 
    row2draw += 25; //position for drawing - it is global in this file
 
    id = window_create_ptr(WINDOW_CLS_TEXT, id0, rect_ui16(col_0, 290, 60, 22), &(pd->textExit));
    pd->textExit.font = resource_font(IDR_FNT_BIG);
    window_set_text(id, (const char *)"EXIT");
    window_enable(id);
    window_set_tag(id, TAG_QUIT);
}

Here is the call graph for this function:

screen_test_disp_mem_done()

void screen_test_disp_mem_done

(

screen_t *

screen

)

                                                 {
    window_destroy(pd->frame.win.id);
}

Here is the call graph for this function:

screen_test_disp_mem_draw()

void screen_test_disp_mem_draw

(

screen_t *

screen

)

                                                 {
}

screen_test_disp_mem_event()

int screen_test_disp_mem_event	(	screen_t *	screen,
		window_t *	window,
		uint8_t	event,
		void *	param
	)

                                                                                               {
    if (event == WINDOW_EVENT_CLICK)
        switch ((int)param) {
        case TAG_QUIT:
            screen_close();
            return 1;
        }
    /*if (event == WINDOW_EVENT_CHANGE){
        switch ((int)param){
        case TAG_BRIGHTNESS:
            isBrightness_ena_actual = window_get_item_index(pd->spinBrigt_ena.window.win.id);
            //if(isBrightness_ena_actual!=isBrightness_ena_last)
            {
                if(isBrightness_ena_actual) st7789v_brightness_enable();
                else                        st7789v_brightness_disable();
                isBrightness_ena_last = isBrightness_ena_actual;
            }
 
 
            brightness_actual = window_get_item_index(pd->spinBrightness.window.win.id);
            //if(brightness_actual!=brightness_last)
            {
                st7789v_brightness_set(brightness_actual);
                brightness_last = brightness_actual;
            }
            break;
        }
 
    }*/
    if (event == WINDOW_EVENT_LOOP) {
 
        isBrightness_ena_actual = window_get_item_index(pd->spinBrigt_ena.win.id);
        brightness_actual = window_get_value(pd->spinBrightness.window.win.id);
 
        if ((isBrightness_ena_actual != isBrightness_ena_last) || (brightness_actual != brightness_last)) {
            st7789v_brightness_set(brightness_actual);
            brightness_last = brightness_actual;
 
            if (isBrightness_ena_actual)
                st7789v_brightness_enable();
            else
                st7789v_brightness_disable();
            isBrightness_ena_last = isBrightness_ena_actual;
        }
 
        mode = window_get_item_index(pd->spinMode.win.id);
 
        user_value = window_get_item_index(pd->spinStrHx0.window.win.id)
            | ((window_get_item_index(pd->spinStrHx1.window.win.id)) << 4)
            | ((window_get_item_index(pd->spinStrHx2.window.win.id)) << 8)
            | ((window_get_item_index(pd->spinStrHx3.window.win.id)) << 12);
 
        clrR = (window_get_item_index(pd->spinStrR0.window.win.id) << 4) | window_get_item_index(pd->spinStrR1.window.win.id);
        clrG = (window_get_item_index(pd->spinStrG0.window.win.id) << 4) | window_get_item_index(pd->spinStrG1.window.win.id);
        clrB = (window_get_item_index(pd->spinStrB0.window.win.id) << 4) | window_get_item_index(pd->spinStrB1.window.win.id);
 
        gamma_actual = window_get_item_index(pd->spinGamma.window.win.id);
        if (gamma_actual != gamma_last) {
            st7789v_gamma_set(gamma_actual);
            gamma_last = gamma_actual;
        }
 
        isInverted_actual = window_get_item_index(pd->spinInversion.win.id);
        if (isInverted_actual != isInverted_last) {
            if (isInverted_actual)
                st7789v_inversion_on();
            else
                st7789v_inversion_off();
            isInverted_last = isInverted_actual;
        }
 
        //check if spin changed
        spinSpiClkVal_actual = window_get_item_index(pd->spinSpiClk.win.id);
        if (spinSpiClkVal_actual != spinSpiClkVal_last) {
            sys_spi_set_prescaler(spinSpiClkVal_actual);
            spinSpiClkVal_last = spinSpiClkVal_actual;
            //window_set_text(pd->numbSpiClk.win.id,(const char*)opt_spi[spinSpiClkVal_actual]);
        }
 
        dispRamTest(mode, row2draw);
    }
 
    return 0;
}

Here is the call graph for this function:

Variable Documentation

spi_prescaler

int16_t spi_prescaler

opt_spi

const char* opt_spi[] = { "21M", "10.5M", "5.25M", "2.63M", "1.31M", "656k", "328k", "164k" }

static

modes

const char* modes[] = { "RGBW scale", "WrRdWr + RGB" }

static

inversions

const char* inversions[] = { "Inv. DIS.", "Inv. ENA." }

static

bright_enas

const char* bright_enas[] = { "Bri. DIS.", "Bri. ENA." }

static

spinSpiClkVal_last

int16_t spinSpiClkVal_last = -1

static

spinSpiClkVal_actual

int16_t spinSpiClkVal_actual = -1

static

mode

int16_t mode = 0

static

user_value

int16_t user_value = 0

static

row2draw

int16_t row2draw

static

clrR

uint8_t clrR = 0

static

clrG

uint8_t clrG = 0

static

clrB

uint8_t clrB = 0

static

gamma_last

int16_t gamma_last = -1

static

gamma_actual

int16_t gamma_actual = -1

static

brightness_last

int16_t brightness_last = -1

static

brightness_actual

int16_t brightness_actual = -1

static

isInverted_last

int8_t isInverted_last = -1

static

isInverted_actual

int8_t isInverted_actual = -1

static

isBrightness_ena_last

int8_t isBrightness_ena_last = -1

static

isBrightness_ena_actual

int8_t isBrightness_ena_actual = -1

static

fptrArr

drawCol_t* fptrArr[] = { printRGBWscale, printRGB_DirHx }

directColorBuff

uint16_t directColorBuff[directColorBuff_sz]

screen_test_disp_mem

screen_t screen_test_disp_mem

Initial value:

= {
    0,
    0,
    screen_test_disp_mem_init,
    screen_test_disp_mem_done,
    screen_test_disp_mem_draw,
    screen_test_disp_mem_event,
    sizeof(screen_test_disp_mem_data_t), 
    0, 
}

pscreen_test_disp_mem

const screen_t* pscreen_test_disp_mem = &screen_test_disp_mem