multi-page and displaying text in Realtime

[Qtakruri]

Hey Rudolph,
I want to make text show up on the screen and have it change according to what the microcontroller is reading. I see in your example that you are updating numerical values at the bottom left corner of the screen, can you walk me through how to display dynamic text?
Also, can I have a tag that transfers me to another window with different information, backgrounds, wedges, etc.? Would this require another display list?
I am trying to understand what some functions do but there is little to no documentation on the BT817 except for this library and what was asked on the BridgeTek community forum. is there a good source to learn more about display list commands that are in EVE.h ?

[RudolphRiedel]

Hello,

there are two major ways to handle display refresh, either based on timing or based on events.
Well, for simpler pixel displays something in between with tiles that are updated on events would make sense and such an event could be triggered by timing.

Anyways, the FT81x / BT81x display list approach does not really allow for partial updates and the amount of data that needs to be send is very small in comparision with pixel displays.
So yes, I do have my example split into one part that is generated every time, that one is "dynamic".
And a "static" part that is generated once and added to the display list with CMD_APPEND.
Well, there could be more pre-calculated display list fragments that are copied together and used with CMD_APPEND.
The lines for the button in my example represent only two options, the button is either displayed as pressed
or displayed as not pressed.
But regardless if the displayed list is partly copied together with CMD_APPEND or not, it always is a full update.
So even the "static" part is written over and over again to the display list, it does not go thru the SPI though.

I opted for a timed approach of updating the display list since that eliminates the need to keep track of all the events
that could trigger an update.
And even with a triggered uddate you need to have a timer on top as the display list refresh must be slower than the frame rate of the panel.
So there might have been an updated 1ms ago and some measurement for example triggered a new update, but it must not happen before some 16ms more have passed.

I went for updates every 20ms, this allows for smooth animations and provides feedback with no detectable delay.

This is way faster than we can read text, so for example analog measurements could be generating the string to be displayed only every other frame or every 10th frame.
Or the output for five measurements could generate only one of the strings per 20ms to split the computational "load" over several frames.

Different tags could be used for tabs like in a text editor, each tab has its own tag and clicking on one triggers displaying different display lists.

Like this which I put together in EVE Screen Editor now:

The display list for this is:
CLEAR(1, 1, 1)
COLOR_RGB(255,255,255)
CMD_TEXT(40, 0, 28, 0, "SomethingSomething")
BEGIN(RECTS)
TAG(100)
COLOR_RGB(100, 50, 200)
VERTEX2F(5000, 0)
VERTEX2F(7000, 400)
TAG(110)
COLOR_RGB(200, 50, 100)
VERTEX2F(7000, 0)
VERTEX2F(9000, 400)
TAG(120)
COLOR_RGB(150, 50, 200)
VERTEX2F(9000, 0)
VERTEX2F(11000, 400)
TAG(130)
COLOR_RGB(200, 50, 200)
VERTEX2F(11000, 0)
VERTEX2F(13000, 400)
COLOR_RGB(255,255,255)
TAG(100)
CMD_TEXT(350, 2, 27, 0, "One")
TAG(110)
CMD_TEXT(480, 2, 27, 0, "Two")
TAG(120)
CMD_TEXT(600, 2, 27, 0, "Three")
TAG(130)
CMD_TEXT(730, 2, 27, 0, "Four")
END()

This could be the "static" part and triggering the display of four different "dynamic" parts based on the touch events.

Finally the API of this library is mostly based on the programming guides for FT81x and BT81x and partly based on the datasheets.
The programming guides can be currently found here:
https://brtchip.com/document/programming-guides/

So the still current BT81x programming guide is:
https://brtchip.com/wp-content/uploads/2022/12/BRT_AN_033_BT81X-Series-Programming-Guide.pdf

I am hoping for an update though that does at least fixes a number of values that are documented to be signed to unsigned.

[Qtakruri]

if I want to do the same thing you did above using the functions you have in your example which would be the right one?

void initStaticBackground(void)
void TFT_init(void)
void TFT_touch(void)
void TFT_display(void)

Which of these is the one that actually sets up the display list and can be modified?

[RudolphRiedel]

Well, TFT_display() does the display refresh and to do so generates most of the display list.
But TFT_init() generates a snippet that is is only transferred once and then copied over with CMD_APPEND.

So what is above could be placed in TFT_init(), or to be more precise in initStaticBackground() that is called by TFT_init().
And the four screens could be functions that are called from TFT_display().

[Qtakruri]

I tried this in initStaticBackground(). I can only see the text but no touch functionality or colors. I get a white rectangle in the middle of my screen with words up top and that's it.

void initStaticBackground(void)
{
  EVE_cmd_dl(CMD_DLSTART);      /* Start the display list */
  EVE_cmd_dl(DL_TAG);           /* no tag = 0 - do not use the following objects for touch-detection */
  EVE_cmd_bgcolor(BLACK);       // background color
  EVE_cmd_dl(DL_VERTEX_FORMAT); /* set to 0 - reduce precision for VERTEX2F to 1 pixel instead of 1/16 pixel default */

  CLEAR(1, 1, 1);
  COLOR_RGB(255, 255, 255);
  EVE_cmd_text(30, 0, 28, 0, "Main Menu");
  EVE_cmd_dl(DL_BEGIN | EVE_RECTS);
  EVE_cmd_dl_burst(DL_TAG + 120); // tried TAG(120)
  COLOR_RGB(100, 50, 200);
  EVE_cmd_dl(VERTEX2F(128, 64));
  EVE_cmd_dl(VERTEX2F(160, 64));
  EVE_cmd_dl_burst(DL_TAG + 130);
  COLOR_RGB(200, 50, 100);
  EVE_cmd_dl(VERTEX2F(160, 64));
  EVE_cmd_dl(VERTEX2F(190, 64));
  EVE_cmd_dl_burst(DL_TAG + 140);
  COLOR_RGB(150, 50, 200);
  EVE_cmd_dl(VERTEX2F(90, 0));
  EVE_cmd_dl(VERTEX2F(110, 400));
  EVE_cmd_dl_burst(DL_TAG + 150);
  COLOR_RGB(200, 50, 200);
  EVE_cmd_dl(VERTEX2F(110, 0));
  EVE_cmd_dl(VERTEX2F(130, 400));
  TAG(150);
  COLOR_RGB(255, 255, 255);
  TAG(120);
  EVE_cmd_text(350, 2, 27, 0, "one");
  TAG(130);
  EVE_cmd_text(480, 2, 27, 0, "two");
  TAG(140);
  EVE_cmd_text(600, 2, 27, 0, "Three");
  TAG(150);
  EVE_cmd_text(730, 2, 27, 0, "Four");
  EVE_cmd_dl(DL_END);

  EVE_execute_cmd();

  num_dl_static = EVE_memRead16(REG_CMD_DL);

  EVE_cmd_memcpy(MEM_DL_STATIC, EVE_RAM_DL, num_dl_static);
  EVE_execute_cmd();
}

and in
TFT_touch() I have this part where I added a simple command when touch is detected. the way I understand this is that I can assign tag values to certain areas on the screen and if a touch is detected on that part of the screen the tag value is read and it does something like change the screen or toggle a button and in this case dim the screen

    case 110:
      EVE_memWrite8(REG_PWM_DUTY, 0x75);
      break;
    case 120:
      EVE_memWrite8(REG_PWM_DUTY, 0x65);
      break;
    case 130:
      EVE_memWrite8(REG_PWM_DUTY, 0x55);
      break;

[RudolphRiedel]

Ok, I just took your function and put it in a fresh example.
Then I modified this a bit to work.
I currently run this on an Arduino UNO R4 but this is just what I grabbed first as it already had all the wires connected.

Oh yes, in TFT_display() I also switched to black background.

void initStaticBackground(void)
{
  EVE_cmd_dl(CMD_DLSTART);      /* Start the display list */
  EVE_cmd_dl(DL_TAG);           /* no tag = 0 - do not use the following objects for touch-detection */
  EVE_cmd_bgcolor(BLACK);       // background color
  EVE_cmd_dl(DL_VERTEX_FORMAT); /* set to 0 - reduce precision for VERTEX2F to 1 pixel instead of 1/16 pixel default */

//  CLEAR(1, 1, 1);

  EVE_cmd_dl(COLOR_RGB(255, 255, 255));
  EVE_cmd_text(30, 0, 28, 0, "Main Menu");

  EVE_cmd_dl(DL_BEGIN | EVE_RECTS);
  EVE_cmd_dl(DL_TAG + 120); // tried TAG(120)
  EVE_cmd_dl(COLOR_RGB(100, 50, 200));
  EVE_cmd_dl(VERTEX2F(320, 0));
  EVE_cmd_dl(VERTEX2F(450, 24));
  EVE_cmd_dl(DL_TAG + 130);
  EVE_cmd_dl(COLOR_RGB(200, 50, 100));
  EVE_cmd_dl(VERTEX2F(450, 0));
  EVE_cmd_dl(VERTEX2F(570, 24));
  EVE_cmd_dl(DL_TAG + 140);
  EVE_cmd_dl(COLOR_RGB(150, 50, 200));
  EVE_cmd_dl(VERTEX2F(570, 0));
  EVE_cmd_dl(VERTEX2F(700, 24));
  EVE_cmd_dl(DL_TAG + 150);
  EVE_cmd_dl(COLOR_RGB(200, 50, 200));
  EVE_cmd_dl(VERTEX2F(700, 0));
  EVE_cmd_dl(VERTEX2F(800, 24));
  EVE_cmd_dl(DL_TAG + 150);
  EVE_cmd_dl(DL_END);

  EVE_cmd_dl(COLOR_RGB(255, 255, 255));
  EVE_cmd_dl(DL_TAG + 120);
  EVE_cmd_text(350, 2, 27, 0, "one");
  EVE_cmd_dl(DL_TAG + 130);
  EVE_cmd_text(480, 2, 27, 0, "two");
  EVE_cmd_dl(DL_TAG + 140);
  EVE_cmd_text(600, 2, 27, 0, "Three");
  EVE_cmd_dl(DL_TAG + 150);
  EVE_cmd_text(730, 2, 27, 0, "Four");

  EVE_cmd_dl(DL_TAG);

  EVE_execute_cmd();

  num_dl_static = EVE_memRead16(REG_CMD_DL);

  EVE_cmd_memcpy(MEM_DL_STATIC, EVE_RAM_DL, num_dl_static);
  EVE_execute_cmd();
}

Hmm, now I could go and try to explain everything in this like I do too often.
Not to overexplain is rather tricky when doing this in writing.
So trying this a different way, I just leave it at this for you to figure out what went wrong in your version. :-)

And yes, please ask if anything is remotely unclear, I am just trying to avoid giving answers to questions
that you do not need to ask. :-)

[Qtakruri]

Thank you, I now see what I was missing.

Now I am trying to call a display list when touching the tabs, do you have an idea of how that might look like?

Do I create a new DL in the tft_touch function under the corresponding tag case or do I create a separate function for each window and then call it there, would you kindly explain the steps to generate a DL and calling it so it switches to the new DL? and if I want to add a back button how is that done?

Another question I had was about memory. I am using trial and error to set the memory values for the images I am displaying eg.
#define MEM_LOGO 0x00000000
#define MEM_INFO 0x000f0000
#define MEM_MENU 0x0000f000

Is there a way to accurately or automatically manage the memory?

[RudolphRiedel]

Now I am trying to call a display list when touching the tabs, do you have an idea of how that might look like?

Do I create a new DL in the tft_touch function under the corresponding tag case or do I create a separate function for each window
and then call it there, would you kindly explain the steps to generate a DL and calling it so it switches to the new DL?

I would add a global variable like show_screen and assign it values in TFT_touch(), in the simplest form like this:

            case 120:
                show_screen = 0;
                break;
            case 130:
                show_screen = 1;
                break;
            case 140:
                show_screen = 2;
                break;
            case 150:
                show_screen = 3;
                break;

Depending on the application it might be preferable to put a lock on this so you need to lift the finger before a new
touch is accepted.

And then I would add something like this to TFT_display():

...
        EVE_cmd_append_burst(MEM_DL_STATIC, num_dl_static);

        switch (show_screen)
        {
            case 0:
                show_screen_1();
                break;
            case 1:
                show_screen_2();
                break;
            case 2:
                show_screen_3();
                break;
            case 3:
                show_screen_4();
                break;
            default:
                show_screen_1();
                break;
        }
...
        EVE_cmd_dl_burst(DL_DISPLAY);
        EVE_cmd_dl_burst(CMD_SWAP);
        EVE_end_cmd_burst();

So the show_screen_1() function only would have the commands unique to that screen.

and if I want to add a back button how is that done?

There is no need for a back button in the structure I proposed, this is more like the tabs on a web-browser.

But well, I did something like this before, press one button to go to a configuration-screen, press a different button on that new screen to go back.
The mechanism is the same, check for touch events, decide what to show, then follow this decision when a screen-update is due.

Another question I had was about memory. I am using trial and error to set the memory values for the images I am displaying eg.
#define MEM_LOGO 0x00000000
#define MEM_INFO 0x000f0000
#define MEM_MENU 0x0000f000

Is there a way to accurately or automatically manage the memory?

Yes and no. :-)

I like to keep things simple, even if that means a little math every now and then.
And for that reason I usually round my memory addresses down to pages, as long as there is plenty of free memory there is no need to store everything with minimum gaps.
For a bigger project I might resort to using a spreadsheet for planing the memory map.

On the opposite side of this I had an intern play with my library and he wrote some kind of malloc() that returned the next available address for a given amount of bytes.
I am not even sure where I put that code, I am only fairly certain that I got a copy of it, but I never felt the need to use it.

So, whatever fits your needs. :-)

[Qtakruri]

so for this part in tft_dipslay()

the beginning and end are the key to displaying stuff on the screen and the functions such as show_screen1(); would have all the details like shapes, widgets etc. ?
...
EVE_cmd_append_burst(MEM_DL_STATIC, num_dl_static);

    switch (show_screen)
    {
        case 0:
            show_screen_1();
            break;
        case 1:
            show_screen_2();
            break;
        case 2:
            show_screen_3();
            break;
        case 3:
            show_screen_4();
            break;
        default:
            show_screen_1();
            break;
    }

...
EVE_cmd_dl_burst(DL_DISPLAY);
EVE_cmd_dl_burst(CMD_SWAP);
EVE_end_cmd_burst();

[RudolphRiedel]

Yup, that was the idea, have a common part that stays the same.

[Qtakruri]

Hey Rudolph,

Have you had a chance to use the Keyboard (cmd_keys) ?

I am trying to figure out how to utilize the characters being pressed and perhaps show them on the screen, any idea how the tag values work for the keyboard? do I have to make a tag value for every character?

[RudolphRiedel]

I have not used CMD_KEYS in an application so far, but I know that it sets up the ASCII values of each key for the TAGs.
And this is probably the reason why CMD_KEYS does not support UTF-8 fonts, although it would have been to even get the extended ASCII range.

[Qtakruri]

That's correct, each character has a tag value of the corresponding ASCII value, it may have its limitations but I think it's easy to utilize.

I was able to read the tag values and store them in a buffer and used EVE_cmd_text to show the letters on the screen, but it's not working as expected here's what I have to read and display the character:

` if (EVE_memRead8(REG_TOUCH_RAW_XY) != 0xff)
{
// Serial.print(keysIndx);
keys[keysIndx] = EVE_memRead8(REG_TOUCH_TAG);

keysIndx++;

if (keysIndx > 10)
{
  keysIndx = 0;
}

}
EVE_cmd_text(x, 115, 28, 0, (const char *)&keys);
}`

the letters eventually show up on the screen but randomly. eg some letters and numbers will show up and others won't or you press keys with nothing displayed and then all the keys you pressed suddenly show up.

Do you have a good way to update the screen with each button press? like a notepad.

[RudolphRiedel]

I am not updating the screen on events, I am updating the screen with a fixed timing of 20ms.
And I am running my touch function every 5ms.
20ms is well below the perceiveable delay of about 100ms and with the touch function called first, the actual delay between a touch event and the reaction can be lower than 20ms but never higher.
Thinking about this with a total runtime resctriction in mind, there is no need to call the touch function right before the display function in the same time slot which would result in having the added runtime for the two calls.
With
touch() touch() touch() display()
on a 5ms timing, the maximum delay is 25ms for events that happen after the third touch() call.
I am not even sure that the first two touch() calls do anything, other than potentially help with catching short touch events.
I changed the main loop of my current playground software to this and the touch still feels spontaneous,

Ok, adding keys and printing the string:
EVE_cmd_keys(200, LAYOUT_Y1, 400, 35, 28, key_pressed, "abcdef");
EVE_cmd_text(200, LAYOUT_Y1+40, 29, 0, keys);

My complete touch function is this now:

uint16_t toggle_state = 0;
uint16_t display_list_size = 0;
char keys[32] = {0};
uint8_t keysIndx = 0;
uint8_t key_pressed = 0;

/* check for touch events and setup vars for TFT_display() */
void TFT_touch(void)
{
    if(tft_active != 0)
    {
        uint8_t tag;
        static uint8_t toggle_lock = 0;

        if(EVE_IS_BUSY == EVE_busy()) /* is EVE still processing the last display list? */
        {
            return;
        }

        display_list_size = EVE_memRead16(REG_CMD_DL); /* debug-information, get the size of the last generated display-list */
        tag = EVE_memRead8(REG_TOUCH_TAG); /* read the value for the first touch point */

        switch(tag)
        {
            case 0:
                toggle_lock = 0;
                key_pressed = 0;
                break;

            case 10: /* use button on top as on/off toggle-switch */
                if(0 == toggle_lock)
                {
                    toggle_lock = 42;
                    if(0 == toggle_state)
                    {
                        toggle_state = EVE_OPT_FLAT;
                    }
                    else
                    {
                        toggle_state = 0;
                    }
                }
                break;

            case 'a':
            case 'b':
            case 'c':
            case 'd':
            case 'e':
            case 'f':
                if(0 == toggle_lock)
                {
                    toggle_lock = 75;
                    key_pressed = tag;
                    keys[keysIndx] = (char) tag;
                    keysIndx++;
                    if(keysIndx > 30)
                    {
                        keysIndx = 0;
                    }
                }
                else
                {
                    toggle_lock--;
                }
                break;

            default:
                break;
        }
    }
}

So toggle_lock is there to only generate a single event and is cleared when the finger is lifted or moved out of the touch area.
Setting it to 75 and counting it down results in keys added about every 500ms after the first one on pressing continously.

The only issue I encountered with this is that my touch-calibration is not quite correct.

And my current playground software looks like this now: