Hello,

When using the Custom Touch functionality with the BT815/7 you would connect the CTP directly to the EVE IC and not the MCU.

Sorry I should have clarified that the relevant points from section 6.7.2 of AN_336 are how to load the .h file into RAM_CMD, a similar approach can be used for the custom touch firmware generated in EAB for the BT815/7.

Best Regards,
BRT Community

Hello Rudolph,

Sorry I had passed this onto the development team for some clarification, but they are quite busy recently. I will chase them up on this.

I believe the v2.2.0 release is intended as an internal release for some bug updates, while the next official release will be v2.3.0.

However the release note does mention the following:
Feature updates
- Improve flash programming utility to work with 128 Mbytes flash chip
- Improve font utility:
  + Report only valid characters
  + Calculate the number of characters in each unicode ranges

As such I believe this will resolve some of the issues you have been seeing.

EDIT: please use the following link: EVE-Asset-Builder-setup-2.2.0-rc2.zip

Best Regards,
BRT Community

Hello,

There is a readme file contained in EAB which covers the creation of the firmware. Unfortunately however I do not have a application note currently which covers uploading this to EVE, but I will chase the development team up for an example. I suspect this file has to be written to RAM_CMD during the initialization sequence.

And unfortunately no the BT815/7 does not natively support the IL2511, you would need to utilise touch host mode or a custom touch firmware file for this CTP.

Best Regards,
BRT Community

Hello,

No, this is not the same approach as utilising Touch Host mode.

The EAB Custom Touch tab enables the feature of compiling custom CTP firmware. You can write custom CTP firmware in C and use EAB to compile into a downloadable binary(blob). The output binary can then be downloaded into RAM_CMD to allow you to use your CTP which would be connected directly to the BT815/7.

Best Regards,
BRT Community

Hello,

Thank you for your question.

Unfortunately it would not be possible to utilise the ATMXT336T touch controller just by altering the I2C address in REG_TOUCH_CONFIG as this controller is not natively supported by EVE.

However a new feature in EVE Asset Builder allows for the compilation of custom touch firmware for unsupported devices (see attached screenshot). This can then be written to EVE to allow the use of your desired CTP.

Best Regards,
BRT Community

Hello,

Thank you for the confirmation, I have also given this a try and I am seeing similar results. I've asked the development team to clarify if this is a bug in ESD.

Best Regards,
BRT Community.

Hello,

Thank you for the updates.

Unfortunately the second sparkfun link seems to be broken.

Thank you for the clarification on the CS# signal, in our libraries we utilise a similar approach (holding the CS# low for a full read/write operation). however from your capture it looks like there is an errant CS# toggle between transactions. When are you asserting this signal in your code.

As for the PD# signal this is an input and shouldn't be toggling during SPI transactions. There is nothing internal to EVE which would cause this behaviour, can you double check your code to see if your are inadvertently toggling this line? I can see from the scope capture this seems to be happening, as a result EVE will be reset every time this signal toggles. This is likely to be an issue, you may want to try adjusting the driver strength on this pin.

As for the REG_ID read returning incorrectly, this could be related to the either of the above. But can you please clarify which SPI mode you are using with the SPI master interface? (I cannot zoom in enough onto the capture to establish this, please send a zoomed in capture of the MISO/MOSO and CLK lines if possible). The PIC should be configure to use SPI mode 0.

I have attached a SPI capture  for reference of the following code being used within the BRT_AN_025 library:

void eve_display(void)
{

    delay(200);
                uint32_t dlOffset;
                uint32_t x = 0;

//            uint32_t xoffset, yoffset, xoffset2, yoffset2;
                uint32_t FT_DispWidth1 = 800;
                uint32_t FT_Dispheight1 = 480;
//
//    xoffset = FT_DispWidth1 / 2;                             // Variables to hold coordinates where the static text will be placed
//    yoffset = FT_DispHeight1 / 2;
//
//    xoffset2 = FT_DispWidth1 / 3;                            // Variables to hold coordinates where the dynamic text will be placed
//    yoffset2 = FT_DispHeight1 / 3;

    EVE_LIB_BeginCoProList();
    EVE_CMD_MEMSET(0,0,10*1024);
    EVE_LIB_EndCoProList();
    EVE_LIB_AwaitCoProEmpty();

    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_CMD_TEXT(10, 50, 31, 0, "abc");
    EVE_CMD_TEXT(10, 100, 31, 0, "123456789456123123");
    EVE_CMD_TEXT(10, 200, 31, 0, "456");
    EVE_CMD_TEXT(10, 300, 31, 0, "456");
    EVE_CMD_TEXT(10, 400, 31, 0, "456");

    EVE_LIB_EndCoProList();
    EVE_LIB_AwaitCoProEmpty();

    dlOffset = HAL_MemRead16(EVE_REG_CMD_DL);

    EVE_LIB_BeginCoProList();
    EVE_CMD_MEMCPY(1000,EVE_RAM_DL,dlOffset);
    EVE_LIB_EndCoProList();
    EVE_LIB_AwaitCoProEmpty();

                do {

                    EVE_LIB_BeginCoProList();
                    EVE_CMD_DLSTART();
                    EVE_CLEAR(1,1,1);
                    EVE_CMD_APPEND(1000,dlOffset);
                    EVE_COLOR_RGB(255,0,0);
                    EVE_CMD_TEXT(FT_DispWidth1/3 , FT_Dispheight1/3, 31, 0, "Dynamic");
                    EVE_COLOR_RGB(0,0,255);
                 EVE_CMD_TEXT(FT_DispWidth1/2 , FT_Dispheight1/2, 31, 0, "Dynamic");
                 EVE_CMD_NUMBER(200,100,31,EVE_OPT_CENTER | EVE_OPT_RIGHTX | 6 , x);
                    EVE_DISPLAY();
                    EVE_CMD_SWAP();
                    EVE_LIB_EndCoProList();
                    EVE_LIB_AwaitCoProEmpty();

                    delay(500);
                    x++;

                } while (1);
}

This code utilises the following boot sequence (see the BRT_AN_025 source):


       MCU_PDlow();                                                                // PD low to reset device                                                               
    MCU_Delay_20ms();
    MCU_PDhigh();                                                               // PD high again
    MCU_Delay_20ms();

    // ---------------------- Delay to allow FT81x start-up --------------------   
   
    EVE_CmdWrite(FT81x_ACTIVE, 0x00);                                           // Sends 00 00 00 to wake FT8xx
   
    MCU_Delay_500ms();                                                          // 500ms delay (EVE requires at least 300ms here))
       
    // --------------- Check that FT8xx ready and SPI comms OK -----------------
   
    while (EVE_MemRead8(REG_ID) != 0x7C)                                        // Read REG_ID register until reads 0x7C
    {
    }
     
    while (EVE_MemRead8(REG_CPURESET) != 0x00)                                  // Ensure CPUreset register reads 0 and so FT8xx is ready   
    {
    }
   
    // ------------------------- Display settings ------------------------------

    // WQVGA display parameters
    lcdWidth   = 800;                                                           // Active width of LCD display
    lcdHeight  = 480;                                                           // Active height of LCD display
    lcdHcycle  = 928;                                                           // Total number of clocks per line
    lcdHoffset = 88;                                                            // Start of active line
    lcdHsync0  = 0;                                                             // Start of horizontal sync pulse
    lcdHsync1  = 48;                                                            // End of horizontal sync pulse
    lcdVcycle  = 525;                                                           // Total number of lines per screen
    lcdVoffset = 32;                                                            // Start of active screen
    lcdVsync0  = 0;                                                             // Start of vertical sync pulse
    lcdVsync1  = 3;                                                             // End of vertical sync pulse
    lcdPclk    = 2;                                                             // Pixel Clock
    lcdSwizzle = 0;                                                             // Define RGB output pins
    lcdPclkpol = 1;                                                             // Define active edge of PCLK
       
    EVE_MemWrite16(REG_HSIZE,   lcdWidth);     
    EVE_MemWrite16(REG_HCYCLE,  lcdHcycle);     
    EVE_MemWrite16(REG_HOFFSET, lcdHoffset);   
    EVE_MemWrite16(REG_HSYNC0,  lcdHsync0);     
    EVE_MemWrite16(REG_HSYNC1,  lcdHsync1);     
    EVE_MemWrite16(REG_VSIZE,   lcdHeight);     
    EVE_MemWrite16(REG_VCYCLE,  lcdVcycle);     
    EVE_MemWrite16(REG_VOFFSET, lcdVoffset);   
    EVE_MemWrite16(REG_VSYNC0,  lcdVsync0);     
    EVE_MemWrite16(REG_VSYNC1,  lcdVsync1);     
    EVE_MemWrite8(REG_SWIZZLE,  lcdSwizzle);   
    EVE_MemWrite8(REG_PCLK_POL, lcdPclkpol);   
   
       
    // ---------------------- Touch and Audio settings -------------------------

    EVE_MemWrite16(REG_TOUCH_RZTHRESH, 1200);                                   // Eliminate any false touches

    EVE_MemWrite8(REG_VOL_PB, ZERO);                                            // turn recorded audio volume down
    EVE_MemWrite8(REG_VOL_SOUND, ZERO);                                         // turn volume down
    EVE_MemWrite16(REG_SOUND, 0x6000);                                          // set volume mute
       
   
    // ---------------- Configure the GPIO and PWM  --------------------
   
    EVE_MemWrite8(REG_PWM_DUTY, 0);                                             // Backlight off
   
    FT81x_GPIO_DAT = EVE_MemRead16(REG_GPIOX);                                  // Read the FT81x GPIO register for a read/modify/write operation
    FT81x_GPIO_DAT = FT81x_GPIO_DAT | 0x8000;                                   // set bit 15 of GPIO register (DISP). If using audio, also enable the amplifier shutdown GPIO line here
    EVE_MemWrite16(REG_GPIOX, FT81x_GPIO_DAT);                                  // Enable the DISP signal to the LCD panel

    FT81x_GPIO_DIR = EVE_MemRead16(REG_GPIOX_DIR);                              // Read the FT81x GPIO DIR register for a read/modify/write operation
    FT81x_GPIO_DIR = FT81x_GPIO_DIR | 0x8000;                                   // DISP is output, if using audio, also set the associated shutdown line as output (check your Eval module schematic))
    EVE_MemWrite16(REG_GPIOX_DIR, FT81x_GPIO_DIR);                              // Enable the DISP signal to the LCD panel
       

    // ---------------------- Create an initial screen before we enable the display -------------------------

    ramDisplayList = RAM_DL;                                                    // start of Display List
    EVE_MemWrite32(ramDisplayList, 0x02000000);                                 // Clear Color RGB sets the colour to clear screen to

    ramDisplayList += 4;                                                        // point to next location
    EVE_MemWrite32(ramDisplayList, (0x26000000 | 0x00000007));                  // Clear 00100110 -------- -------- -----CST  (C/S/T define which parameters to clear)

    ramDisplayList += 4;                                                        // point to next location
    EVE_MemWrite32(ramDisplayList, 0x00000000);                                 // DISPLAY command 00000000 00000000 00000000 00000000 (end of display list)

    EVE_MemWrite32(REG_DLSWAP, DLSWAP_FRAME);                                   // Swap display list to make the edited one active

    // -------------------- Now turn on PCLK and ramp the PWM up  -------------------------------------
    // ---------------- This provides a clean start-up for the application ----------------------------
       
    EVE_MemWrite8(REG_PCLK, lcdPclk);                                           // Now start clocking data to the LCD panel

    MCU_Delay_20ms();
   
    for(PWM = 0; PWM <= 127; PWM ++)
    {
        EVE_MemWrite8(REG_PWM_DUTY, PWM);     
        MCU_Delay_20ms();
    }
   



This capture can be viewed using Saleae's Logic software:
https://www.saleae.com/downloads/

Note: channel 4 in this capture represents the PD# pin.

This was a general example for another customer however in this case the 'config' section in the 'capture.jpg' image attached should be useful as it provides a set of known good SPI transactions to EVE for comparison in your set up. It may be worth comparing this section with the SPI data you are seeing in your configuration.

The first SPI transaction should be the "while (EVE_MemRead8(0X302000) != 0x7C)" call, so I have included a zoom of this attached as 'REG_ID.jpg'. Could you share a zoomed scope capture of your REG_ID read?

Best Regards,
BRT Community