CCS/TMS320F28069M: SPI Communication using F28069M Not sending more than 2 data(int) without interrupt

Gaurav shinde

Part Number: TMS320F28069M

Tool/software: Code Composer Studio

Respected sir,

I am trying to communicate between Two F28069m Launchpad using SPI Communication without interrupt one is slave and another one is master. but i am not able to send and receive more than two data.

please help me out with your suggestion.

thank you.

My Code For Master:

//###########################################################################
//
// FILE: Example_2806xSpi_FFDLB.c
//
// TITLE: SPI Digital Loop Back Example
//
//! \addtogroup f2806x_example_list
//! <h1>SPI Digital Loop Back(spi_loopback)</h1>
//!
//! This program uses the internal loop back test mode of the peripheral.
//! Other then boot mode pin configuration, no other hardware configuration
//! is required. Interrupts are not used.
//!
//! A stream of data is sent and then compared to the received stream.
//! The sent data looks like this: \n
//! 0000 0001 0002 0003 0004 0005 0006 0007 .... FFFE FFFF \n
//! This pattern is repeated forever.
//!
//! \b Watch \b Variables \n
//! - \b sdata , sent data
//! - \b rdata , received data
//
////###########################################################################
// $TI Release: F2806x Support Library v2.04.00.00 $
// $Release Date: Thu Oct 18 15:47:20 CDT 2018 $
// $Copyright:
// Copyright (C) 2009-2018 Texas Instruments Incorporated - http://www.ti.com/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the
// distribution.
//
// Neither the name of Texas Instruments Incorporated nor the names of
// its contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// $
//#############################################################################

//
// Included Files
//
#include "DSP28x_Project.h" // Device Headerfile and Examples Include File
#include <stdbool.h>
#include <stdint.h>
//
// Function Prototypes
//
void spi_xmit(Uint16 a);
void spi_fifo_init(void);
void spi_init(void);
void error(void);

//
// Main
//
void main(void)
{
Uint16 sdata; // send data
Uint16 rdata; // received data
Uint16 rxdata;
Uint16 tdata;
//
// Step 1. Initialize System Control:
// PLL, WatchDog, enable Peripheral Clocks
// This example function is found in the F2806x_SysCtrl.c file.
//
InitSysCtrl();

//
// Step 2. Initalize GPIO:
// This example function is found in the F2806x_Gpio.c file and
// illustrates how to set the GPIO to it's default state.
//
//InitGpio(); // Skipped for this example

//
// Setup only the GP I/O only for SPI-A functionality
// This function is found in F2806x_Spi.c
//
InitSpiaGpio();

//
// Step 3. Clear all interrupts and initialize PIE vector table:
// Disable CPU interrupts
//
DINT;

//
// Initialize PIE control registers to their default state.
// The default state is all PIE interrupts disabled and flags
// are cleared.
// This function is found in the F2806x_PieCtrl.c file.
//
InitPieCtrl();

//
// Disable CPU interrupts and clear all CPU interrupt flags
//
IER = 0x0000;
IFR = 0x0000;

//
// Initialize the PIE vector table with pointers to the shell Interrupt
// Service Routines (ISR).
// This will populate the entire table, even if the interrupt
// is not used in this example. This is useful for debug purposes.
// The shell ISR routines are found in F2806x_DefaultIsr.c.
// This function is found in F2806x_PieVect.c.
//
InitPieVectTable();

//
// Step 4. Initialize all the Device Peripherals:
// This function is found in F2806x_InitPeripherals.c
//
//InitPeripherals(); // Not required for this example
spi_fifo_init(); // Initialize the Spi FIFO
spi_init(); // init SPI

//
// Step 5. User specific code:
// Interrupts are not used in this example.
//
sdata = 0x0000;
uint16_t array1[10] = {2412,2043,14,15,16,17,18,19,20,21};
uint16_t array2[10];
uint16_t i;
for(;;)
{
//
// Transmit data
//
for(i=0;i<=8;i++)
{
SpiaRegs.SPICTL.bit.TALK = 1;
spi_xmit(array1[i]);
DELAY_US(100);
// SpiaRegs.SPITXBUF = 0;
}

for(i=0;i<=8;i++)
{
SpiaRegs.SPICTL.bit.TALK = 0;
while(SpiaRegs.SPIFFRX.bit.RXFFST !=1);
array2[i] = SpiaRegs.SPIRXBUF;
DELAY_US(100);
// SpiaRegs.SPIRXBUF = 0;
}

//
// Wait until data is received
//

/* spi_xmit(tdata);

//
// Check against sent data
//
while(SpiaRegs.SPIFFRX.bit.RXFFST !=1);
rxdata = SpiaRegs.SPIRXBUF;
*/
sdata++;
tdata++;
}
}

//
// error - Step 7. Insert all local Interrupt Service Routines (ISRs)
// and functions here
//
void
error(void)
{
__asm(" ESTOP0"); // Test failed!! Stop!
for (;;);
}

//
// spi_init -
//
void
spi_init()
{
SpiaRegs.SPICCR.all =0x000F; // Reset on, rising edge, 16-bit char bits
SpiaRegs.SPICCR.bit.SPICHAR = 2;
//
// Enable master mode, normal phase, enable talk, and SPI int disabled.
//
SpiaRegs.SPICTL.all =0x0006;

SpiaRegs.SPIBRR =0x007F;
SpiaRegs.SPICCR.all =0x009F; // Relinquish SPI from Reset
SpiaRegs.SPIPRI.bit.FREE = 1; // Set so breakpoints don't disturb xmission
SpiaRegs.SPICTL.bit.MASTER_SLAVE =1;
}

//
// spi_xmit -
//
void
spi_xmit(Uint16 a)
{
SpiaRegs.SPITXBUF=a;
}

//
// spi_fifo_init -
//
void
spi_fifo_init(void)
{
//
// Initialize SPI FIFO registers
//
SpiaRegs.SPIFFTX.all=0xE040;
SpiaRegs.SPIFFRX.all=0x2044;
SpiaRegs.SPIFFCT.all=0x0;
}

//
// End of File
//

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

And For SLAVE ///////////////////////////////////////////////////

//
// Main
//
void main(void)
{
Uint16 sdata; // send data
Uint16 rdata; // received data

//
// Step 1. Initialize System Control:
// PLL, WatchDog, enable Peripheral Clocks
// This example function is found in the F2806x_SysCtrl.c file.
//
InitSysCtrl();

//
// Step 2. Initalize GPIO:
// This example function is found in the F2806x_Gpio.c file and
// illustrates how to set the GPIO to it's default state.
//
//InitGpio(); // Skipped for this example

//
// Setup only the GP I/O only for SPI-A functionality
// This function is found in F2806x_Spi.c
//
InitSpiaGpio();

//
// Step 3. Clear all interrupts and initialize PIE vector table:
// Disable CPU interrupts
//
DINT;

//
// Disable CPU interrupts and clear all CPU interrupt flags
//
IER = 0x0000;
IFR = 0x0000;

//
// Step 5. User specific code:
// Interrupts are not used in this example.
//
sdata = 0x0000;
uint16_t i;
// uint16_t array_data[10] ={1,2,3,4,5,6,7,8,9,10};
uint16_t array_data_1[100];
while(1)
{
//

//
for(i=0;i<=8;i++){
SpiaRegs.SPICTL.bit.TALK = 0;
while(SpiaRegs.SPIFFRX.bit.RXFFST !=1){}
array_data_1[i] = SpiaRegs.SPIRXBUF;
DELAY_US(100);
// SpiaRegs.SPIRXBUF = 0;
}

for(i=0;i<=8;i++)
{
SpiaRegs.SPICTL.bit.TALK = 1;
spi_xmit(array_data_1[i]);
DELAY_US(100);
// SpiaRegs.SPITXBUF = 0;
}

/* while(SpiaRegs.SPIFFRX.bit.RXFFST !=1){}
array_data_1[0] = SpiaRegs.SPIRXBUF;
DELAY_US(100);
while(SpiaRegs.SPIFFRX.bit.RXFFST !=1){}
array_data_1[1] = SpiaRegs.SPIRXBUF;
DELAY_US(100);
while(SpiaRegs.SPIFFRX.bit.RXFFST !=1){}
array_data_1[0] = SpiaRegs.SPIRXBUF;
DELAY_US(100);
while(SpiaRegs.SPIFFRX.bit.RXFFST !=1){}
array_data_1[1] = SpiaRegs.SPIRXBUF;
DELAY_US(100);
for(i=0;i<=9;i++)
{
spi_xmit(array_data_1[i]);
DELAY_US(100);
}*/
/*
for(i=0;i<=9;i++){
spi_xmit(array_data[i]);
}
//
// Wait until data is received
//
for(i=0;i<=9;i++)
{
while(SpiaRegs.SPIFFRX.bit.RXFFST !=1){}
array_data_1[i] = SpiaRegs.SPIRXBUF;
}
*/

// if(rdata != sdata)
// {
// error();
// }

sdata++;
}
}

//
// error - Step 7. Insert all local Interrupt Service Routines (ISRs)
// and functions here
//
void
error(void)
{
__asm(" ESTOP0"); // Test failed!! Stop!
for (;;);
}

//
// spi_init -
//
void
spi_init()
{
SpiaRegs.SPICCR.all =0x000F; // Reset on, rising edge, 16-bit char bits

//
// Enable master mode, normal phase, enable talk, and SPI int disabled.
//
SpiaRegs.SPICTL.all =0x0006;

SpiaRegs.SPIBRR =0x007F;
SpiaRegs.SPICCR.all =0x009F; // Relinquish SPI from Reset
SpiaRegs.SPIPRI.bit.FREE = 1; // Set so breakpoints don't disturb xmission
SpiaRegs.SPICTL.bit.MASTER_SLAVE =0;
}

//
// spi_xmit -
//
void
spi_xmit(Uint16 a)
{
// SpiaRegs.SPITXBUF=a;
SpiaRegs.SPITXBUF = a |(a<<8);

}

//
// spi_fifo_init -
//
void
spi_fifo_init(void)
{
//
// Initialize SPI FIFO registers
//
SpiaRegs.SPIFFTX.all=0xE040;
SpiaRegs.SPIFFRX.all=0x2044;
SpiaRegs.SPIFFCT.all=0x0;
}

//
// End of File
//

over 5 years ago

0 Whitney Dewey over 5 years ago

TI__Guru 53175 points

Please use the syntax highlighter tool to format your code (it's the "</>" button in the reply toolbar). It was challenging to read the code you shared without the formatting.

I did notice is that you aren't checking whether or not the FIFO is full before you try to send data. The delay you added is probably long enough to make sure it gets sent, but checking the SPIFFTX.TXFFST would be more reliable.

Saying while(SpiaRegs.SPIFFRX.bit.RXFFST !=1) might cause you problems too. What if another word arrives before it can read the previous one and your RXFFST gets set to 2 or higher? It might make more sense to say while(SpiaRegs.SPIFFRX.bit.RXFFST==0). That way you just read until the FIFO is empty.

Also, keep in mind that with SPI, you're shifting in data every time you send it, so even if what you're receiving isn't meaningful data, it's filling up your RXFIFO, so you may want to do some dummy reads of SPIRXBUF to clear out the data you don't care about.

Whitney

0 Gaurav shinde over 5 years ago in reply to Whitney Dewey

Prodigy 20 points

Hello Whitney

I am trying with your suggestion and i found out that now SPI not Receiving and Transmitting more than 6 Byte of data.

here is my new edit

MASTER :

SPIA_&_SPIB_Master_slave_com_21_11_19_16_37.c

Fullscreen

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
//###########################################################################
//
// FILE:   Example_2806xSpi_FFDLB.c
//
// TITLE:  SPI Digital Loop Back Example
//
//!  \addtogroup f2806x_example_list
//!  <h1>SPI Digital Loop Back(spi_loopback)</h1>
//!
//!  This program uses the internal loop back test mode of the peripheral.
//!  Other then boot mode pin configuration, no other hardware configuration
//!  is required. Interrupts are not used.
//!
//!  A stream of data is sent and then compared to the received stream.
//!  The sent data looks like this: \n
//!  0000 0001 0002 0003 0004 0005 0006 0007 .... FFFE FFFF \n
//!  This pattern is repeated forever.
//!
//!  \b Watch \b Variables \n
//!  - \b sdata , sent data
//!  - \b rdata , received data
//
////###########################################################################
// $TI Release: F2806x Support Library v2.04.00.00 $
// $Release Date: Thu Oct 18 15:47:20 CDT 2018 $
// $Copyright:
// Copyright (C) 2009-2018 Texas Instruments Incorporated - http://www.ti.com/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
//   Redistributions of source code must retain the above copyright
//   notice, this list of conditions and the following disclaimer.
//
//   Redistributions in binary form must reproduce the above copyright
//   notice, this list of conditions and the following disclaimer in the
//   documentation and/or other materials provided with the
//   distribution.
//
//   Neither the name of Texas Instruments Incorporated nor the names of
//   its contributors may be used to endorse or promote products derived
//   from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// $
//#############################################################################
//
// Included Files
//
#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File
#include <stdbool.h>
#include <stdint.h>
//
// Function Prototypes
//
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

//###########################################################################
//
// FILE:   Example_2806xSpi_FFDLB.c
//
// TITLE:  SPI Digital Loop Back Example
//
//!  \addtogroup f2806x_example_list
//!  <h1>SPI Digital Loop Back(spi_loopback)</h1>
//!
//!  This program uses the internal loop back test mode of the peripheral.
//!  Other then boot mode pin configuration, no other hardware configuration
//!  is required. Interrupts are not used.
//!
//!  A stream of data is sent and then compared to the received stream.
//!  The sent data looks like this: \n
//!  0000 0001 0002 0003 0004 0005 0006 0007 .... FFFE FFFF \n
//!  This pattern is repeated forever.
//!
//!  \b Watch \b Variables \n
//!  - \b sdata , sent data
//!  - \b rdata , received data
//
////###########################################################################
// $TI Release: F2806x Support Library v2.04.00.00 $
// $Release Date: Thu Oct 18 15:47:20 CDT 2018 $
// $Copyright:
// Copyright (C) 2009-2018 Texas Instruments Incorporated - http://www.ti.com/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
//   Redistributions of source code must retain the above copyright
//   notice, this list of conditions and the following disclaimer.
//
//   Redistributions in binary form must reproduce the above copyright
//   notice, this list of conditions and the following disclaimer in the
//   documentation and/or other materials provided with the
//   distribution.
//
//   Neither the name of Texas Instruments Incorporated nor the names of
//   its contributors may be used to endorse or promote products derived
//   from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// $
//#############################################################################

//
// Included Files
//
#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File
#include <stdbool.h>
#include <stdint.h>
//
// Function Prototypes
//
void spi_xmit(int a);
void spi_fifo_init(void);
void spi_init(void);
void error(void);

//
// Main
//
void main(void)
{
    Uint16 sdata;  // send data
    Uint16 rdata;  // received data
    Uint16 rxdata;
    Uint16 tdata;
    //
    // Step 1. Initialize System Control:
    // PLL, WatchDog, enable Peripheral Clocks
    // This example function is found in the F2806x_SysCtrl.c file.
    //
    InitSysCtrl();

    //
    // Step 2. Initalize GPIO:
    // This example function is found in the F2806x_Gpio.c file and
    // illustrates how to set the GPIO to it's default state.
    //
    //InitGpio();  // Skipped for this example

    //
    // Setup only the GP I/O only for SPI-A functionality
    // This function is found in F2806x_Spi.c
    //
    InitSpiaGpio();

    //
    // Step 3. Clear all interrupts and initialize PIE vector table:
    // Disable CPU interrupts
    EALLOW;
    GpioCtrlRegs.GPBMUX1.bit.GPIO44 = 0;
    GpioCtrlRegs.GPBDIR.bit.GPIO44 =  1;
    //
    EDIS;

    DINT;
 //   GpioDataRegs.GPBSET.bit.GPIO44 = 1;//GPIO_setHigh(myGpio, D0);
    //GpioDataRegs.GPBCLEAR.bit.GPIO44 = 1;//GPIO_setLow(myGpio, D0);
    //
    // Initialize PIE control registers to their default state.
    // The default state is all PIE interrupts disabled and flags
    // are cleared.
    // This function is found in the F2806x_PieCtrl.c file.
    //
    InitPieCtrl();

    //
    // Disable CPU interrupts and clear all CPU interrupt flags
    //
    IER = 0x0000;
    IFR = 0x0000;

    //
    // Initialize the PIE vector table with pointers to the shell Interrupt
    // Service Routines (ISR).
    // This will populate the entire table, even if the interrupt
    // is not used in this example.  This is useful for debug purposes.
    // The shell ISR routines are found in F2806x_DefaultIsr.c.
    // This function is found in F2806x_PieVect.c.
    //
    InitPieVectTable();

    //
    // Step 4. Initialize all the Device Peripherals:
    // This function is found in F2806x_InitPeripherals.c
    //
    //InitPeripherals(); // Not required for this example
    spi_fifo_init();      // Initialize the Spi FIFO
    spi_init();       // init SPI

    //
    // Step 5. User specific code:
    // Interrupts are not used in this example.
    //
    sdata = 0x0000;
    uint16_t array1[10] = {40,3,14,15,16,17,18,19,20,21};
    int array2[10];
    uint16_t array3[10];
    uint16_t i;
    int data_array[10] = {11,21,31,41,51,101,102,103,104,105};
    GpioDataRegs.GPBSET.bit.GPIO44 = 1;
    for(;;)
    {
       for(i=0;i<=6;i++)
       {
            spi_xmit(data_array[i]);
            DELAY_US(1);
       }
        for(i=0;i<=6;i++)
          {
            while(SpiaRegs.SPIFFRX.bit.RXFFST ==0);
            array2[i] = SpiaRegs.SPIRXBUF;
            DELAY_US(1);
         }

        //
        // Transmit data
        //





/*
       for(i=0;i<=1;i++)
        {
        SpiaRegs.SPICTL.bit.TALK = 1;
//        while(SpiaRegs.SPISTS.bit.BUFFULL_FLAG == 1);
        spi_xmit(array1[i]);
        DELAY_US(100);
//        SpiaRegs.SPITXBUF = 0;
        }

        for(i=0;i<=1;i++)
        {
        SpiaRegs.SPICTL.bit.TALK = 0;
//        while(SpiaRegs.SPISTS.bit.BUFFULL_FLAG == 1);
        while(SpiaRegs.SPIFFRX.bit.RXFFST !=1);
        array2[i] = SpiaRegs.SPIRXBUF;
        DELAY_US(100);
//        SpiaRegs.SPIRXBUF = 0;
        }
*/


        //
        // Wait until data is received
        //



/*        spi_xmit(tdata);

        //
        // Check against sent data
        //
        while(SpiaRegs.SPIFFRX.bit.RXFFST !=1);
        rxdata = SpiaRegs.SPIRXBUF;
*/
        sdata++;
        tdata++;
    }
}

//
// error - Step 7. Insert all local Interrupt Service Routines (ISRs)
// and functions here
//
void
error(void)
{
    __asm("     ESTOP0");                       // Test failed!! Stop!
    for (;;);
}

//
// spi_init -
//
void
spi_init()
{
    SpiaRegs.SPICCR.all =0x000F;  // Reset on, rising edge, 16-bit char bits
//    SpiaRegs.SPICCR.bit.SPICHAR = 8;
    //
    // Enable master mode, normal phase, enable talk, and SPI int disabled.
    //
    SpiaRegs.SPICTL.all =0x0006;

    SpiaRegs.SPIBRR =0x007F;
    SpiaRegs.SPICCR.all =0x009F;   // Relinquish SPI from Reset
    SpiaRegs.SPIPRI.bit.FREE = 1;  // Set so breakpoints don't disturb xmission
    SpiaRegs.SPICTL.bit.MASTER_SLAVE =1;
}

//
// spi_xmit -
//
void
spi_xmit(int a)
{
    while(SpiaRegs.SPISTS.bit.BUFFULL_FLAG == 1);
    while(SpiaRegs.SPIFFTX.bit.TXFFST ==1);
    SpiaRegs.SPITXBUF=a;
}

//
// spi_fifo_init -
//
void
spi_fifo_init(void)
{
    //
    // Initialize SPI FIFO registers
    //
    SpiaRegs.SPIFFTX.all=0xE040;
    SpiaRegs.SPIFFRX.all=0x2044;
    SpiaRegs.SPIFFCT.all=0x0;
}

//
// End of File
//

SLAVE :

SPIA_slave_com_21_11_19_16_37.c

Fullscreen

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
//###########################################################################
//
// FILE:   Example_2806xSpi_FFDLB.c
//
// TITLE:  SPI Digital Loop Back Example
//
//!  \addtogroup f2806x_example_list
//!  <h1>SPI Digital Loop Back(spi_loopback)</h1>
//!
//!  This program uses the internal loop back test mode of the peripheral.
//!  Other then boot mode pin configuration, no other hardware configuration
//!  is required. Interrupts are not used.
//!
//!  A stream of data is sent and then compared to the received stream.
//!  The sent data looks like this: \n
//!  0000 0001 0002 0003 0004 0005 0006 0007 .... FFFE FFFF \n
//!  This pattern is repeated forever.
//!
//!  \b Watch \b Variables \n
//!  - \b sdata , sent data
//!  - \b rdata , received data
//
////###########################################################################
// $TI Release: F2806x Support Library v2.04.00.00 $
// $Release Date: Thu Oct 18 15:47:20 CDT 2018 $
// $Copyright:
// Copyright (C) 2009-2018 Texas Instruments Incorporated - http://www.ti.com/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
//   Redistributions of source code must retain the above copyright
//   notice, this list of conditions and the following disclaimer.
//
//   Redistributions in binary form must reproduce the above copyright
//   notice, this list of conditions and the following disclaimer in the
//   documentation and/or other materials provided with the
//   distribution.
//
//   Neither the name of Texas Instruments Incorporated nor the names of
//   its contributors may be used to endorse or promote products derived
//   from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// $
//#############################################################################
//
// Included Files
//
#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File
#include <stdbool.h>
#include <stdint.h>
//
// Function Prototypes
//
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

//###########################################################################
//
// FILE:   Example_2806xSpi_FFDLB.c
//
// TITLE:  SPI Digital Loop Back Example
//
//!  \addtogroup f2806x_example_list
//!  <h1>SPI Digital Loop Back(spi_loopback)</h1>
//!
//!  This program uses the internal loop back test mode of the peripheral.
//!  Other then boot mode pin configuration, no other hardware configuration
//!  is required. Interrupts are not used.
//!
//!  A stream of data is sent and then compared to the received stream.
//!  The sent data looks like this: \n
//!  0000 0001 0002 0003 0004 0005 0006 0007 .... FFFE FFFF \n
//!  This pattern is repeated forever.
//!
//!  \b Watch \b Variables \n
//!  - \b sdata , sent data
//!  - \b rdata , received data
//
////###########################################################################
// $TI Release: F2806x Support Library v2.04.00.00 $
// $Release Date: Thu Oct 18 15:47:20 CDT 2018 $
// $Copyright:
// Copyright (C) 2009-2018 Texas Instruments Incorporated - http://www.ti.com/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
//   Redistributions of source code must retain the above copyright
//   notice, this list of conditions and the following disclaimer.
//
//   Redistributions in binary form must reproduce the above copyright
//   notice, this list of conditions and the following disclaimer in the
//   documentation and/or other materials provided with the
//   distribution.
//
//   Neither the name of Texas Instruments Incorporated nor the names of
//   its contributors may be used to endorse or promote products derived
//   from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// $
//#############################################################################

//
// Included Files
//
#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File
#include <stdbool.h>
#include <stdint.h>
//
// Function Prototypes
//
void spi_xmit(int a);
void spi_fifo_init(void);
void spi_init(void);
void error(void);

//
// Main
//
void main(void)
{
    Uint16 sdata;  // send data
    Uint16 rdata;  // received data

    //
    // Step 1. Initialize System Control:
    // PLL, WatchDog, enable Peripheral Clocks
    // This example function is found in the F2806x_SysCtrl.c file.
    //
    InitSysCtrl();

    //
    // Step 2. Initalize GPIO:
    // This example function is found in the F2806x_Gpio.c file and
    // illustrates how to set the GPIO to it's default state.
    //
    //InitGpio();  // Skipped for this example

    //
    // Setup only the GP I/O only for SPI-A functionality
    // This function is found in F2806x_Spi.c
    //
    InitSpiaGpio();

    //
    // Step 3. Clear all interrupts and initialize PIE vector table:
    // Disable CPU interrupts
    //
    DINT;

    //
    // Initialize PIE control registers to their default state.
    // The default state is all PIE interrupts disabled and flags
    // are cleared.
    // This function is found in the F2806x_PieCtrl.c file.
    //
    InitPieCtrl();

    //
    // Disable CPU interrupts and clear all CPU interrupt flags
    //
    IER = 0x0000;
    IFR = 0x0000;

    //
    // Initialize the PIE vector table with pointers to the shell Interrupt
    // Service Routines (ISR).
    // This will populate the entire table, even if the interrupt
    // is not used in this example.  This is useful for debug purposes.
    // The shell ISR routines are found in F2806x_DefaultIsr.c.
    // This function is found in F2806x_PieVect.c.
    //
    InitPieVectTable();

    //
    // Step 4. Initialize all the Device Peripherals:
    // This function is found in F2806x_InitPeripherals.c
    //
    //InitPeripherals(); // Not required for this example
    spi_fifo_init();      // Initialize the Spi FIFO
    spi_init();       // init SPI

    //
    // Step 5. User specific code:
    // Interrupts are not used in this example.
    //
    sdata = 0x0000;
    uint16_t i;
//    uint16_t array_data[10] ={1,2,3,4,5,6,7,8,9,10};
   int array_data_1[10];
   int array_data_2[10];

    while(1)
    {
        //
/*        array3[0] = (array1[0] & 0xFF);
        array3[1] = ((array1[0]>>8 )& 0xFF);
        array3[2] = (array1[1] & 0xFF);
        array3[3] = ((array1[1]>>8 )& 0xFF);
        array3[4] = (array1[2] & 0xFF);
        array3[5] = ((array1[2]>>8 )& 0xFF);
        array3[6] = (array1[3] & 0xFF);
        array3[7] = ((array1[3]>>8 )& 0xFF);*/
//        array3[8] = (array1[4] & 0xFF);
//        array3[9] = ((array1[4]>>8 )& 0xFF);



                for(i=0;i<=7;i++){
                while(SpiaRegs.SPIFFRX.bit.RXFFST !=1){}
                array_data_1[i] = SpiaRegs.SPIRXBUF;
//                DELAY_US(1);000
                }

                        for(i=0;i<=7;i++)
                        {
                        spi_xmit(array_data_1[i]);
//                        DELAY_US(1);
                        }



        //
//        for(i=0;i<=8;i++){
//        SpiaRegs.SPICTL.bit.TALK = 0;
//        while(SpiaRegs.SPIFFRX.bit.RXFFST !=1){}
//
//        array_data_1[i] = SpiaRegs.SPIRXBUF;
//        DELAY_US(100);
////        SpiaRegs.SPIRXBUF = 0;
//        }
//
//        for(i=0;i<=8;i++)
//        {
//        SpiaRegs.SPICTL.bit.TALK = 1;
//
//        spi_xmit(array_data_1[i]);
//        DELAY_US(100);
////        SpiaRegs.SPITXBUF = 0;
//        }

/*        while(SpiaRegs.SPIFFRX.bit.RXFFST !=1){}
        array_data_1[0] = SpiaRegs.SPIRXBUF;
        DELAY_US(100);
        while(SpiaRegs.SPIFFRX.bit.RXFFST !=1){}
        array_data_1[1] = SpiaRegs.SPIRXBUF;
        DELAY_US(100);
        while(SpiaRegs.SPIFFRX.bit.RXFFST !=1){}
        array_data_1[0] = SpiaRegs.SPIRXBUF;
        DELAY_US(100);
        while(SpiaRegs.SPIFFRX.bit.RXFFST !=1){}
        array_data_1[1] = SpiaRegs.SPIRXBUF;
        DELAY_US(100);
        for(i=0;i<=9;i++)
        {
        spi_xmit(array_data_1[i]);
        DELAY_US(100);
        }*/
        /*
        for(i=0;i<=9;i++){
        spi_xmit(array_data[i]);
        }
        //
        // Wait until data is received
        //
        for(i=0;i<=9;i++)
        {
        while(SpiaRegs.SPIFFRX.bit.RXFFST !=1){}
        array_data_1[i] = SpiaRegs.SPIRXBUF;
        }
*/



//        if(rdata != sdata)
//        {
//            error();
//        }

        sdata++;
    }
}

//
// error - Step 7. Insert all local Interrupt Service Routines (ISRs)
// and functions here
//
void
error(void)
{
    __asm("     ESTOP0");                       // Test failed!! Stop!
    for (;;);
}

//
// spi_init -
//
void
spi_init()
{
    SpiaRegs.SPICCR.all =0x000F;  // Reset on, rising edge, 16-bit char bits

    //
    // Enable master mode, normal phase, enable talk, and SPI int disabled.
    //
    SpiaRegs.SPICTL.all =0x0006;

    SpiaRegs.SPIBRR =0x007F;
    SpiaRegs.SPICCR.all =0x009F;   // Relinquish SPI from Reset
    SpiaRegs.SPIPRI.bit.FREE = 1;  // Set so breakpoints don't disturb xmission
    SpiaRegs.SPICTL.bit.MASTER_SLAVE =0;
}

//
// spi_xmit -
//
void
spi_xmit(int a)
{
//    SpiaRegs.SPITXBUF=a;
    while(SpiaRegs.SPIFFTX.bit.TXFFST ==1);
    SpiaRegs.SPITXBUF=a;

}

//
// spi_fifo_init -
//
void
spi_fifo_init(void)
{
    //
    // Initialize SPI FIFO registers
    //
    SpiaRegs.SPIFFTX.all=0xE040;
    SpiaRegs.SPIFFRX.all=0x2044;
    SpiaRegs.SPIFFCT.all=0x0;
}

//
// End of File
//

0 Whitney Dewey over 5 years ago in reply to Gaurav shinde

TI__Guru 53175 points

Your slave side code still says while(SpiaRegs.SPIFFRX.bit.RXFFST !=1) instead of while(SpiaRegs.SPIFFRX.bit.RXFFST==0).

Which receive/tranmit isn't working? Are you able to successfully run the master-transmit/slave-recieve loop of the code, but the slave-transmit/master-receive loop fails or are you not getting that far in the code yet?

Do you have a logic analyzer or oscilloscope or some tool that you can use to watch the transmissions on the signals that may help you debug?

Whitney

C2000™︎ microcontrollers

C2000 microcontrollers forum

CCS/TMS320F28069M: SPI Communication using F28069M Not sending more than 2 data(int) without interrupt