SPI0 in kit C6748LCDK

please help me !, it is my graduation project

I think you need to clarify what you mean by "it did not wor". Most of the code uses StarterWare functions. It looks okay. I have never used the ADXL345, so here is some general comments.

1) The delay functionmay get optimized out. Adding volatile might help:
void Delay(volatile unsigned int N){
        while(N--);

}

2) Assignment of tx_data in GetData() is misleading. From what I've read from the datasheet, GetData() will read back six 16-bit registers starting with register at address DATAX0. The GetData() function could be reduced to:
static void GetData(void){
        tx_data[0] = (DATAX0|0xC0);
        rx_len = 13;
        tx_len = 13;
        SPIDat1Config(SOC_SPI_0_REGS,
                (SPI_CSHOLD | SPI_DATA_FORMAT3), 0x10);
        SpiTransfer();

}

3) A stylistic thing. Avoid magic numbers like 0xC0
OP_READ    0x10
OP_WRITE   0x00
MULTI_BYTE  0x10
SINGLE_BYTE 0x00
Use "OP_READ|MULTI_BYTE" instead of "0xC0"


4) The ADXL345 datasheet would suggest that the POLARITY=1 and PHASE=0. The config is then:
SPIConfigClkFormat(SOC_SPI_0_REGS,
                    SPI_CLK_POL_HIGH|SPI_CLK_INPHASE,
                    dataFormat);

Hi Trinh Trung,

Please refer the below thread for SPI0 pin usage.

http://e2e.ti.com/support/dsp/omap_applications_processors/f/42/t/282359.aspx

Thanks.

thank for your helping so much, but it didn't run strictly with your code.

Oops. Just noticed I used the wrong values for the constants. Should be something like:

OP_READ    0x80
OP_WRITE   0x00
MULTI_BYTE  0x40
SINGLE_BYTE 0x00

You should use an oscilloscope to see exactly what is coming out on the SPI pins.

Does the signals match the ADXL345 datasheet?

How do you know it does not work?

sorry Norman Wong because  of my delay for reply.

First of all, thank for your comments.

I did as your suggestions: i read information from the sensor : OP_READ    0x80 | MULTI_BYTE  0x40

but your error is SPI_CLK_POL_HIGH and SPI_CLK_INPHASE

I read datasheet of ADXL345 CLK_POL is 1 and  Phase is 1 so that SPI_CLK_POL_HIGH(1) and SPI_CLK_OUTOFPHASE(1)

And when i read information, from DATAX0 to DATAZ1, they are zeros completely. 

i think that error comes from timming. maybe in bus SPI or configuring delay for setup time or hold time. i am trying to test.   

Note much more to add. I'd try all four combinations of Polarity and Phase. The ADXL345 SPI timing diagram

and the C6748 Polarity =1 / Phase = 0 diagram

The ADXL345 diagram is admittedly hard to understand with nothing lining up. The C6748 diagram is far too idealized. But in both cases, data is stable on the rising edge of SCLK and SCLK is high on idle.

thank for your enthusiasm.

how about SPI0 bus configuration: SPIClkConfigure(SOC_SPI_0_REGS,15000000,2000000,SPI_DATA_FORMAT0); is it true for SPI0 bus 2MHz ?

Your example is one zero short. The 15000000 should be 150000000. For the LCDK StarterWare examples, the GEL scripts setup the PLL clock to be 300Mhz. SPI is clocked by SYSCLK_2 which is half that. The StarterWare headers have constant for each clock.

#include <soc_C6748.h>
SPIClkConfigure(SOC_SPI_0_REGS,SOC_SPI_0_MODULE_FREQ,2000000,SPI_DATA_FORMAT0)

The function SPIClkConfigure() use this code:
prescale = (moduleClk/spiClk) - 1;

plug in the numbers:

prescale = (moduleClk/spiClk) - 1;
  = (150000000/2000000) - 1;
  = 75-1
  = 74

Reverse the calc using the TRM formula:

SPI clock frequency = SPI module clock/(PRESCALE + 1)
 = 150000000/(74 + 1)
 = 2000000

Putting a scope on would verify the clock frequency. Try reading back registers with known values instead of the changing sensor values.

Upon further reading of the ADXL345 datasheet, I don't think you can write to many discontiguous registers in one SPI transaction. I think you should try writing one register at a time. Also you should be reading 3x16-bit registers or 6x8-bit registers for the data.

#define DEVID 0x00 /* Put in ADXL345.h */

static short BytesToShort(unsigned char bytes[2])
{
  unsigned short v;
  v = (bytes[1] <<8) | (bytes[0]);
  return((short)v);
}


static void GetData(void){
        short datax;
        short datay;
        short dataz;

        tx_data[0] = (DATAX0|OP_READ|MULTI_BYTE);
        rx_len = 1+3*2;
        tx_len = 1+3*2;
        SpiTransfer();
        datax = BytesToShort(&rx_data[1]);
        datay = BytesToShort(&rx_data[3]);
        dataz = BytesToShort(&rx_data[5]);

        UARTprintf("DATAX = %d\r\n", datax);
        UARTprintf("DATAY = %d\r\n", datay);
        UARTprintf("DATAZ = %d\r\n", dataz);
}

static void SpiTransfer(void){
        p_tx = &tx_data[0];
        p_rx = &rx_data[0];

        /* Move all SPIDat1Config() calls to here. */
        SPIDat1Config(SOC_SPI_0_REGS,(SPI_CSHOLD|SPI_DATA_FORMAT3),0x10);/*Assert CS*/
        SPIIntEnable(SOC_SPI_0_REGS,SPI_RECV_INT|SPI_TRANSMIT_INT);
        while(flag);
        flag =1;
        SPIDat1Config(SOC_SPI_0_REGS,SPI_DATA_FORMAT3,0x10);/*Deassert CS*/
}

static unsigned char ADXL345Read1(unsigned char addr){
        tx_data[0] = addr | OP_READ | SINGLE_BYTE;
        tx_len = 2;
        rx_len = 2;
        SpiTransfer();
        return(rx_data[0]);
}

static void ADXL345Write1(unsigned char addr, unsigned char value){
        tx_data[0] = addr | OP_WRITE | SINGLE_BYTE;
        tx_data[1] = value;
        tx_len = 2;
        rx_len = 2;
        SpiTransfer();
}

static void SetUpADXL345(){
        ADXL345Write1(DATA_FORMAT, SSI_4WIRE|FULL_RES|JUS_RIGHT|RANGE16);
        ADXL345Write1(BW_RATE, BW_3200HZ);
        ADXL345Write1(POWER_CTL, MEASURE);

        /* Read back*/
        UARTprintf("DEVID      =0x%02X\r\n", (int)ADXL345Read1(DEVID)); /* Should 0xE5 */
        UARTprintf("DATA_FORMAT=0x%02X\r\n", (int)ADXL345Read1(DATA_FORMAT));
        UARTprintf("BW_RATE    =0x%02X\r\n", (int)ADXL345Read1(BW_RATE));
        UARTprintf("POWER_CTL  =0x%02X\r\n", (int)ADXL345Read1(POWER_CTL));
}

thank u, all your code that i tested, it still doesn't  work. 

What doesn't work? What values do you receive? What do the SPI signals looks like?

sorry for my delay

data outs zero, i tested for take DEVID. the below is all my code. 

#include <string.h>
#include "soc_C6748.h"
#include "hw_psc_C6748.h"
#include "lcdkC6748.h"
#include "uart.h"
#include "uartStdio.h"
#include "spi.h"
#include "psc.h"
#include "interrupt.h"
#include "ADXL345.h"
#include "stdio.h"


#define SIMO_SOMI_CLK_CS    0x00000E10    // using SIMO, SOMI, CLK, CS4
#define CHAR_LENGTH            0x8
#define DEVID                0x00

static void SPIConfigDataFmtReg(unsigned int dataFormat);
static void SpiTransfer(void);
static void SetUpInt(void);
static void SetUpSPI(void);
static void SetUpADXL345(void);
//static void GetData(void);
static void Delay(volatile unsigned int N);
static void SetDATA_FORMAT(void);
static void SetBW_RATE(void);
static void SetPOWER_CTL(void);
static unsigned char ADXL345Read1(unsigned char addr);
void SPIIsr(void);

volatile unsigned int flag = 1;
unsigned int tx_len;
unsigned int rx_len;
unsigned char *p_tx;
volatile unsigned char *p_rx;
unsigned char tx_data[260];
unsigned char rx_data[260];
char RES[8];

void main(void) {
    int id;
    //unsigned int i;
    PSCModuleControl(SOC_PSC_0_REGS,HW_PSC_SPI0,                //use
            PSC_POWERDOMAIN_ALWAYS_ON,PSC_MDCTL_NEXT_ENABLE);
    SPIPinMuxSetup(0);        // using PINMUX
    SPI0CSPinMuxSetup(4);    //not use CS pin here
    UARTStdioInit();
    UARTPuts("Hello ",-1);


    SetUpInt();        // setup interrupt for DSP
    SetUpSPI();        // setup SPI0 function for DSP

    SetUpADXL345();    // setup ADXL345 sensor
    Delay(100000);
    // get data
    //GetData();

    SPIDat1Config(SOC_SPI_0_REGS,(SPI_CSHOLD | SPI_DATA_FORMAT2), 0x10);
    id =  (int)ADXL345Read1(DEVID);
    sprintf(RES,"%d",id);
    UARTPuts(RES,-1);



}
/*static void GetData(void){
    unsigned int i;
        tx_data[0] = (DATAX0|0xC0);    // read data with multiple data
        tx_data[1] = 0x00;
        tx_data[2] = 0x00;
        tx_data[3] = 0x00;
        tx_data[4] = 0x00;
        tx_data[5] = 0x00;
        tx_data[6] = 0x00;

        rx_len =7;
        tx_len =7;
        SPIDat1Config(SOC_SPI_0_REGS,(SPI_CSHOLD | SPI_DATA_FORMAT2), 0x10);

        SpiTransfer();        // transfer data

        for(i=0;i<6;i++){
                    if(rx_data[i+1] == 0)
                        UARTPuts("ZERO",-1);
                    else
                        UARTPuts("DIFF",-1);
            }

}*/
static void SetUpADXL345(){    //configure function for ADXL345

        SetDATA_FORMAT();
        SetBW_RATE();
        SetPOWER_CTL();

}

static void SetDATA_FORMAT(){
        tx_data[0] = DATA_FORMAT;        // baud-rate register of the sensor
        tx_data[1] = (SSI_4WIRE|FULL_RES|JUS_RIGHT|RANGE16); //using 4-wire, full_ress (13 bits, gather information is leftmost significant byte
        tx_len = rx_len = 2;
        SPIDat1Config(SOC_SPI_0_REGS,(SPI_CSHOLD|SPI_DATA_FORMAT0),0x10);    // assert CS4 and CS

        SpiTransfer();


}
static void SetBW_RATE(){
            tx_data[0] = BW_RATE;
            tx_data[1] = BW_3200HZ;        // output data from sensor is 3200Hz
            tx_len = rx_len = 2;
            SPIDat1Config(SOC_SPI_0_REGS,(SPI_CSHOLD|SPI_DATA_FORMAT0),0x10);    // assert CS4 pin, CS4 is low when transfer

            SpiTransfer();

}

static void SetPOWER_CTL(){
            tx_data[0] = POWER_CTL;        // start measure for sensor
            tx_data[1] = MEASURE;
            tx_len = rx_len = 2;

            SPIDat1Config(SOC_SPI_0_REGS,(SPI_CSHOLD|SPI_DATA_FORMAT0),0x10);    // assert CS pin CS is low when transfer

            SpiTransfer();


}
static unsigned char ADXL345Read1(unsigned char addr){
        tx_data[0] = addr |0x80;
        tx_data[1] = 0;
        tx_len = 2;
        rx_len = 2;
        SpiTransfer();
        return(rx_data[0]);
}
static void SetUpInt(void){            // register SPI0 interrupt

    IntDSPINTCInit();

    IntRegister(C674X_MASK_INT4,SPIIsr);

    IntEventMap(C674X_MASK_INT4,SYS_INT_SPI0_INT);

    IntEnable(C674X_MASK_INT4);

    IntGlobalEnable();

}

static void SetUpSPI(void){
    unsigned char cs = 0x10;
    unsigned char dcs = 0x10;
    unsigned int  val = SIMO_SOMI_CLK_CS;

    SPIReset(SOC_SPI_0_REGS);        // reset SPI0

    SPIOutOfReset(SOC_SPI_0_REGS);      // get SPI0 out of reset

    SPIModeConfigure(SOC_SPI_0_REGS, SPI_MASTER_MODE);        // DSP  is MASTER mode

    SPIClkConfigure(SOC_SPI_0_REGS,150000000,2000000,SPI_DATA_FORMAT0);        // SPI0 bus =2MHZ


    SPIPinControl(SOC_SPI_0_REGS,0,0,&val);        //using SIMO,SOMI,CLK, CS4 declared in val

    SPIDefaultCSSet(SOC_SPI_0_REGS,dcs);    // high if no transmission

    SPIConfigDataFmtReg(SPI_DATA_FORMAT0);    //    using DATAFORMAT 3

    SPIDat1Config(SOC_SPI_0_REGS,(SPI_CSHOLD|SPI_DATA_FORMAT0),cs);        // assert CS pin, CS is low when transfer


    SPIIntLevelSet(SOC_SPI_0_REGS,SPI_RECV_INTLVL|SPI_TRANSMIT_INTLVL);        // set interrupt level


    SPIEnable(SOC_SPI_0_REGS);    // enable SPI

}

static void SPIConfigDataFmtReg(unsigned int dataFormat){


        SPIConfigClkFormat(SOC_SPI_0_REGS,SPI_CLK_POL_HIGH|        // POL = high
                                 SPI_CLK_INPHASE,dataFormat);    // PHASE = high

        SPIShiftMsbFirst(SOC_SPI_0_REGS,dataFormat);

        SPICharLengthSet(SOC_SPI_0_REGS,CHAR_LENGTH,dataFormat);    // each trans is 8 bits

}

void Delay(unsigned int N){
        while(N--);

}


static void SpiTransfer(void){
        p_tx = &tx_data[0];
        p_rx = &rx_data[0];

        SPIIntEnable(SOC_SPI_0_REGS,SPI_RECV_INT|SPI_TRANSMIT_INT);         //     enable interrupt
        while(flag);        // when trans complete
        flag =1;
        SPIDat1Config(SOC_SPI_0_REGS,SPI_DATA_FORMAT0,0x10);    // deassert CS4 pin, CS is high
}
void SPIIsr(void){        // process interrupt

        unsigned int intCode = 0;
        IntEventClear(SYS_INT_SPI0_INT);
        intCode = SPIInterruptVectorGet(SOC_SPI_0_REGS);    // read status of BUFFER

        while(intCode){

                if(intCode == SPI_TX_BUF_EMPTY){

                        tx_len--;
                        SPITransmitData1(SOC_SPI_0_REGS,*p_tx);    // transmit data
                        p_tx++;
                        if(!tx_len){
                                SPIIntDisable(SOC_SPI_0_REGS,SPI_TRANSMIT_INT);

                        }

                }
                if(intCode == SPI_RECV_FULL){

                    rx_len--;
                    *p_rx = (unsigned char)SPIDataReceive(SOC_SPI_0_REGS);        // receive data
                    p_rx++;
                    if(!rx_len){
                            flag = 0;
                            SPIIntDisable(SOC_SPI_0_REGS,SPI_RECV_INT);

                    }

                }
            intCode = SPIInterruptVectorGet(SOC_SPI_0_REGS);
        }
}

The call is to ADXL345Read1() is preceded with SPIDat1Config() of SPI_DATA_FORMAT2. SPI_DATA_FORMAT2 is not configured. SPI_DATA_FORMAT0 is configured and is used everywhere else except for the commentted out GetData().

The Delay function need a volatile or else the compiler might optimize it out:
void Delay(volatile unsigned int N){
        while(N--);
}

I doubt any of the above will make it work. You really need to see the signals on the scope.

I've only used the LCDK to validate my SPI code without actually talking to a SPI device. I vaguely remember I had HW conflicts that stopped me from using the SPI ports for testting. I checked the LCDK schematic and the SPI0 pins are connected to the Ethernet chip. Those same pins are NOT connected to J15 because resistors to J15 are not populated.

J15:SPIO_SIMO = SPI0_SIMO, Maybe remove R184, Add R214
J15:SPIO_SOMI = SPI0_SOMI, Maybe remove R179, Add R215
J15:SPIO_CLK  = SPI0_CLK,  Maybe remove R178, Add R216
J15:UART0_RX  = SPI0_SCSN_4,  Remove R173, Add R219

In theory, you can install R214-R219 and keep the other resistors. This will retain use of the Ethernet. See here:

http://e2e.ti.com/support/dsp/omap_applications_processors/f/42/t/234899.aspx

thank  u !!!

I changed code for SPI1 but problem happened in here. I tried to print the below values to screen:

// the below is code to display DEVID, DATAFORMAT, BW_RATE and POWER_CTL as you mentioned

while(1){

    UARTprintf("DEVID: %d \n",Read1(DEVID|RD_CM));

    UARTprintf("DATAFORMAT: %d \n  ",Read1(DATA_FORMAT|RD_CM));

    UARTprintf("BR : %d \n",Read1(BW_RATE|RD_CM));

    UARTprintf("PCTL: %d \n",Read1(POWER_CTL|RD_CM));


    Delay(1000000);

    }

but output is that: DEVID: 299, DATAFORMAT: 299, BR: 299 and PCTL: 299

can u help me again ?

//all my code:

// SPI1 application for ADXL345
//SPI1: J16 connector  SP1_SIMO (36), SPI1_SOMI (31),
//                        SPI1_CLK (32), SPI1_SCSn_3 (34)
//SPI1 bus = 2MHz

#include <string.h>
#include "soc_C6748.h"
#include "lcdkC6748.h"
#include "spi.h"
#include "interrupt.h"
#include "uartStdio.h"
#include "uart.h"
#include "stdio.h"
#include "psc.h"
#include "hw_psc_C6748.h"
#include "ADXL345.h"

void SetUpInt();
static void SetUpSPI1();
static void SPIConfigDataFmtReg(unsigned int dataFormat);
static void SpiTransfer();
void SPIIsr(void);
static void SetUp_ADXL345(void);
static void SetDATA_FORMAT(void);
static void SetBW_RATE(void);
static void SetPOWER_CTL(void);
unsigned char Read1(unsigned char dat);
void Delay(volatile unsigned int N );
//short BytesToShort(volatile unsigned char bytes[2]);
//static void GetData(void);

#define PIN_SPI1_USE        0xE08
#define CHAR_LENGTH            0x08
#define RD_CM                0x80        // read command
#define WR_CM                0x00        // write command
#define RD_MULTIPLE            0x40        // read multiple bytes
#define DEVID                0x00        // 0xE5
#define SPI1BUF                (*((volatile unsigned int *) 0x01F0E040))        // SPI1_BUF register address
#define TXF                    0x20000000        // TX buf is full   => 1
#define RXE                    0x80000000        // RX buf is empty  => 1
volatile unsigned int flag =1;
unsigned int tx_len;
unsigned int rx_len;
unsigned char tx_data[260];
volatile unsigned char rx_data[260];
unsigned char *p_tx;
volatile unsigned char *p_rx;
char RES[8];
void main(void) {
    //unsigned int i;

    PSCModuleControl(SOC_PSC_1_REGS,HW_PSC_SPI1, PSC_POWERDOMAIN_ALWAYS_ON,
                            PSC_MDCTL_NEXT_ENABLE);

    SPIPinMuxSetup(1);
    SPI1CSPinMuxSetup(3);
    UARTStdioInit();
    UARTPuts("Hello software...",-1);
    UARTPutc(0x0A);
    UARTPutc(0x0D);

    SetUpInt();
    SetUpSPI1();
    SetUp_ADXL345();

    while(1){

    UARTprintf("DEVID: %d \n",Read1(DEVID|RD_CM));

    UARTprintf("DATAFORMAT: %d \n  ",Read1(DATA_FORMAT|RD_CM));

    UARTprintf("BR : %d \n",Read1(BW_RATE|RD_CM));

    UARTprintf("PCTL: %d \n",Read1(POWER_CTL|RD_CM));


    Delay(1000000);

    }


}


/*
 short BytesToShort(volatile unsigned char bytes[2])
{
  unsigned short v;
  v = (bytes[1] <<8) | (bytes[0]);
  return((short)v);
}


static void GetData(void){
        short datax;
        short datay;
        short dataz;

        tx_data[0] = (DATAX0|RD_CM|RD_MULTIPLE);

        rx_len = 1+3*2;
        tx_len = 1+3*2;
        SpiTransfer();
        datax = BytesToShort(&rx_data[1]);
        datay = BytesToShort(&rx_data[3]);
        dataz = BytesToShort(&rx_data[5]);

        UARTprintf("DATAX = %d\r\n", datax);
        UARTprintf("DATAY = %d\r\n", datay);
        UARTprintf("DATAZ = %d\r\n", dataz);
}

*/
void Delay(volatile unsigned int N ){
    while(N--);

}


unsigned char Read1(unsigned char dat){

    tx_data[0] = dat;
    tx_len =  2;
    rx_len = 2;
    SPIDat1Config(SOC_SPI_0_REGS,(SPI_CSHOLD|SPI_DATA_FORMAT0),0x08);
    SpiTransfer();
    return rx_data[0];

}


static void SetUp_ADXL345(){

        SetDATA_FORMAT();
        SetBW_RATE();
        SetPOWER_CTL();

}

static void SetDATA_FORMAT(){

                tx_data[0] = (DATA_FORMAT);
                tx_data[1] = (SSI_4WIRE|FULL_RES|JUS_RIGHT|RANGE16);
                tx_len = rx_len = 2;
                SPIDat1Config(SOC_SPI_0_REGS,(SPI_CSHOLD|SPI_DATA_FORMAT0),0x08);    // assert CS4 and CS
                SpiTransfer();

}

static void SetBW_RATE(){
                tx_data[0] = BW_RATE;
                tx_data[1] = BW_800HZ;        // output data from sensor is 3200Hz

                tx_len = rx_len = 2;
                SPIDat1Config(SOC_SPI_0_REGS,(SPI_CSHOLD|SPI_DATA_FORMAT0),0x08);    // assert CS4 pin, CS4 is low when transfer
                SpiTransfer();
}

static void SetPOWER_CTL(){
                tx_data[0] = POWER_CTL;        // start measure for sensor
                tx_data[1] = MEASURE;

                tx_len = rx_len = 2;
                SPIDat1Config(SOC_SPI_0_REGS,(SPI_CSHOLD|SPI_DATA_FORMAT0),0x08);    // assert CS pin CS is low when transfer
                SpiTransfer();

}

//interrupt setup
void SetUpInt(){
    IntDSPINTCInit();

    IntRegister(C674X_MASK_INT4,SPIIsr);

    IntEventMap(C674X_MASK_INT4, SYS_INT_SPI1_INT);

    IntEnable(C674X_MASK_INT4);

    IntGlobalEnable();

}

// SPI1 setup
static void SetUpSPI1(){
        unsigned char cs = 0x08;    // SCSn_3
        unsigned char dcs = 0x08;
        unsigned int val = PIN_SPI1_USE;

        SPIReset(SOC_SPI_1_REGS);
        SPIOutOfReset(SOC_SPI_1_REGS);
        SPIModeConfigure(SOC_SPI_1_REGS, SPI_MASTER_MODE);
        SPIClkConfigure(SOC_SPI_1_REGS,150000000,1000000,SPI_DATA_FORMAT0);
        SPIPinControl(SOC_SPI_1_REGS, 0, 0, &val);
        SPIDefaultCSSet(SOC_SPI_1_REGS,dcs);

        SPIConfigDataFmtReg(SPI_DATA_FORMAT0);

        SPIDat1Config(SOC_SPI_1_REGS,(SPI_CSHOLD|SPI_DATA_FORMAT0),cs);
        SPIIntLevelSet(SOC_SPI_1_REGS,SPI_RECV_INTLVL|SPI_TRANSMIT_INTLVL);
        SPIEnable(SOC_SPI_1_REGS);

}

static void SPIConfigDataFmtReg(unsigned int dataFormat){

    SPIConfigClkFormat(SOC_SPI_1_REGS,(SPI_CLK_POL_HIGH|SPI_CLK_INPHASE),
                        dataFormat);

    SPIShiftMsbFirst(SOC_SPI_1_REGS,dataFormat);
    SPICharLengthSet(SOC_SPI_1_REGS,CHAR_LENGTH,dataFormat);

}



static void SpiTransfer(){

    p_tx = &tx_data[0];
    p_rx = &rx_data[0];
    SPIIntEnable(SOC_SPI_1_REGS,(SPI_TRANSMIT_INT|SPI_RECV_INT));
    while(flag);
    flag = 1;
    SPIDat1Config(SOC_SPI_1_REGS, SPI_DATA_FORMAT0, 0x08);


}


void SPIIsr(void)
{
    unsigned int intCode = 0;

    IntEventClear(SYS_INT_SPI1_INT);


    intCode = SPIInterruptVectorGet(SOC_SPI_1_REGS);

    while (intCode)
    {
        if(intCode == SPI_TX_BUF_EMPTY)
        {
            tx_len--;
            SPITransmitData1(SOC_SPI_1_REGS, *p_tx);
            p_tx++;
            if (!tx_len)
            {
                SPIIntDisable(SOC_SPI_1_REGS, SPI_TRANSMIT_INT);
            }
        }

        if(intCode == SPI_RECV_FULL)
        {
            rx_len--;
            *p_rx = (unsigned char)SPIDataReceive(SOC_SPI_1_REGS);
            p_rx++;
            if (!rx_len)
            {
                flag = 0;
                SPIIntDisable(SOC_SPI_1_REGS, SPI_RECV_INT);
            }
        }

        intCode = SPIInterruptVectorGet(SOC_SPI_1_REGS);
    }
}

You should not be able to  get the value 299 as it is larger than a 8-bit value. I suspect that you need to cast the value from Read1() to int before passing it to UARTprintf(). The 6748 is little endian, so you are probably grabbing the next 3 bytes to complete the int. So 299 = 0x12B or 0x2B. Which is still not a good value.

Which version of the LCDK to you have? Version 5 has a AES850 chip connected to SPI1. On Version 6 the chip is not populated.

Your code still references SOC_SPI_0_REGS in Read1(). Change to SOC_SPI_0_REGS ro SOC_SPI_1_REGS in that function as well as all other places, eg SetDATA_FORMAT(), SetBW_RATE(), SetPOWER_CTL(). Everything else looks good for SPI1 config and use.

oh, thank u so much, my code run strictly as i hope. one more time, thank for your enthusiasm