This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

DMA issue on spi interface in cc3200

Other Parts Discussed in Thread: CC3200, ENERGIA

Hi,

I am currently working on CC3200 rev3.2 board. I want interface cc3200 with Davinci-dm365 board through SPI interface, where cc3200 acts as a slave and dm365 is a Master.

I have done it successfully using interrupt mode.

Now I enabled DMA channels for SPI transactions, as below 

#define MASTER_MODE 0



#define TR_BUFF_SIZE 38

//*****************************************************************************
// Global variables
//*****************************************************************************
static unsigned char g_ucTxBuff[TR_BUFF_SIZE]="This is CC3200 SPI Slave Application writing to Mcam-board\n\r";


static unsigned char g_ucRxBuff[TR_BUFF_SIZE];

BoardInit();

//
// Initialize uDMA
//
UDMAInit();
//
// Muxing UART and SPI lines.
//
PinMuxConfig();

//
// Enable the SPI module clock
//
MAP_PRCMPeripheralClkEnable(PRCM_GSPI,PRCM_RUN_MODE_CLK);

//
// Initialising the Terminal.
//
InitTerm();

//
// Clearing the Terminal.
//
ClearTerm();

//
// Display the Banner
//
Message("\n\n\n\r");
Message("\t\t ********************************************\n\r");
Message("\t\t CC3200 SPI Demo Application \n\r");
Message("\t\t ********************************************\n\r");
Message("\n\n\n\r");

//
// Reset the peripheral
//
MAP_PRCMPeripheralReset(PRCM_GSPI);


//
// Reset SPI
//
MAP_SPIReset(GSPI_BASE);

//
// Configure SPI interface
//
MAP_SPIConfigSetExpClk(GSPI_BASE,MAP_PRCMPeripheralClockGet(PRCM_GSPI),
SPI_IF_BIT_RATE,SPI_MODE_SLAVE,SPI_SUB_MODE_0,
(SPI_HW_CTRL_CS |
SPI_4PIN_MODE |
SPI_TURBO_OFF |
SPI_CS_ACTIVELOW |
SPI_WL_8));

//
// Enable SPI for communication
//

MAP_uDMAChannelAssign( UDMA_CH30_GSPI_RX);
MAP_uDMAChannelAssign( UDMA_CH31_GSPI_TX );
//
// Register Interrupt Handler
//
MAP_SPIIntRegister(GSPI_BASE,SlaveIntHandler);

MAP_SPIEnable(GSPI_BASE);

//
// Enable Interrupts. dma will cause intr on completion of transfer
//

MAP_SPIIntEnable(GSPI_BASE,SPI_INT_DMATX);
MAP_SPIIntEnable(GSPI_BASE,SPI_INT_DMARX);


//
// Configure the control parameters for the spi TX. The uDMA spi TX
// channel is used to transfer a block of data from a buffer to the tx-reg.
// The data size is 8 bits. The source address increment is 8-bit bytes
// since the data is coming from a buffer. The destination increment is
// none since the data is to be written to the spi data register. The
// arbitration size is set to 1,
//


SetupTransfer(UDMA_CH30_GSPI_RX | UDMA_PRI_SELECT,
UDMA_MODE_BASIC,
sizeof(g_ucRxBuff),
UDMA_SIZE_8,
UDMA_ARB_1,
(void *)(GSPI_BASE + MCSPI_O_RX0),
UDMA_SRC_INC_NONE,
g_ucRxBuff, UDMA_DST_INC_8);

SetupTransfer(UDMA_CH31_GSPI_TX| UDMA_PRI_SELECT,
UDMA_MODE_BASIC,
sizeof(g_ucTxBuff),
UDMA_SIZE_8,
UDMA_ARB_1,
g_ucTxBuff,
UDMA_SRC_INC_8,
(void *)(GSPI_BASE + MCSPI_O_TX0),
UDMA_DST_INC_NONE);

MAP_SPIDmaEnable(GSPI_BASE, SPI_RX_DMA | SPI_TX_DMA);


//
// Print mode on uart
//
Message("(DMA) Enabled SPI Interface in Slave Mode\n\rReceived : ");

Here I'm facing Two main problems

1>   interrupt handler should be called after a total number of bytes transferred by DMA channel, to indicate transfer was done.

but sometimes, when I run the program interrupt handler is getting called immediately, and indicating DMA receive channel is in STOP mode, which occures after total number of transfers. it is happening though the Master is idle (No clock given to slave).

2> sometimes interrupt is not called immediately, but called after total byte transfers by DMA, which is desired.

in this case Master receiving the data sent by slave, but slave is not receiving any data. I put a print inside receive channel stop condition.

Handler is written as follows.

static void SlaveIntHandler()
{

unsigned long ulMode;

Message("Slave hndlr\n");

ulMode = MAP_uDMAChannelModeGet(UDMA_CH30_GSPI_RX | UDMA_PRI_SELECT);

if(ulMode == UDMA_MODE_STOP)
{
Message("Rx done and data received is:\n");
Report("%s\n\r",g_ucRxBuff);

MAP_SPIDmaDisable(GSPI_BASE, SPI_RX_DMA);
}
ulMode = MAP_uDMAChannelModeGet(UDMA_CH31_GSPI_TX | UDMA_PRI_SELECT);

if(ulMode == UDMA_MODE_STOP)
{
Message("Tx done\n\r");

MAP_SPIDmaDisable(GSPI_BASE, SPI_TX_DMA );

}

}

Thank you,

VinodKumar.

  • 3542.main.c
    //*****************************************************************************
    // main.c
    //
    // The demo application focuses on showing the required initialization
    // sequence to enable the CC3200 SPI module in full duplex 4-wire master
    // and slave mode(s).
    //
    // Copyright (C) 2014 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.
    //
    //*****************************************************************************
    
    #include <string.h>
    #include "hw_types.h"
    #include "hw_memmap.h"
    #include "hw_common_reg.h"
    #include "hw_mcspi.h"
    #include "hw_ints.h"
    #include "spi.h"
    #include "pin.h"
    #include "rom.h"
    #include "rom_map.h"
    #include "utils.h"
    #include "prcm.h"
    #include "interrupt.h"
    #include "pinmux.h"
    #include "uart.h"
    #include "udma.h"
    #include "uart_if.h"
    #include "udma_if.h"
    
    
    //*****************************************************************************
    //
    // Application Master/Slave mode selector macro
    //
    // MASTER_MODE = 1 : Application in master mode
    // MASTER_MODE = 0 : Application in slave mode
    //
    //*****************************************************************************
    #define MASTER_MODE      0
    
    
    #define SPI_IF_BIT_RATE  100000
    #define TR_BUFF_SIZE     20
    
    #define MASTER_MSG "This is CC3200 SPI Master Application\n\r"
    #define SLAVE_MSG "This is CC3200 SPI Slave Application\n\r"
    
    //*****************************************************************************
    // Global variables
    //*****************************************************************************
    static unsigned char g_ucTxBuff[TR_BUFF_SIZE];
    static unsigned char g_ucRxBuff[TR_BUFF_SIZE];
    static unsigned char ucTxBuffNdx;
    static unsigned char ucRxBuffNdx;
    
    #if defined(ccs)
    extern void (* const g_pfnVectors[])(void);
    #endif
    
    #if defined(ewarm)
    extern uVectorEntry __vector_table;
    #endif
    
    //*****************************************************************************
    //
    //! SPI Slave Interrupt handler
    //!
    //! This function is invoked when SPI slave has its receive register full or
    //! transmit register empty.
    //!
    //! \return None.
    //
    //*****************************************************************************
    static void SlaveIntHandler()
    {
      unsigned long ulRecvData;
      unsigned long ulStatus;
    
      ulStatus = MAP_SPIIntStatus(GSPI_BASE,true);
    
      MAP_SPIIntClear(GSPI_BASE,SPI_INT_DMARX|SPI_INT_DMATX);
    
    #if 0
      if(ulStatus & SPI_INT_TX_EMPTY)
      {
        MAP_SPIDataPut(GSPI_BASE,g_ucTxBuff[ucTxBuffNdx%TR_BUFF_SIZE]);
        ucTxBuffNdx++;
      }
    
      if(ulStatus & SPI_INT_RX_FULL)
      {
        MAP_SPIDataGetNonBlocking(GSPI_BASE,&ulRecvData);
        g_ucTxBuff[ucRxBuffNdx%TR_BUFF_SIZE] = ulRecvData;
        Report("%c",ulRecvData);
        ucRxBuffNdx++;
      }
    #endif
    }
    
    //*****************************************************************************
    //
    //! SPI Master mode main loop
    //!
    //! This function configures SPI modelue as master and enables the channel for
    //! communication
    //!
    //! \return None.
    //
    //*****************************************************************************
    void MasterMain()
    {
    
      unsigned long ulUserData;
      unsigned long ulDummy;
    
      //
      // Initialize the message
      //
      memcpy(g_ucTxBuff,MASTER_MSG,sizeof(MASTER_MSG));
    
      //
      // Set Tx buffer index
      //
      ucTxBuffNdx = 0;
      ucRxBuffNdx = 0;
    
      //
      // Reset SPI
      //
      MAP_SPIReset(GSPI_BASE);
    
      //
      // Configure SPI interface
      //
      MAP_SPIConfigSetExpClk(GSPI_BASE,MAP_PRCMPeripheralClockGet(PRCM_GSPI),
                         SPI_IF_BIT_RATE,SPI_MODE_MASTER,SPI_SUB_MODE_0,
                         (SPI_SW_CTRL_CS |
                         SPI_4PIN_MODE |
                         SPI_TURBO_OFF |
                         SPI_CS_ACTIVEHIGH |
                         SPI_WL_8));
    
      //
      // Enable SPI for communication
      //
      MAP_SPIEnable(GSPI_BASE);
    
      //
      // Print mode on uart
      //
      Message("Enabled SPI Interface in Master Mode\n\r");
    
      //
      // User input
      //
      Report("Press any key to transmit data....");
    
      //
      // Read a character from UART terminal
      //
      ulUserData = MAP_UARTCharGet(UARTA0_BASE);
    
    
      //
      // Send the string to slave. Chip Select(CS) needs to be
      // asserted at start of transfer and deasserted at the end.
      //
      MAP_SPITransfer(GSPI_BASE,g_ucTxBuff,g_ucRxBuff,50,
                SPI_CS_ENABLE|SPI_CS_DISABLE);
    
      //
      // Report to the user
      //
      Report("\n\rSend      %s",g_ucTxBuff);
      Report("Received  %s",g_ucRxBuff);
    
      //
      // Print a message
      //
      Report("\n\rType here (Press enter to exit) :");
    
      //
      // Initialize variable
      //
      ulUserData = 0;
    
      //
      // Enable Chip select
      //
      MAP_SPICSEnable(GSPI_BASE);
    
      //
      // Loop until user "Enter Key" is
      // pressed
      //
      while(ulUserData != '\r')
      {
        //
        // Read a character from UART terminal
        //
        ulUserData = MAP_UARTCharGet(UARTA0_BASE);
    
        //
        // Echo it back
        //
        MAP_UARTCharPut(UARTA0_BASE,ulUserData);
    
        //
        // Push the character over SPI
        //
        MAP_SPIDataPut(GSPI_BASE,ulUserData);
    
        //
        // Clean up the receive register into a dummy
        // variable
        //
        MAP_SPIDataGet(GSPI_BASE,&ulDummy);
      }
    
      //
      // Disable chip select
      //
      MAP_SPICSDisable(GSPI_BASE);
    }
    
    //*****************************************************************************
    //
    //! SPI Slave mode main loop
    //!
    //! This function configures SPI modelue as slave and enables the channel for
    //! communication
    //!
    //! \return None.
    //
    //*****************************************************************************
    void SlaveMain()
    {
      unsigned long ulNdx;
    
      //
      // Initialize the message
      //
      for(ulNdx=0; ulNdx < TR_BUFF_SIZE; ulNdx++)
      {
        g_ucTxBuff[ulNdx] = ulNdx;
      }
    
      //
      // Set Tx buffer index
      //
      ucTxBuffNdx = 0;
      ucRxBuffNdx = 0;
    
      //
      // Reset SPI
      //
      MAP_SPIReset(GSPI_BASE);
    
      //
      // Initialize UDMA
      //
      UDMAInit();
    
      //
      // Configure SPI interface
      //
      MAP_SPIConfigSetExpClk(GSPI_BASE,MAP_PRCMPeripheralClockGet(PRCM_GSPI),
                         SPI_IF_BIT_RATE,SPI_MODE_SLAVE,SPI_SUB_MODE_0,
                         (SPI_HW_CTRL_CS |
                         SPI_4PIN_MODE |
                         SPI_TURBO_OFF |
                         SPI_CS_ACTIVELOW |
                         SPI_WL_8));
    
      //
      // Register Interrupt Handler
      //
      MAP_SPIIntRegister(GSPI_BASE,SlaveIntHandler);
    
      SetupTransfer(UDMA_CH30_GSPI_RX,UDMA_MODE_BASIC,TR_BUFF_SIZE,
                    UDMA_SIZE_8,UDMA_ARB_1,
                    (void *)(GSPI_BASE + MCSPI_O_RX0),UDMA_SRC_INC_NONE,
                    &g_ucRxBuff,UDMA_DST_INC_8);
    
      SetupTransfer(UDMA_CH31_GSPI_TX,UDMA_MODE_BASIC,TR_BUFF_SIZE,
                    UDMA_SIZE_8,UDMA_ARB_1,
                    &g_ucTxBuff,UDMA_SRC_INC_8,(void *)(GSPI_BASE + MCSPI_O_TX0),
                    UDMA_DST_INC_NONE);
    
    #if 0
      SPIWordCountSet(GSPI_BASE,TR_BUFF_SIZE);
    
      SPIFIFOLevelSet(GSPI_BASE,1,1);
    
    
      SPIFIFOEnable(GSPI_BASE, SPI_RX_FIFO|SPI_TX_FIFO);
    #endif
    
      SPIDmaEnable(GSPI_BASE,SPI_RX_DMA|SPI_TX_DMA);
    
    
      //
      // Enable Interrupts
      //
      MAP_SPIIntEnable(GSPI_BASE,SPI_INT_DMATX|SPI_INT_DMARX);
    
      //
      // Enable SPI for communication
      //
      MAP_SPIEnable(GSPI_BASE);
    
      //
      // Print mode on uart
      //
      Message("Enabled SPI Interface in Slave Mode\n\rReceived : ");
    }
    
    //*****************************************************************************
    //
    //! Board Initialization & Configuration
    //!
    //! \param  None
    //!
    //! \return None
    //
    //*****************************************************************************
    static void
    BoardInit(void)
    {
    /* In case of TI-RTOS vector table is initialize by OS itself */
    #ifndef USE_TIRTOS
      //
      // Set vector table base
      //
    #if defined(ccs)
        MAP_IntVTableBaseSet((unsigned long)&g_pfnVectors[0]);
    #endif
    #if defined(ewarm)
        MAP_IntVTableBaseSet((unsigned long)&__vector_table);
    #endif
    #endif
      //
      // Enable Processor
      //
      MAP_IntMasterEnable();
      MAP_IntEnable(FAULT_SYSTICK);
    
      PRCMCC3200MCUInit();
    }
    
    //*****************************************************************************
    //
    //! Main function for spi demo application
    //!
    //! \param none
    //!
    //! \return None.
    //
    //*****************************************************************************
    void main()
    {
    
      //
      // Initialize Board configurations
      //
      BoardInit();
    
      //
      // Muxing UART and SPI lines.
      //
      PinMuxConfig();
    
      //
      // Enable the SPI module clock
      //
      MAP_PRCMPeripheralClkEnable(PRCM_GSPI,PRCM_RUN_MODE_CLK);
    
      //
      // Initialising the Terminal.
      //
      InitTerm();
    
      //
      // Clearing the Terminal.
      //
      ClearTerm();
    
      //
      // Display the Banner
      //
      Message("\n\n\n\r");
      Message("\t\t   ********************************************\n\r");
      Message("\t\t        CC3200 SPI Demo Application  \n\r");
      Message("\t\t   ********************************************\n\r");
      Message("\n\n\n\r");
    
      //
      // Reset the peripheral
      //
      MAP_PRCMPeripheralReset(PRCM_GSPI);
    
    #if MASTER_MODE
    
      MasterMain();
    
    #else
    
      SlaveMain();
    
    #endif
    
      while(1)
      {
    
      }
    
    }
    
    

    Hi Vinod,

               Pls find SlaveMain() inside attached main.c file. Its modified main.c from SDK example spi_demo to show using DMA with SPI Slave with or without FIFO.

              Pls tryout this sequence at your end and let me know if this solves your issues.

    Thanks and Regards,

    Praveen

  • Hi Praveen,

    I tried the file sent by you, but no data was received in Rxbuffer. I did the following changes to your file.

    static unsigned char g_ucTxBuff[TR_BUFF_SIZE + 1];  

    Report(".%s\n\r",g_ucRxBuff); it is placed inside interrupt handler to check whether data has been received.

    SetupTransfer(UDMA_CH31_GSPI_TX,UDMA_MODE_BASIC,TR_BUFF_SIZE + 1,
    UDMA_SIZE_8,UDMA_ARB_1,
    &g_ucTxBuff,UDMA_SRC_INC_8,(void *)(GSPI_BASE + MCSPI_O_TX0),  UDMA_DST_INC_NONE);

    /* We have to Pass only address, don't we? */

    Master is sending TR_BUFF_SIZE data to slave.

    I added +1 there to avoid infinite interrupts due to SPI-Tx-Reg Empty condition on final byte transfer of TR_BUFF_SIZE.

    have a small doubt like, We are using  SPIDmaEnable(GSPI_BASE,SPI_RX_DMA|SPI_TX_DMA); function call, which means SPI triggers the DMA controller based tx-buffer empty and rx-buffer full condition.

    Here we are not enabling any interrupts to CPU for tx-buffer empty and rx-buffer full conditions. in the SPI_IRQENABLE Register.

    Then also we are getting interrupt to CPU on Tx-buffer empty condition,( which actually trigger the DMA write line to fetch data from Memory to Tx-Reg, but DMA write channel was disabled before this condition ). Is there any mechanism implemented internally to enable SPI interrupts when DMA channel is disabled?

    Could you figure out why data is not received in the rx-buffer?

     

     

  • Vinod,

         

           Are you receiving any data at the Master side ? What pattern are you sending from master to slave ?

    Thanks and Regards,

    Praveen

  • Praveen,

    I am sending a string like "This is Master Macam-board sending to slave " and nothing was received at cc3200.

     

  • Hi Praveen,

    Thanks for your replies.

    DMA is working absolutely Fine.  it was just my mistake to update the Master side test Application which I changed (Assigned NULL to transmit buffer)  as a trial of avoiding infinite interrupts to CPU. 

    I added +1 to the item-Count field in the DMA Transmit-channel configuration. which avoided infinite interrupts, but thereafter I forgot assign tx-buffer in the Master side APllication (spidev_test.c).

    I enabled FIFO option on SPI, this is also working fine. I found one thing that if we use FIFOs there is no need of adding  +1 to  item-Count field in the DMA Transmit-channel configuration. which is mandatory for without FIFOs may I know the reason for this behaviour. (Here I used item-Count equal to the number of items sent by Master to slave)

    And I asked one question in the previous thread like 

     we are getting interrupt to CPU on Tx-buffer empty condition,( which actually trigger the DMA write line to fetch data from Memory to Tx-Reg, but DMA write channel was disabled before this condition ). Is there any mechanism implemented internally to enable SPI interrupts when DMA channel is disabled?


    Could you read my previous thread for details on the above question and clarify me.


    Once again Thanks a lot for all quick your replies

     

  • Vinod,

       When you are using DMA you also set the word count

      SPIWordCountSet(GSPI_BASE,TR_BUFF_SIZE);

       That tells SPI how many SPI words it need to transfer. Thus SPI generates only that much of DMA requests.

       But when not using FIFO, SPI is in continuous transfer mode ( no word count ), thus it keeps on generating DMA requests.

       Regarding your query on interrupts, as soon as you enable SPI channel it will start sendingTX-Empty request to DMA. Now since DMA channel is disabled it will just trigger a DMA done interrupt. If you read this interrupt status inside the handler using following API you should see 0x2000_0000

    ulStatus = MAP_SPIIntStatus(GSPI_BASE,true);

    Let me know if this is the behavior you are observing.

    Thanks and Regards,

    Praveen

  • Hi Praveen,

    I tried keeping a print in interrupt handler and I observed it value as 0x2000_9350.

    Now I used   SPIWordCountSet(GSPI_BASE,TR_BUFF_SIZE);  API just above 

    MAP_SPIIntEnable(GSPI_BASE,SPI_INT_DMATX|SPI_INT_DMARX); API.

    As you said there should be TR_BUFF_SIZE requests to be asserted by SPI to DMA, but infinite interrupts are coming as like in continuous mode (asserting DMA write channel as soon as Tx-Reg is empty, which occurs at the end of last transfer byte from Master)

    Here TR_BUFF_SIZE is equal to number of items sent by Master to Slave.

  • Hi !

    Im very impressed with the DMA and FIFO capabilities in the CC3200.

    I just got a 240x320 LCD display working with the CC3200 via the SPI library in Energia IDE.

    The display is good and affordable, but with the SPI library it simply is to slow.

    Is it possible to implement the DMA + FIFO into the Energia SPI lib. or create a new one with the DMA + FIFO ?

    The library should ideally grab data like the original SPI library in order to ease use with other library's being SPI dependent.    

     

    https://github.com/energia/Energia/tree/master/hardware/cc3200/libraries/SPI

     

    Here you see the difference between a display with and without DMA + FIFO: 

     http://dorkbotpdx.org/blog/paul/display_spi_optimization

     

    With a SPIFIFO Lib. in the Energia CC3200 folder, people would see what this chip i made of. The SPI library is working like an old AVR setup and do not do justice to the ARM M4.

    Unfortunately i am not able to code this. I just can´t get my head around it. Hopefully you´ll see the potential in this, and find a way. 

  • Hello,

    Did you find any solutions/workarounds for the DMA/SPI issue you mentioned?

    I am facing the same problem (posted on a new thread - http://e2e.ti.com/support/wireless_connectivity/f/968/p/381940/1347971.aspx) but I still can't get DMA and SPI to work.

    Keep getting continuous interrupts on INT_DMA_TX and only one element of my buffer gets transmitted.

    Regards,

    Pavlos

  • Hi, is there any progress with this?

    We are considering using CC3200 for our IoT platform but efficient SPI is absolutely necessary, so if the problems reported above are caused by a hardware bug it will mean we cannot use it.

    Let's hope that the problems so far are due to immature datasheet and/or driverlib.

    Any new information will be appreciated.

    Best,

    Giannis

  • Hello all,
    I referred to the file 3542.main.c.
    I am trying to implement DMA+FIFO for receiving 19 bytes from slave.

    Can you please tell me what "MCSPI_0_RX0" is ??
    It is giving me an error.

    Warm regards,
    Abhishek.
  • Hello all,
    I included the file "hw_mcspi.h" in my project.
    It has the defination for "MCSPI_0_RX0".
    Sorry for the above post.

    Warm regards,
    Abhishek.
  • Hi Praveen,
    The discuss about SPI are great. I'm just wondering where can I find some document about these function? I know it's ok to just follow the example codes here, but it's better to have more understanding.
    Best regards,
    John
  • hello ,Praveen .cc3200_dma_spi_example-master20160803.zip is not work. can u tell me ,where have demo of cc3200 spi use DMA? tks