spi.c

Go to the documentation of this file.

/*
 * spi.c
 *
 *  Created on: 31/10/2013
 *      Author: Fernando
 */

/*
 * Reference connections:
 * MSP430 in master mode
 *
 * (MSP430 pin number; pin name; config) <-> BUS name <-> (CC2480 pin number; pin name)
 *
 * (MSP430 26 P3.7: GPIO    )  -> RESET_N -> (CC2480 10 RESETn)
 *
 * (MSP430 15 P4.0: GPIO    )  -> CFG0    -> (CC2480 11 CFG0) - 1=32KHz crystal installed; 0=not
 * (MSP430 16 P4.1: GPIO    )  -> CFG1    -> (CC2480 12 CFG1) - 1=SPI; 0=UART
 *
 * (MSP430 03 P2.6: GPIO    ) <-  SRDY   <-  (CC2480 05 SRDY)
 * (MSP430 25 P3.6: GPIO    )  -> MRDY    -> (CC2480 06 MRDY)
 *
 * (MSP430 09 P3.0: UCB0STE )  -> SS/CT   -> (CC2480 15 SS/CT) - disabled in 3-pin SPI
 * UCxSTE chooses between master active/inactive
 *
 * (MSP430 10 P3.1: UCB0SIMO)  -> SI      -> (CC2480 14 SI/TX)
 * (MSP430 11 P3.2: UCB0SOMI) <-  SO     <-  (CC2480 13 SO/RX)
 * (MSP430 12 P3.3: UCB0CLK )  -> C/RT    -> (CC2480 16 C/RT)
 *
 * (MSP430 17 P4.2: GPIO    )  -> P_4.2   -> (CC2480 45 NC)
 * (MSP430 18 P4.3: GPIO    )  -> P_4.3   -> (CC2480 46 NC)
 *
 * From "swra175a.pdf":
 *
 * Frame format:
 *             ---------+------------------
 *       Bytes |   1    |    2    | 0-253 |
 *             +--------+---------+-------+
 * Information | Length | Command |  Data |
 *             ---------+------------------
 *
 *             -------------------+-------
 *        Byte |       Cmd0       | Cmd1 |
 *             -------+-----------+------+
 *        Bits | 7-5  |    4-0    | 7-0  |
 *             +------+-----------+------+
 * Information | Type | Subsystem |  ID  |
 *             -------+-------------------
 *
 * Type
 *  0: 0x00 POLL. Used to retrieve data, length, subsystem and id are set to 0;
 *  1: 0x20 SREQ. Synchronous request;
 *  2: 0x40 AREQ. Asynchronous request;
 *  3: 0x60 SRSP. Synchronous response;
 *  4-7: Reserved.
 *
 * Subsystem
 *  0: Reserved
 *  1: SYS interface
 *  2: Reserved
 *  3: Reserved
 *  4: AF interface
 *  5: ZDO interface
 *  6: Simple API interface
 *  7-32: Reserved
 *
 * ID
 *  Command ID, maps to a particular interface message. 0-255
 *
 * SS/CT will have the same signal as MRDY as if them were hardwired.
 *
 */

/*
 * ======== Standard MSP430 includes ========
 */
#include <msp430.h>

/*
 * ======== Includes ========
 */
#include "spi.h"
#include "cc2480ai.h"
#include "uart.h"
#include "im.h"

/*
 * ======== Constants ========
 */

/*
 * ======== Macros ========
 */

#define SPI_SRDYBIT BIT6 // On port 2

#define SPI_SETSRDYDETECTUP P2IES &= ~SPI_SRDYBIT

#define SPI_SETSRDYDETECTDOWN P2IES |= SPI_SRDYBIT

#define SPI_SSBIT 0x01 // bit 0 on port 3

#define SPI_MRDYBIT BIT6 // On port 3

#define SPI_CLRMRDY P3OUT &= ~(SPI_MRDYBIT | SPI_SSBIT)

#define SPI_SETMRDY P3OUT |= SPI_MRDYBIT | SPI_SSBIT

#define SPI_FRAMEHDRSIZE 3

/*
 * ======== Types ========
 */

typedef enum spi_state {
  SPI_INIT,
  SPI_IDLE,
  SPI_AREQ_START,
  SPI_AREQ_SENDING,
  SPI_AREQ_SENT,
  SPI_SREQ_START,
  SPI_SREQ_SENDING,
  SPI_SREQ_SENT,
  SPI_SREQ_RECEIVING_START,
  SPI_SREQ_RECEIVING,
  SPI_SREQ_RECEIVING_OVER,
  SPI_SREQ_RECEIVED,
  SPI_POLL_START,
  SPI_POLL_RECEIVING_START,
  SPI_POLL_RECEIVING,
  SPI_POLL_RECEIVING_OVER,
  SPI_POOL_RECEIVED
} spi_state;

/*
 * ======== Global Variables ========
 */

char spi_buf[SPI_BUFSIZE];

/*
 * ======== Local Variables ========
 */

spi_state spi_currentState;

char *spi_pBuf;

UInt16 spi_bytesLeft;

UInt8 spi_receiveOverFlow;

UInt8 spi_currentFreeBytes;

/*
 * @brief   Variable to detect freeze on SPI
 */
UInt8 spi_freezeDetect;

/*
 * ======== Local Functions ========
 */

void spi_snd();
void spi_setPollCmd();

/*
 * ================
 */

void spi_process_message() {
#if DEBUG==1
  uart_forwardCmd(spi_buf);
#endif
  ccai_process_message();
}

void spi_init() {
  spi_currentState = SPI_INIT;
  spi_bytesLeft = 0;
  spi_receiveOverFlow = 0;
  spi_currentFreeBytes = 0;

  // reset UCxRXIE, UCxTXIE, UCxRXIFG, UCOE, and UCFE and set UCxTXIFG
  UCB0CTL1 |= UCSWRST;
  // SRDY interrupt
  P2IE &= ~SPI_SRDYBIT;
  P2OUT |= SPI_SRDYBIT;
  P2DIR &= ~SPI_SRDYBIT;
  P2IFG &= ~SPI_SRDYBIT;
  P2IES |= SPI_SRDYBIT;
  P2IE |= SPI_SRDYBIT;
  P3DIR |= SPI_MRDYBIT | SPI_SSBIT;

  SPI_SETSRDYDETECTDOWN;
  SPI_SETMRDY;

  // release ICB0 for operation
  UCB0CTL1 &= ~UCSWRST;
  IE2 |= UCB0RXIE; // Must be done after releasing UCB0 for operation

  spi_currentState = SPI_IDLE;
  spi_freezeDetect = 2;

}

UInt16 spi_proccess() {
  // Sometimes the channel just "freezes" on SPI_SREQ_SENT the SRDY line
  // doesn't go up as it should. There is no way to wake-up the other device, so
  // it is reset:
  if (spi_currentState != SPI_IDLE) {
    spi_freezeDetect--;
    if (!spi_freezeDetect) {
      ccai_resetFull();
      spi_freezeDetect = 10;
    }
  }
  return 200;
}

UInt8 spi_reqBegin(UInt8 len, UInt8 cmd0, UInt8 cmd1) {
  // critical section: Disable Global IE
  im_disable_interrupt();
  if ((spi_currentState != SPI_IDLE)
      || (len > (SPI_BUFSIZE - SPI_FRAMEHDRSIZE))) {
    // Enable Global IE before exit
    im_enable_interrupt();
    return 0;
  }
  SPI_SETSRDYDETECTDOWN;
  spi_buf[0] = len;
  spi_buf[1] = cmd0;
  spi_buf[2] = cmd1;
  spi_pBuf = &spi_buf[3]; // prepare to write by spi_reqData below
  spi_currentFreeBytes = len;
  return 1;
}

UInt8 spi_reqData(UInt8 len, void *pBuf) {
  char *pcBuf;
  UInt8 result;

  pcBuf = pBuf;
  if (len > spi_currentFreeBytes) {
    result = 0;
    len = spi_currentFreeBytes;
  } else
    result = 1;
  spi_currentFreeBytes -= len;

  while (len) {
    len--;
    *spi_pBuf++ = *pcBuf++;
  }

  return result;
}

void spi_reqEnd(UInt8 forwardToSerial) {
  spi_pBuf = spi_buf;
  spi_bytesLeft = *spi_pBuf + SPI_FRAMEHDRSIZE; // size of payload + size of header
  // Avoid access violation
  if (spi_bytesLeft > SPI_BUFSIZE) {
    spi_bytesLeft = SPI_BUFSIZE;
  }
  // Get request type
  if ((spi_buf[1] & 0xE0) == 0x20) { // SREQ
    spi_currentState = SPI_SREQ_START;
  } else { // AREQ
    spi_currentState = SPI_AREQ_START;
  };
  // Enable Global IE
  im_enable_interrupt();
  SPI_CLRMRDY;
#if DEBUG==1
  uart_forwardCmd(spi_buf);
#else
  if (forwardToSerial)
  uart_forwardCmd(spi_buf);
#endif
}

UInt8 spi_busy() {
  return (spi_currentState != SPI_IDLE);
}

void spi_snd() {
  if (spi_bytesLeft) {
    spi_bytesLeft--;
    switch (spi_currentState) {
    case SPI_SREQ_RECEIVING:
    case SPI_SREQ_RECEIVING_OVER:
    case SPI_POLL_RECEIVING:
    case SPI_POLL_RECEIVING_OVER:
      UCB0TXBUF = 0; // If receiving, send only zeroes
      break;
    default:
      UCB0TXBUF = *spi_pBuf;
      break;
    }
  } else {
    // nothing to send
    switch (spi_currentState) {
    case SPI_AREQ_SENDING:
      spi_currentState = SPI_AREQ_SENT;
      break;
    case SPI_SREQ_SENDING:
      spi_currentState = SPI_SREQ_SENT;
      break;
    case SPI_SREQ_RECEIVING_START:
      spi_currentState = SPI_SREQ_RECEIVING;
      // got header, read amount of data (payload) to receive
      spi_bytesLeft = spi_buf[0];
      // Avoid access violation (header is already on the buffer)
      if (spi_bytesLeft > (SPI_BUFSIZE - SPI_FRAMEHDRSIZE)) {
        spi_receiveOverFlow = spi_bytesLeft
            - (SPI_BUFSIZE - SPI_FRAMEHDRSIZE);
        spi_bytesLeft = SPI_BUFSIZE - SPI_FRAMEHDRSIZE;
      }
      // continue normal receiving, *spi_pBuf is left at next byte to receive
      spi_snd();
      break;
    case SPI_SREQ_RECEIVING:
      if (spi_receiveOverFlow) {
        spi_bytesLeft = spi_receiveOverFlow;
        spi_receiveOverFlow = 0;
        spi_currentState = SPI_SREQ_RECEIVING_OVER;
        // use send to receive and discard data awaiting on CC2480
        spi_snd();
        break;
      }
    case SPI_SREQ_RECEIVING_OVER:
      spi_currentState = SPI_SREQ_RECEIVED;
      // set MRDY high to terminate communication
      SPI_SETMRDY;
      spi_process_message();
      spi_currentState = SPI_IDLE;
      spi_freezeDetect = 2;
      break;
    case SPI_POLL_START:
      // just wait for SRDY up
      break;
    case SPI_POLL_RECEIVING_START:
      // got header, read amount of data (payload) to receive
      spi_bytesLeft = spi_buf[0];
      // Avoid access violation (header is already on the buffer)
      if (spi_bytesLeft > (SPI_BUFSIZE - SPI_FRAMEHDRSIZE)) {
        spi_receiveOverFlow = spi_bytesLeft
            - (SPI_BUFSIZE - SPI_FRAMEHDRSIZE);
        spi_bytesLeft = SPI_BUFSIZE - SPI_FRAMEHDRSIZE;
      }
      // continue normal receiving, *spi_pBuf is left at next byte to receive
      spi_currentState = SPI_POLL_RECEIVING;
      spi_snd();
      break;
    case SPI_POLL_RECEIVING:
      if (spi_receiveOverFlow) {
        spi_bytesLeft = spi_receiveOverFlow;
        spi_receiveOverFlow = 0;
        spi_currentState = SPI_POLL_RECEIVING_OVER;
        // use send to receive and discard data awaiting on CC2480
        spi_snd();
        break;
      }
    case SPI_POLL_RECEIVING_OVER:
      spi_currentState = SPI_POOL_RECEIVED;
      // set MRDY high to terminate communication
      SPI_SETMRDY;
      spi_process_message();
      spi_currentState = SPI_IDLE;
      spi_freezeDetect = 2;
      break;
    default:
      break;
    }
  }
}

void spi_setPollCmd() {
  spi_buf[0] = 0;
  spi_buf[1] = 0;
  spi_buf[2] = 0;
  spi_pBuf = spi_buf; // reset buffer position to send poll command and receive data
  spi_bytesLeft = SPI_FRAMEHDRSIZE; // bytes to send
}

void SPI_SRDYISR() {
  P2IFG &= ~SPI_SRDYBIT; // clear IFG
  switch (spi_currentState) {
  case SPI_IDLE:
    // Poll command
    spi_currentState = SPI_POLL_START;
    SPI_SETSRDYDETECTUP;
    // Set poll command to initiate communication
    spi_setPollCmd();
    SPI_CLRMRDY;
    spi_snd();
    break;
  case SPI_AREQ_START:
    spi_currentState = SPI_AREQ_SENDING;
    SPI_SETSRDYDETECTUP;
    spi_snd();
    break;
  case SPI_AREQ_SENDING: // Normally this would not occur, act as SPI_AREQ_SENT
  case SPI_AREQ_SENT:
    SPI_SETSRDYDETECTDOWN;
    SPI_SETMRDY;
    spi_currentState = SPI_IDLE;
    spi_freezeDetect = 2;
    break;
  case SPI_SREQ_START:
    spi_currentState = SPI_SREQ_SENDING;
    SPI_SETSRDYDETECTUP;
    spi_snd();
    break;
  case SPI_SREQ_SENDING: // Normally this would not occur, act as SPI_SREQ_SENT
  case SPI_SREQ_SENT:
    spi_currentState = SPI_SREQ_RECEIVING_START;
    SPI_SETSRDYDETECTDOWN;
    // send poll command to start receiving data
    spi_setPollCmd();
    spi_snd();
    break;
  case SPI_POLL_START:
    spi_currentState = SPI_POLL_RECEIVING_START;
    SPI_SETSRDYDETECTDOWN;
    // send poll command to start receiving data
    spi_setPollCmd();
    spi_snd();
    break;
  default:
    break;
  }
}

void SPI_USCIB0RX_ISR() {
  char v;

  v = UCB0RXBUF;
  switch (spi_currentState) {
  case SPI_AREQ_SENDING:
  case SPI_SREQ_SENDING:
    *spi_pBuf++; // just advance pointer
    break;
  case SPI_SREQ_RECEIVING_START:
  case SPI_SREQ_RECEIVING:
  case SPI_POLL_START:
  case SPI_POLL_RECEIVING_START:
  case SPI_POLL_RECEIVING:
    *spi_pBuf = v; // Read byte to buffer
    *spi_pBuf++; // advance pointer
    break;
  default:
    // invalid state to receive data, but there is data being received, it is discarded.
    break;
  }
  spi_snd();
}