spi.c

Go to the documentation of this file.

/*
 * @brief SPI example
 *
 * @note
 * Copyright(C) NXP Semiconductors, 2012
 * All rights reserved.
 *
 * @par
 * Software that is described herein is for illustrative purposes only
 * which provides customers with programming information regarding the
 * LPC products.  This software is supplied "AS IS" without any warranties of
 * any kind, and NXP Semiconductors and its licensor disclaim any and
 * all warranties, express or implied, including all implied warranties of
 * merchantability, fitness for a particular purpose and non-infringement of
 * intellectual property rights.  NXP Semiconductors assumes no responsibility
 * or liability for the use of the software, conveys no license or rights under any
 * patent, copyright, mask work right, or any other intellectual property rights in
 * or to any products. NXP Semiconductors reserves the right to make changes
 * in the software without notification. NXP Semiconductors also makes no
 * representation or warranty that such application will be suitable for the
 * specified use without further testing or modification.
 *
 * @par
 * Permission to use, copy, modify, and distribute this software and its
 * documentation is hereby granted, under NXP Semiconductors' and its
 * licensor's relevant copyrights in the software, without fee, provided that it
 * is used in conjunction with NXP Semiconductors microcontrollers.  This
 * copyright, permission, and disclaimer notice must appear in all copies of
 * this code.
 */

#include "board.h"

/*****************************************************************************
 * Private types/enumerations/variables
 ****************************************************************************/

#define RW_TEST             1
#define LOOPBACK_TEST       1
#define BUFFER_SIZE         10
#define SPI_MODE_TEST       (SPI_MODE_MASTER)
//#define SPI_MODE_TEST  (SPI_MODE_SLAVE)
#define POLLING_MODE        1
#if POLLING_MODE
#define INTERRUPT_MODE      0
#else
#define INTERRUPT_MODE      1
#endif

#define LPC_SPI           LPC_SPI1
#define SPI_IRQ           SPI1_IRQn
#define SPIIRQHANDLER     SPI1_IRQHandler

/* Tx buffer */
static uint16_t TxBuf[BUFFER_SIZE];

/* Rx buffer */
static uint16_t RxBuf[BUFFER_SIZE];

static SPI_CONFIG_T ConfigStruct;
static SPI_DELAY_CONFIG_T DelayConfigStruct;

static CHIP_SPI_DATA_SETUP_T XfSetup;
static volatile uint8_t  isXferCompleted = 0;

/*****************************************************************************
 * Public types/enumerations/variables
 ****************************************************************************/

/*****************************************************************************
 * Private functions
 ****************************************************************************/

/* Initialize buffer */
static void bufferInit(void)
{
 uint16_t i;
 uint16_t ch = 0;

 for (i = 0; i < BUFFER_SIZE; i++) {
  TxBuf[i] = ch++;
  RxBuf[i] = 0xAA;
 }
}

#if (RW_TEST || LOOPBACK_TEST)
/* Verify buffer after transfer */
static uint8_t bufferVerify(void)
{
 uint16_t i;
 uint16_t *src_addr = (uint16_t *) &TxBuf[0];
 uint16_t *dest_addr = (uint16_t *) &RxBuf[0];

 for ( i = 0; i < BUFFER_SIZE; i++ ) {

  if (*src_addr != *dest_addr) {
   return 1;
  }
  src_addr++;
  dest_addr++;
 }
 return 0;
}

#endif

/*****************************************************************************
 * Public functions
 ****************************************************************************/

#if INTERRUPT_MODE

void SPIIRQHANDLER(void)
{
 Chip_SPI_Int_Cmd(LPC_SPI, SPI_INTENCLR_TXDYEN | SPI_INTENCLR_RXDYEN
      | SPI_INTENCLR_RXOVEN | SPI_INTENCLR_TXUREN, DISABLE);      /* Disable all interrupt */
 if (((XfSetup.pRx) && (XfSetup.RxCnt < XfSetup.Length))
  || ((XfSetup.pTx) && (XfSetup.TxCnt < XfSetup.Length))) {
  Chip_SPI_Int_RWFrames(LPC_SPI, &XfSetup);
  Chip_SPI_Int_Cmd(LPC_SPI, SPI_INTENSET_TXDYEN | SPI_INTENSET_RXDYEN
       | SPI_INTENSET_RXOVEN | SPI_INTENSET_TXUREN, ENABLE);
 }
 else {
  isXferCompleted = 1;
 }
}

#endif /*INTERRUPT_MODE*/

int main(void)
{
 Board_Init();

 /* SPI initialization */
 Board_SPI_Init(LPC_SPI);

 ConfigStruct.Mode = SPI_MODE_TEST;
 ConfigStruct.ClkDiv = Chip_SPI_CalClkRateDivider(LPC_SPI, 100000);
 ConfigStruct.ClockMode = SPI_CLOCK_CPHA0_CPOL0;
 ConfigStruct.DataOrder = SPI_DATA_MSB_FIRST;
 ConfigStruct.SSELPol = SPI_SSEL_ACTIVE_LO;
 Chip_SPI_Init(LPC_SPI, &ConfigStruct);

 DelayConfigStruct.FrameDelay = 0;
 DelayConfigStruct.PostDelay = 0;
 DelayConfigStruct.PreDelay = 0;
 DelayConfigStruct.TransferDelay = 0;
 Chip_SPI_DelayConfig(LPC_SPI, &DelayConfigStruct);

#if INTERRUPT_MODE
 /* Setting SPI interrupt */
 NVIC_EnableIRQ(SPI_IRQ);
#endif
 Chip_SPI_Enable(LPC_SPI);

#if LOOPBACK_TEST
 Chip_SPI_EnableLoopBack(LPC_SPI);
#endif
 bufferInit();
 XfSetup.Length = BUFFER_SIZE;
 XfSetup.pTx = TxBuf;
 XfSetup.RxCnt = XfSetup.TxCnt = 0;
 XfSetup.DataSize = 8;

#if (RW_TEST || LOOPBACK_TEST)
 XfSetup.pRx = RxBuf;
#else
 XfSetup.pRx = NULL;
#endif

#if POLLING_MODE
#if (RW_TEST || LOOPBACK_TEST)
 Chip_SPI_RWFrames_Blocking(LPC_SPI, &XfSetup);
#else
 Chip_SPI_WriteFrames_Blocking(LPC_SPI, &XfSetup);
#endif

#elif INTERRUPT_MODE
 Chip_SPI_Int_RWFrames(LPC_SPI, &XfSetup);
 Chip_SPI_Int_Cmd(LPC_SPI, SPI_INTENSET_TXDYEN | SPI_INTENSET_RXDYEN
      | SPI_INTENSET_RXOVEN | SPI_INTENSET_TXUREN, ENABLE);
 while (!isXferCompleted) {}
 while (!(Chip_SPI_GetStatus(LPC_SPI) & SPI_STAT_SSD)) {}/* Make sure the last frame sent completely */
#endif /*INTERRUPT_MODE*/

#if (RW_TEST || LOOPBACK_TEST)
 if (bufferVerify()) {
  Board_LED_Set(0, true);
 }
 else
#endif  /*(RW_TEST || LOOPBACK_TEST)*/
 {
  Board_LED_Set(1, true);
 }

#if LOOPBACK_TEST
 Chip_SPI_DisableLoopBack(LPC_SPI);
#endif
 /* DeInitialize SPI peripheral */
 Chip_SPI_DeInit(LPC_SPI);

 while(1) {}
 return 0;
}