CCS/EK-TM4C1294XL: getting started FT800 with TM4C1294XL

Hello Angel

The SSI controller on TM4C devices require that the RX FIFO be cleared whenever a byte is written.

Since the protoype of the ft800mem_Write8 r Write16 command is not described in your code, it would be tough to decipher the action it is performing and the implication of the same for the TM4C device.

Hello many thanks for your early response

with my code I get to turn on the DisplayLCD but it only shows full brightness and as I mentioned before when I try to read on any register I had to call twice any read function (why? I don't understand)

Regards!

these is my read and write functions that I have used

Write functions:

void ft800cmd_Write(unsigned char ftCommand)
{
    GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, 0);                     // Set chip select low
    while(SSIDataGetNonBlocking(SSI0_BASE, &pui32DataRx) != 0);

    // Initialize the data to send.
    SSIDataPut(SSI0_BASE, ftCommand);                                                     // Send command
    SSIDataPut(SSI0_BASE, 0x00);                                                                 // Send first filler byte
    SSIDataPut(SSI0_BASE, 0x00);                                                                 // Send second filler byte

    while(SSIBusy(SSI0_BASE));
    GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, GPIO_PIN_CS);    // Set chip select high
}

void ft800mem_Write8(unsigned long ftAddress, unsigned char ftData8)
{
    unsigned char cTempAddr[3];                                                                    // FT800 Memory Address

    cTempAddr[2] = (char) (ftAddress >> 16) | MEM_WRITE;                    // Compose the command and address to send
    cTempAddr[1] = (char) (ftAddress >> 8);                                                  // middle byte
    cTempAddr[0] = (char) (ftAddress);                                                           // low byte

    GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, 0);                   // Set chip select low
    while(SSIDataGetNonBlocking(SSI0_BASE, &pui32DataRx) != 0);

    for (i = 2; i >= 0; i--)
    {
        SSIDataPut(SSI0_BASE, cTempAddr[i]);                                             // Send Memory Write plus high address byte
    }

    for (j = 0; j >= 0; j--)
    {
        SSIDataPut(SSI0_BASE, ftData8);                                                       // Send data byte
    }

    while(SSIBusy(SSI0_BASE));
    GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, GPIO_PIN_CS);    // Set chip select high
}

void ft800mem_Write16(unsigned long ftAddress, unsigned int ftData16)
{
    unsigned char cTempAddr[3];                                                                           // FT800 Memory Address
    unsigned char cTempData[2];                                                                           // 16-bit data to write

    cTempAddr[2] = (char) (ftAddress >> 16) | MEM_WRITE;                           // Compose the command and address to send
    cTempAddr[1] = (char) (ftAddress >> 8);                                                        // middle byte
    cTempAddr[0] = (char) (ftAddress);                                                                 // low byte

    cTempData[1] = (char) (ftData16 >> 8);                                                         // Compose data to be sent - high byte
    cTempData[0] = (char) (ftData16);                                                                  // low byte

    GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, 0);                         // Set chip select low
    while(SSIDataGetNonBlocking(SSI0_BASE, &pui32DataRx) != 0);

    for (i = 2; i >= 0; i--)
    {
        SSIDataPut(SSI0_BASE, cTempAddr[i]);                                                // Send Memory Write plus high address byte
    }

    for (j = 1; j >= 0; j--)                                                                                          // Start with least significant byte
    {
        SSIDataPut(SSI0_BASE, cTempData[j]);                                               // Send data byte
    }

    while(SSIBusy(SSI0_BASE));
    GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, GPIO_PIN_CS);    // Set chip select high
}

void ft800mem_Write32(unsigned long ftAddress, unsigned long ftData32)
{
    unsigned char cTempAddr[3];                                                                          // FT800 Memory Address
    unsigned char cTempData[4];                                                                         // 32-bit data to write

    cTempAddr[2] = (char) (ftAddress >> 16) | MEM_WRITE;        // Compose the command and address to send
    cTempAddr[1] = (char) (ftAddress >> 8);                     // middle byte
    cTempAddr[0] = (char) (ftAddress);                          // low byte

    cTempData[3] = (char) (ftData32 >> 24);                     // Compose data to be sent - high byte
    cTempData[2] = (char) (ftData32 >> 16);                     //
    cTempData[1] = (char) (ftData32 >> 8);                      //
    cTempData[0] = (char) (ftData32);                           // low byte

    GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, 0);              // Set chip select low
    while(SSIDataGetNonBlocking(SSI0_BASE, &pui32DataRx) != 0);

    for (i = 2; i >= 0; i--)
    {
        SSIDataPut(SSI0_BASE, cTempAddr[i]);                    // Send Memory Write plus high address byte
    }

    for (j = 3; j >= 0; j--)                                    // Start with least significant byte
    {
        SSIDataPut(SSI0_BASE, cTempData[j]);                    // Send data byte
    }

    while(SSIBusy(SSI0_BASE));
    GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, GPIO_PIN_CS);    // Set chip select high
}

Read functions:

unsigned char ft800mem_Read8(unsigned long ftAddress)
{
    unsigned char ftData8 = 0;                                      // Place-holder for 8-bits being read
    unsigned char cTempAddr[3];                                 // FT800 Memory Address
    unsigned char cZeroFill = ZERO;

    cTempAddr[2] = (char) (ftAddress >> 16) | MEM_READ;         // Compose the command and address to send
    cTempAddr[1] = (char) (ftAddress >> 8);                     // middle byte
    cTempAddr[0] = (char) (ftAddress);                          // low byte

    GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, 0);              // Set chip select low
    while(SSIDataGetNonBlocking(SSI0_BASE, &pui32DataRx) != 0);

    for (i = 2; i >= 0; i--)
    {
        SSIDataPut(SSI0_BASE, cTempAddr[i]);                    // Send Memory Write plus high address byte
    }

    SSIDataPut(SSI0_BASE, cZeroFill);                           // Send dummy byte

    for (j = 0; j < sizeof(ftData8); j++)                       // Start with least significant byte
    {
        SSIDataGet(SSI0_BASE, &ftData8);                        // Receive data byte
    }

    while(SSIBusy(SSI0_BASE));
    GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, GPIO_PIN_CS);    // Set chip select high

  return ftData8;                                               // Return 8-bits
}

unsigned int ft800mem_Read16(unsigned long ftAddress)
{
    unsigned int ftData16 = 0;                                      // 16-bits to return
    unsigned char cTempAddr[3];                                 // FT800 Memory Address
    unsigned char cTempData[2];                                 // Place-holder for 16-bits being read
    unsigned char cZeroFill = ZERO;

    cTempAddr[2] = (char) (ftAddress >> 16) | MEM_READ;         // Compose the command and address to send
    cTempAddr[1] = (char) (ftAddress >> 8);                     // middle byte
    cTempAddr[0] = (char) (ftAddress);                          // low byte

    GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, 0);              // Set chip select low
    while(SSIDataGetNonBlocking(SSI0_BASE, &pui32DataRx) != 0);

  for (i = 2; i >= 0; i--)
    {
      SSIDataPut(SSI0_BASE, cTempAddr[i]);                      // Send Memory Write plus high address byte
    }

    SSIDataPut(SSI0_BASE, cZeroFill);                           // Send dummy byte

    for (j = 0; j < sizeof(cTempData); j++)                     // Start with least significant byte
    {
        SSIDataGetNonBlocking(SSI0_BASE, &cTempData[j]);        // Receive data byte
    }

    while(SSIBusy(SSI0_BASE));
    GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, GPIO_PIN_CS);    // Set chip select high

    ftData16 = (cTempData[1]<< 8) |                             // Compose value to return - high byte
                       (cTempData[0]);                          // low byte

  return ftData16;                                          // Return 16-bits
}

unsigned long ft800mem_Read32(unsigned long ftAddress)
{
    unsigned long ftData32 = 0;                                     // 32-bits to return
    unsigned char cTempAddr[3];                                 // FT800 Memory Address
    unsigned char cTempData[4];                                 // Place holder for 32-bits being read
    unsigned char cZeroFill= ZERO;                              // Dummy byte

    cTempAddr[2] = (char) (ftAddress >> 16) | MEM_READ;         // Compose the command and address to send
    cTempAddr[1] = (char) (ftAddress >> 8);                     // middle byte
    cTempAddr[0] = (char) (ftAddress);                          // low byte

    GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, 0);              // Set chip select low
    while(SSIDataGetNonBlocking(SSI0_BASE, &pui32DataRx) != 0);

    for (i = 2; i >= 0; i--)
    {
        SSIDataPut(SSI0_BASE, cTempAddr[i]);                    // Send Memory Write plus high address byte
    }

    SSIDataPut(SSI0_BASE, cZeroFill);                           // Send dummy byte

    for (j = 0; j < sizeof(cTempData); j++)                     // Start with least significatn byte
    {
        SSIDataGetNonBlocking(SSI0_BASE, &cTempData[j]);        // Receive data byte
    }

    while(SSIBusy(SSI0_BASE));
    GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, GPIO_PIN_CS);    // Set chip select high

    ftData32 = (cTempData[3]<< 24) |                            // Compose value to return - high byte
                         (cTempData[2]<< 16) |
                         (cTempData[1]<< 8) |
                         (cTempData[0]);                        // Low byte

  return ftData32;                                              // Return 32-bits
}

This function increase the command pointer:

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset;                                      // Used to hold new offset
    newOffset = currentOffset + commandSize;                     // Calculate new offset
    if(newOffset > 4095)                                         // If new offset past boundary...
    {
        newOffset = (newOffset - 4096);                          // ... roll over pointer
    }
    return newOffset;                                            // Return new offset
}

And this is the SSI init function:

void ConfigureSSI(void)
{
     MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);
     MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

     MAP_GPIOPinConfigure(GPIO_PA2_SSI0CLK);
     //MAP_GPIOPinConfigure(GPIO_PA3_SSI0FSS);
     MAP_GPIOPinConfigure(GPIO_PA4_SSI0XDAT0); //Tx
     MAP_GPIOPinConfigure(GPIO_PA5_SSI0XDAT1); //RX
     MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_2);

     MAP_SSIConfigSetExpClk(SSI0_BASE, 120000000, SSI_FRF_MOTO_MODE_0, SSI_MODE_MASTER, 10000000, 8);
     
     MAP_SSIEnable(SSI0_BASE);
}

Hello Angelo,

Thanks for the code post. The issue as I see is that when a read operation is done, it is a non-blocking read which is being done without a write and flush operation.

unsigned char ft800mem_Read8(unsigned long ftAddress)
{
unsigned char ftData8 = 0; // Place-holder for 8-bits being read
unsigned char cTempAddr[3]; // FT800 Memory Address
unsigned char cZeroFill = ZERO;

cTempAddr[2] = (char) (ftAddress >> 16) | MEM_READ; // Compose the command and address to send
cTempAddr[1] = (char) (ftAddress >> 8); // middle byte
cTempAddr[0] = (char) (ftAddress); // low byte

GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, 0); // Set chip select low
while(SSIDataGetNonBlocking(SSI0_BASE, &pui32DataRx) != 0);

for (i = 2; i >= 0; i--)
{
SSIDataPut(SSI0_BASE, cTempAddr[i]); // Send Memory Write plus high address byte
}

SSIDataPut(SSI0_BASE, cZeroFill); // Send dummy byte

for (j = 0; j < sizeof(ftData8); j++) // Start with least significant byte
{
SSIDataGet(SSI0_BASE, &ftData8); // Receive data byte
}

while(SSIBusy(SSI0_BASE));
GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, GPIO_PIN_CS); // Set chip select high

return ftData8;
}

Must be

unsigned char ft800mem_Read8(unsigned long ftAddress)
{
unsigned char ftData8 = 0; // Place-holder for 8-bits being read
unsigned char cTempAddr[3]; // FT800 Memory Address
unsigned char cZeroFill = ZERO;

cTempAddr[2] = (char) (ftAddress >> 16) | MEM_READ; // Compose the command and address to send
cTempAddr[1] = (char) (ftAddress >> 8); // middle byte
cTempAddr[0] = (char) (ftAddress); // low byte

GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, 0); // Set chip select low
while(SSIDataGetNonBlocking(SSI0_BASE, &pui32DataRx) != 0);

for (i = 2; i >= 0; i--)
{
SSIDataPut(SSI0_BASE, cTempAddr[i]); // Send Memory Write plus high address byte
}
while(SSIDataGetNonBlocking(SSI0_BASE, &pui32DataRx) != 0);

SSIDataPut(SSI0_BASE, cZeroFill); // Send dummy byte

for (j = 0; j < sizeof(ftData8); j++) // Start with least significant byte
{
SSIDataGet(SSI0_BASE, &ftData8); // Receive data byte
}

while(SSIBusy(SSI0_BASE));
GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_CS, GPIO_PIN_CS); // Set chip select high

return ftData8;
}

Hello Angel

Please use SSIDataGet instead of SSIDataGetNonBlocking for flush operation during an active transaction where SSIDataPut is called.

Hello Amit

Sorry to answer until now. I used SSIDataGet instead of SSIDataGetNonBlocking and I got the same answer.

I have a question. How can I change the LBS and MBS parameters?


Regards

Hello Angel

Do you mean MSB and LSB? If yes, then it cannot be changed.

Hi,

Reading the ARM application note specified by you in the first post:

a) There is specified the SSI setting: COPL=0, CPHA=1; please see the SSI driverlib code, there are all info needed to set correctly the SPI module.

b) Same document specify the sending order: least significant byte first. Seems you send it most significant byte first, your for loop should start from i=0, not 2

c) SPI should send MSB first, aka most significant  bit first.

Yes I mean MSB and LSB.

Hello Angel

No. MSB and LSB cannot be swapped.

Hello

Many thanks for your early answers.

I have been a little confused with the setting: COPL=0, CPHA=1 (it is mode 1) and the FT800 datasheet specified the SSI setting must be COPL=0, CPHA=0 (it is mode 0).
And yes you have reason petrei the SPI should send MSB first but I would like know How can I change the LSB and MSB parameters in the SSI module.

I think in those settings are the trouble.
(comment: I am practicing my english too, if I have any bad expression please tell me)

Regards

Hello

Many thanks for your early answers.

I have been a little confused with the setting: COPL=0, CPHA=1 (it is mode 1) and the FT800 datasheet specified the SSI setting must be COPL=0, CPHA=0 (it is mode 0).
And yes you have reason petrei the SPI should send MSB first.

I think in those settings are the trouble.
(comment: I am practicing my english too, if I have any bad expression please tell me)

Regards

Hello

Many thanks for your early answers.

I have been a little confused with the setting: COPL=0, CPHA=1 (it is mode 1) and the FT800 datasheet specified the SSI setting must be COPL=0, CPHA=0 (it is mode 0).

And yes you have reason petrei the SPI should send MSB first.

I think in those settings are the trouble.

(comment: I am practicing my english too, if I have any bad expression please tell me)

Regards

Hello Angel

I would then suggest making the change for the correct operational mode. However, that should not be the cause as the entire transaction is shifted by one byte. I do believe it is a missing SSI RXFIFO data flush. To double check, connect a scope probe to CS, CLK, MISO and MOSI and check what the transaction on the bus and the code execution read of the data at that particular instance shows.

Hello Amit

I was reading about SSI configuration and I made some changes in my funtions. yes I had a wrong in the functions. Now I'm able to write graphics on the LCDDisplay througth the FT800 drive but I still have Issues reading, for that reason I opened other post about the read with SSI port on FT800 drive.

this is the link: e2e.ti.com/.../566770

thank you

Angel Nino

Hello Angel

And I have responded to the same.... Advanced mode usage is different from the Legacy mode usage. We would use the new post to correspond on the same.