BRT Community

🚀 Did you know?
Many designs require separate controllers for:
- TFT display
- Capacitive touch
- Audio feedback
Embedded Video Engine (EVE) integrates these functions into one graphics subsystem.
Benefits include:
- Reduced PCB complexity
- Lower component count
- Easier EMC management
Together, these benefits translate into lower total system cost and higher reliability, especially for compact or cost‑sensitive applications like white goods, smart home devices, industrial panels, smart appliances, and automotive displays.

🚀 Did You Know?
The Bridgetek BT820 EVE takes care of graphics, touch, audio, and display refresh, freeing your MCU to focus on application tasks.
✅ Lower MCU workload
✅ Simpler firmware
✅ Faster touch UIs
✅ Supports displays up to 1920×1200 @ 60fps
Ideal for EV chargers, medical devices, industrial HMIs, smart appliances, and more.
💡 Pro Tip: Pair the BT820 with a cost-effective MCU to create advanced high-resolution touchscreen interfaces.

Pls try on hardware too.   Yes.stencil buffer for the affected pixels will be changed.

Thanks, I tried this and it seems to work at least fine with my test-code in the emulator context.

But, isn't that leaving artifacts in the stencil buffer?
I mean, the general idea is to have this as a universal support.

Hi Rudolph,

One option worth trying is to clear the stencil while drawing the outer point. Using `EVE_stencil_op(EVE_ZERO, EVE_ZERO)` for that pass should remove the need for the separate cleanup pass:

```c
void EVE_widget_circle(const int16_t xc0, const int16_t yc0,
                       const uint16_t radius, const uint16_t border)
{
    EVE_save_context();
    EVE_stencil_mask(0x01);

    EVE_color_mask(0, 0, 0, 0);
    EVE_stencil_func(EVE_ALWAYS, 0x01, 0x01);
    EVE_stencil_op(EVE_REPLACE, EVE_REPLACE);
    EVE_point_size((uint16_t)(radius - border));
    EVE_begin(EVE_POINTS);
    EVE_vertex2f(xc0, yc0);

    EVE_color_mask(1, 1, 1, 1);
    EVE_stencil_func(EVE_NOTEQUAL, 0x01, 0x01);
    EVE_stencil_op(EVE_ZERO, EVE_ZERO);
    EVE_point_size(radius);
    EVE_vertex2f(xc0, yc0);

    EVE_end();
    EVE_restore_context();
}
```

The inner area fails the stencil test, so its colour remains untouched, but its stencil bit is cleared. The ring passes, draws in the current colour, and also clears the bit.

This gives 15 commands / 60 bytes, including `STENCIL_MASK(0x01)` to preserve the other stencil bits. If that write mask is already configured, it becomes 14 commands / 56 bytes.

This assumes stencil bit 0 is initially clear and available for the widget, and `border <= radius`. `SAVE_CONTEXT`/`RESTORE_CONTEXT` restore the stencil settings, but not the stencil-buffer contents.

I am re-visiting my circle function:
void EVE_widget_circle(const int16_t xc0, const int16_t yc0, const uint16_t radius, const uint16_t border, const uint32_t bgcolor)
{
    EVE_save_context();
    EVE_begin(EVE_POINTS);
    EVE_point_size(radius);
    EVE_vertex2f(xc0, yc0);
    EVE_color_rgb(bgcolor);
    EVE_point_size((uint16_t) (radius - border));
    EVE_vertex2f(xc0, yc0);
    EVE_end();
    EVE_restore_context();
}

While that is short and simple, it is a bit odd to use.
The inner area is not transparent, but filled with the provided color.
This is using 9 commands, so 36 bytes in the command-list.

Now I have this:
void EVE_widget_circle(const int16_t xc0, const int16_t yc0, const uint16_t radius, const uint16_t border)
{
    EVE_save_context();
    EVE_color_mask(0, 0, 0, 0);
    EVE_stencil_func(EVE_ALWAYS, 0x01, 0x01);
    EVE_stencil_op(EVE_REPLACE, EVE_REPLACE);
    EVE_point_size((uint16_t) (radius - border));
    EVE_begin(EVE_POINTS);
    EVE_vertex2f(xc0, yc0);
//    EVE_end();
    EVE_color_mask(1, 1, 1, 1);
    EVE_stencil_func(EVE_NOTEQUAL, 0x01, 0x01);
    EVE_stencil_op(EVE_KEEP, EVE_KEEP);
    EVE_point_size(radius);
//    EVE_begin(EVE_POINTS);
    EVE_vertex2f(xc0, yc0);
//    EVE_end();
    EVE_color_mask(0, 0, 0, 0);
    EVE_stencil_func(EVE_ALWAYS, 0x00, 0x01);
    EVE_stencil_op(EVE_REPLACE, EVE_REPLACE);
//    EVE_begin(EVE_POINTS);
    EVE_vertex2f(xc0, yc0);
    EVE_end();
    EVE_restore_context();
}

And this works fine, 18 commands, 72 bytes in the command-list.

At least in the EVE Emulator library I can do this:
EVE_color_rgb(BLACK);
EVE_cmd_text(40, 350, 31, 0, "The quick brown fox jumps...");

EVE_color_rgb(GREEN);
EVE_widget_circle(100,400, 50*16, 8*16);

EVE_color_rgb(RED);
EVE_widget_circle(150,400, 50*16, 8*16);

EVE_color_rgb(MAGENTA);
EVE_widget_circle(220,400, 50*16, 8*16);

I get three overlapping circles and the text underneath.

Hmm, yes, I am also using:
EVE_vertex_format(0);
But neither POINT_SIZE or LINE_WIDTH care about that.

What I am wondering now is, is there a way to do this more efficient?

Edit:
I went with this for a rectangle now:
void EVE_widget_rectangle(const int16_t xc0, const int16_t yc0, const int16_t wid, const int16_t hgt, const uint16_t border)
{
    EVE_save_context();
    EVE_line_width(border);
    EVE_begin(EVE_LINE_STRIP);
    EVE_vertex2f(xc0, yc0);
    EVE_vertex2f(xc0 + wid, yc0);
    EVE_vertex2f(xc0 + wid, yc0 + hgt);
    EVE_vertex2f(xc0, yc0 + hgt);
    EVE_vertex2f(xc0, yc0);
    EVE_end();
    EVE_restore_context();
}


You cannot view this attachment.

Hi,

yes I know, I am not answering the question directly, but I never used interrupts with the EVE chips and never found out what the benefit of using interrupts is supposed to be.

When you use an interrupt, you have to make sure to not disrupt any other on going SPI transfer before reading the touch information.
If you are using DMA to update the display you certainly can not wait in the interrupt function for the DMA transfer to finish.
So the sane option is to set a flag in the interrupt to check in the main loop and read the data when EVE is not busy otherwise.
First you need to find out what the interrupt was about, then read the touch data.

I am just polling REG_TOUCH_TAG every 5ms between display updates, this is fast enough to not lose events and if any change is necessary in the display as a reaction, the display can not be updated immediately anyways, you have to wait for the next update cycle.

Hello Jerome,

Thank you for your question.

On the following:

Quote from: jipihorn on October 08, 2026, 01:34:05 PMHowever, whatever value I put here, I still get other interrupts like INT_SWAP or INT_CMDEMPTY.

Can I ask if you are seeing the INT_N pin assert for INT_SWAP or INT_CMDEMPTY, or are you simply reading the REG_INT_FLAGS register and seeing these flags are also set when for example a INT_TOUCH interrupt is triggered?

The REG_INT_FLAGS register keeps track of the available interrupt sources on the IC, and will set the flag accordingly for each source irrespective of the flags being masked by REG_INT_MASK. When REG_INT_EN is 1, INT_N is driven low when any of the interrupt flags in REG_INT_FLAGS are high, after masking with REG_INT_MASK. Basically the flag will set for a given interrupt source when the given scenario for that flag happens, the mask is then used to tell the INT_N pin which flags it should assert for.

Best Regards,
BRT Community

Bridgetek's IC Development Kits (IDKs) provide a quick and easy way to evaluate EVE graphics controllers, combining graphics, touch, and audio capabilities in a ready-to-use package. Each kit includes a development board, matching LCD display, and connectivity options to help engineers rapidly prototype, test, and develop GUIs.

Simply connect to a PC via USB-SPI/QSPI to start building your user interface using Bridgetek's software tools. When ready, connect your MCU to continue development and seamlessly integrate the GUI into your final product. 🚀

Hello,

I use the BT817 a lot, without touch screen but this time, it is different.
So I have to use interrupts when touch stuff happen.

I put a mask on the REG_INT_MASK register with 0x86 and enable them with REG_INT_EN  set to 1.
However, whatever value I put here, I still get other interrupts like INT_SWAP or INT_CMDEMPTY.

If I read back the mask register, I read the right value, so it is not resetted by something else...

Is there something else to do to filter interrupts ?

Jerome.