Hello Darren,

Thanks for your update, we are currently looking into this and will update you as soon as possible,

Best Regards, BRT Community

Hello,

Thank you for your feedback, I will liaise with the development team to see if we can add this feature into upcoming ESD releases.

Best Regards,
BRT Community

Hello Darren,

The development team have got back to me on this point.

They note that this is the intentional behavior for a generated MPSSE/Emulator project as they wish users to be aware of these dependencies.
As such users are required  to copy the dependency DLLs(such as ftd2xx.dll) for ESD generated MPSSE/Emulator project.

Best Regards,
BRT Community

Hello Darren,

thank you for your post.

I have managed to recreate this behavior, I believe that the appropriate DDLs should be copied into the executable folder once the build has completed.

I have passed this onto the development team for review.

Best Regards,
BRT Community

Hi,

Most of these items are positioned by the pixel rather than by 1/16th. When used in code examples, you will see that Vertex2F has the value multiplied by 16 e.g. VERTEX2F(20*16, 20*16) to place something at coordinate 20,20. Note that you can actually also display numbers and letters using VERTEX2F as they are made up of a series of images (one per character).

Also note that using the text command does all the character spacing etc for you. If you use Vertex2F this only places 1 character per vertex and so to make a string of characters you will need to call a Vertex2f per character.

It is possible to just add a value to the x coordinate each time but if you want the text to look proportional (and so spacing between each char related to the width of the char) then you can use the metric block data/font properties which is in the EVE chip. For numbers you might want a fixed position for each number so that the whole number does not move around and change in length (e.g. a 1 is narrower than an 8 ) but for text, having a constant spacing between characters may not look as good.

Best regards

BRT Community

Hi,

Here is a small code example.

It will tag the four circles and so when you hold your finger on them, you should see the corresponding tag displayed by the number command.
We set the clear tag to 100 and so if you touch an area of the screen outside of the circles, you'll get tag 100
With no touch, the tag will read 0

We also mask the tag so that the text and number are not tagged, this is useful if you want to turn off tagging for these after drawing the tagged items  (the tag 13 for the last circle would otherwise also apply to the text and number)

Best Regards, BRT Community


   uint8_t Tag = 0;
   
   while(1)
    {
        EVE_LIB_BeginCoProList();                                               // Begin new screen
        EVE_CMD_DLSTART();                                                      // Tell co-processor to create new Display List

EVE_CLEAR_TAG(100);                  // Set tag to 100 for any un-tagged pixels
EVE_CLEAR_COLOR_RGB(0, 0, 0);                                           // Specify color to clear screen to

EVE_CLEAR(1,1,1);                                                       // Clear color, stencil, and tag buffer

EVE_TAG_MASK(1);                                                        // Enable tagging

EVE_BEGIN(EVE_BEGIN_POINTS);
EVE_POINT_SIZE(800);
EVE_TAG(10);
EVE_VERTEX2F((100*16), (100*16));
EVE_TAG(11);
EVE_VERTEX2F((200*16), (100*16));
EVE_TAG(12);
EVE_VERTEX2F((300*16), (100*16));
EVE_TAG(13);
EVE_VERTEX2F((400*16), (100*16));
EVE_END();

EVE_TAG_MASK(1);                                                        // Disable tagging
EVE_CMD_TEXT(100, 200, 28, 0, "The Tag is...");
EVE_CMD_NUMBER(100, 250, 28, 0, Tag);

EVE_DISPLAY();                                                          // Tell EVE that this is end of list
EVE_CMD_SWAP();                                                         // Swap buffers in EVE to make this list active

EVE_LIB_EndCoProList();                                                 // Finish the co-processor list burst write
EVE_LIB_AwaitCoProEmpty();                                              // Wait until co-processor has consumed all commands

Tag = HAL_MemRead8(EVE_REG_TOUCH_TAG);
   }

Hi Obones, Torsten,

Here is a small example of the Bitmap rotation method which you mentioned.

To make it even more universal, you can rotate each letter as a bitmap and use the character width to position each character. This works well for right-angles but for other angles, the step where you calculate the X and Y position of each character relative to the last becomes more complex, and may involve quite a bit of code and trig functions.

For some cases where a random angle is needed and where the word does not constantly change, using a bitmap works well. You could also avoid calculating the widths etc. and hard-code these but using the widths makes sure that the string looks well formatted.

EVE_GPU_FONT_HEADER StdFont30;

uint32_t FontByte;
uint16_t FontIndexCounter;
uint32_t FontTableAddress = 0;
uint32_t X = 100;
uint32_t Y = 100;
uint32_t CurrentCharWidth = 0;
uint32_t CurrentCharHeight = 0;
uint8_t offset = 0;
uint32_t angle = 90;
#define FontNum 30


uint32_t StringWidth = 0;
uint32_t StringHeight = 0;
uint32_t SnapWidth = 0;
uint32_t SnapHeight = 0;
uint32_t x_text = 200;
uint32_t y_text = 200;

uint32_t x_coord = 200;
uint32_t y_coord = 200;

// Get the character widths from the ROM font 30
void eve_display(void)
{
FontTableAddress = ((HAL_MemRead32(EVE_ROMFONT_TABLEADDRESS)) + ((FontNum - 16) * FT_GPU_FONT_TABLE_SIZE));

    FontIndexCounter = 0;
    while(FontIndexCounter < 128)
    {
        FontByte = HAL_MemRead8(FontTableAddress + FontIndexCounter);
        StdFont30.FontWidth[FontIndexCounter] = FontByte;
        FontIndexCounter ++;
    }
    FontByte = HAL_MemRead32(FontTableAddress + FontIndexCounter);
    StdFont30.FontBitmapFormat = FontByte;
    FontIndexCounter = FontIndexCounter + 4;

    FontByte = HAL_MemRead32(FontTableAddress + FontIndexCounter);
    StdFont30.FontLineStride = FontByte;
FontIndexCounter = FontIndexCounter + 4;

FontByte = HAL_MemRead32(FontTableAddress + FontIndexCounter);
StdFont30.FontWidthInPixels = FontByte;
FontIndexCounter = FontIndexCounter + 4;

FontByte = HAL_MemRead32(FontTableAddress + FontIndexCounter);
StdFont30.FontHeightInPixels = FontByte;
FontIndexCounter = FontIndexCounter + 4;

FontByte = HAL_MemRead32(FontTableAddress + FontIndexCounter);
StdFont30.PointerToFontGraphicsData = FontByte;

// Write the text Hello and also calculate what width it is based on the characters
EVE_LIB_BeginCoProList(); // Begin co-processor commands
EVE_CMD_DLSTART(); // New display list
EVE_CLEAR_COLOR_RGB(0, 0, 0); // Clear screen to black
EVE_CLEAR(1,1,1); // Clear
EVE_COLOR_RGB(255,255,255); // White color for text
EVE_CMD_TEXT(x_text,y_text, 30, EVE_OPT_CENTER, "Hello"); // Print Hello
// Add up the widths of the characters
StringWidth = (uint32_t) (StdFont30.FontWidth['H'] + StdFont30.FontWidth['e'] + StdFont30.FontWidth['l'] + StdFont30.FontWidth['l'] + StdFont30.FontWidth['o']);// + (StdFont30->FontWidth['e']);// + (uint32_t)(StdFont30->FontWidth["l"]) + (uint32_t)(StdFont30->FontWidth["l"]) + (uint32_t)(StdFont30->FontWidth["o"]);
StringHeight = StdFont30.FontHeightInPixels; // Get the height from the font table
EVE_DISPLAY(); // Finish the display list
EVE_CMD_SWAP();
EVE_LIB_EndCoProList();
EVE_LIB_AwaitCoProEmpty();

// Get the size for our snapshot, ensuring we include the full string
SnapWidth = StringWidth * 2;
SnapHeight = StringWidth * 2;

// Take a snapshot of the area around the text
// Store it at address 0 of RAM_G
EVE_LIB_BeginCoProList();
EVE_CMD_SNAPSHOT2(EVE_FORMAT_ARGB4, 0, (x_text - (SnapWidth/2)), (y_text - (SnapHeight/2)),  SnapWidth, SnapHeight);
EVE_LIB_EndCoProList();
EVE_LIB_AwaitCoProEmpty();

// In this loop, we can constantly rotate the angle to make the word spin round
while(1)
{

if(angle < 360)
angle ++;
else
angle = 0;

EVE_LIB_BeginCoProList();
EVE_CMD_DLSTART();
EVE_CLEAR_COLOR_RGB(0, 0, 0);
EVE_CLEAR(1,1,1);
EVE_COLOR_RGB(255,255,255);

EVE_BEGIN(EVE_BEGIN_BITMAPS);
EVE_BITMAP_SOURCE(0); // Bitmap source is where we stored the snapshot
EVE_BITMAP_SIZE(EVE_FILTER_BILINEAR, EVE_WRAP_BORDER, EVE_WRAP_BORDER,SnapWidth,SnapHeight);
#if (defined EVE2_ENABLE || defined EVE3_ENABLE || defined EVE4_ENABLE)
  EVE_BITMAP_SIZE_H(SnapWidth >> 9, SnapHeight >> 9);
#endif
EVE_BITMAP_LAYOUT(EVE_FORMAT_ARGB4, SnapWidth *2, SnapHeight);
#if (defined EVE2_ENABLE || defined EVE3_ENABLE || defined EVE4_ENABLE)
    EVE_BITMAP_LAYOUT_H((SnapWidth * 2) >> 10, SnapHeight >> 9);
#endif
// Do the rotation
EVE_CMD_LOADIDENTITY();
EVE_CMD_TRANSLATE(65536*(SnapWidth/2),65536*(SnapHeight/2));
EVE_CMD_ROTATE(angle*(65536/360));
EVE_CMD_TRANSLATE(65536*(-SnapWidth/2),65536*(-SnapHeight/2));
EVE_CMD_SETMATRIX();
// Now place the rotated image of the word
EVE_VERTEX2F(x_coord *16,y_coord *16);

EVE_DISPLAY();
EVE_CMD_SWAP();
EVE_LIB_EndCoProList();
EVE_LIB_AwaitCoProEmpty();

MCU_Delay_20ms(); // Prevent it spinning too fast

}
}
Best Regards, BRT Community