uart.c

Go to the documentation of this file.

/*
 * uart.c
 *
 *  Created on: 14/10/2013
 *      Author: Fernando
 */

/*
 * ======== Includes ========
 */

#include "uart.h"
#include "msp430f2274.h"
#include "spi.h"
#include "nwk.h"
#include "cc2480ai.h"
#include "ptp_types.h"
#include "ptp.h"
#include "im.h"

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

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

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

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

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

char uart_rxBuf[UART_RX_BUF_SIZE];

char uart_txBuf[UART_TX_BUF_SIZE];

UInt8 uart_rxBufRead;

UInt8 uart_rxBufWrite;

UInt8 uart_txBufRead;

UInt8 uart_txBufWrite;

char uart_currentFCS;

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

void uart_proccessCmd();
UInt8 uart_txBufFreeReal();

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

void uart_init() {
  uart_rxBufRead = 0;
  uart_rxBufWrite = 0;
  uart_txBufRead = 0;
  uart_txBufWrite = 0;
  uart_currentFCS = 0;
}

UInt16 uart_proccess() {
  uart_proccessCmd();
  return 500;
}

UInt8 uart_startFrame(UInt8 len, UInt8 cmd0, UInt8 cmd1) {
  char frameHeader[3];
  if (len > uart_txBufFree()) {
    return 0;
  }
  im_disable_interrupt();
  frameHeader[0] = len;
  frameHeader[1] = cmd0;
  frameHeader[2] = cmd1;
  uart_snd(1, "\xFE"); // SOF = 0xFE = 254
  uart_currentFCS = 0;
  uart_snd(3, frameHeader);
  return 1;
}

void uart_endFrame() {
  uart_snd(1, &uart_currentFCS);
  im_enable_interrupt();
}

UInt8 uart_snd(UInt8 len, void *pBuf) {
  UInt8 i;
  char *pcBuf;

  // check if there is enough room to the requested size;
  if ((len) > uart_txBufFreeReal()) {
    IE2 |= UCA0TXIE; // activate TX interrupt, this must trigger ISR if TX is not busy.
    return 0;
  }
  pcBuf = pBuf;
  for (i = len; i != 0; i--) {
    uart_txBuf[uart_txBufWrite] = *pcBuf;
    uart_txBufWrite++;
    if (uart_txBufWrite == UART_TX_BUF_SIZE) {
      uart_txBufWrite = 0;
    }
    uart_currentFCS ^= *pcBuf++;
  }
  IE2 |= UCA0TXIE; // activate TX interrupt, this must trigger ISR if TX is not busy.
  return 1;
}

// *
// * @brief       This function receive up to size characters from the uart_rxBuf.
// *
// * @param[in] size Amount of data to read from the uart_rxBuf.
// * @param[out]  Pointer to the buffer where the data will be written.
// *
// * @return      Amount of bytes received
// *
// */
//UInt8 uart_rcv(UInt8 size, void *pBuf) {
//  UInt8 i = 0;
//  char *pcBuf;
//
//  pcBuf = pBuf;
//  while (size && (uart_rxBufRead != uart_rxBufWrite)) {
//    *pcBuf++ = uart_rxBuf[uart_rxBufRead];
//    uart_rxBufRead++;
//    if (uart_rxBufRead == UART_RX_BUF_SIZE) {
//      uart_rxBufRead = 0;
//    }
//    i++;
//    size--;
//  }
//  return i;
//}

void USCIA0RX_ISR() {
  // Device enters ISR when character received in RX Buffer
  if ((uart_rxBufRead != uart_rxBufWrite + 1)
      && !((uart_rxBufWrite == (UART_RX_BUF_SIZE - 1))
          && (uart_rxBufRead == 0))) {
    uart_rxBuf[uart_rxBufWrite] = UCA0RXBUF;
    uart_rxBufWrite++;
    if (uart_rxBufWrite == UART_RX_BUF_SIZE) {
      uart_rxBufWrite = 0;
    }
  } else {
    UCA0RXBUF; // Buffer is full, discard it - Must be done to clear IFG
  }
}

void USCIA0TX_ISR() {
  uart_sndnextchar();
}

void uart_sndnextchar() {
  if (uart_txBufRead != uart_txBufWrite) {
    if (IFG2 & UCA0TXIFG) { // if TX not busy
      UCA0TXBUF = uart_txBuf[uart_txBufRead];
      uart_txBufRead++;
      if (uart_txBufRead == UART_TX_BUF_SIZE) {
        uart_txBufRead = 0;
      }
    }
  } else if (uart_txBufRead == uart_txBufWrite) {
    IE2 &= ~UCA0TXIE;
  }
}

UInt8 uart_txBufFree() {
  UInt8 free;

  free = uart_txBufFreeReal();
  if (free < 7)
    free = 0;
  else
    free -= 6;
  return free;
}

UInt8 uart_txBufFreeReal() {
  if (uart_txBufWrite == uart_txBufRead) {
    return UART_TX_BUF_SIZE - 1;
  } else if (uart_txBufWrite < uart_txBufRead) {
    return uart_txBufRead - (uart_txBufWrite + 1);
  } else {
    return (UART_TX_BUF_SIZE + uart_txBufRead) - (uart_txBufWrite + 1);
  }
}

UInt8 uart_sndInt64(int64_t *p) {
  return uart_snd(8, p);
}

UInt8 uart_sndUInt64(uint64_t *p) {
  return uart_snd(8, p);
}

UInt8 uart_sndUInt48(uint64_t *p) {
  return uart_snd(6, p);
}

UInt8 uart_sndUInt32(UInt32 *p) {
  return uart_snd(4, p);
}

UInt8 uart_sndUInt16(UInt16 v) {
  return uart_snd(2, &v);
}

UInt8 uart_sndUInt8(UInt8 v) {
  return uart_snd(1, &v);
}

void uart_proccessCmd() {
  UInt8 i;
  UInt8 len;
  UInt8 fcs;
  UInt16 cmd;
  PTP_TimeStamp time;
  UInt32 newTickSize;
  int64_t timeAdjust;
  char *dumpPos;
  UInt8 dumpLen;

  // search SOF, using packet format of swra175a.pdf - 5.2.2 Frame Format
  while ((uart_rxBufRead != uart_rxBufWrite)
      && (uart_rxBuf[uart_rxBufRead] != 254)) {
    uart_rxBufRead++;
    if (uart_rxBufRead == UART_RX_BUF_SIZE)
      uart_rxBufRead = 0;
  }
  // Check empty buffer
  if (uart_rxBufRead == uart_rxBufWrite)
    return;
  // char 254 found check length of the buffer
  i = uart_rxBufRead + 1;
  if (i == UART_RX_BUF_SIZE)
    i = 0;
  if (i == uart_rxBufWrite) // No data received
    return;
  len = uart_rxBuf[i];
  if (len >= (UART_RX_BUF_SIZE - 6)) { // Packet invalid or larger than buffer, can't be read
    uart_rxBufRead = i; // discard it, next call will search next SOF
    return;
  }
  // check for complete packet
  if (uart_rxBufWrite < uart_rxBufRead) {
    if ((len + 5) > (UART_RX_BUF_SIZE - uart_rxBufRead + uart_rxBufWrite))
      return;
  } else {
    if ((len + 5) > (uart_rxBufWrite - uart_rxBufRead))
      return;
  }
  // Frame-check sequence.
  fcs = uart_rxBuf[i]; // len
  i++;
  if (i == UART_RX_BUF_SIZE)
    i = 0;
  fcs ^= uart_rxBuf[i]; // cmd0
  i++;
  if (i == UART_RX_BUF_SIZE)
    i = 0;
  fcs ^= uart_rxBuf[i]; // cmd1
  i++;
  if (i == UART_RX_BUF_SIZE)
    i = 0;
  while (len) { // data
    len--;
    fcs ^= uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
  }
  if (fcs != uart_rxBuf[i]) {
    uart_rxBufRead++; // Invalid packet. Discard it, next call will search next SOF
    if (uart_rxBufRead == UART_RX_BUF_SIZE)
      uart_rxBufRead = 0;
    return;
  }
  // The packet is complete and FCS is valid
  uart_rxBufRead++; //pointer position from SOF to len
  if (uart_rxBufRead == UART_RX_BUF_SIZE)
    uart_rxBufRead = 0;
  // Now, if packet is invalid, just exit with return and next call will search for next SOF
  i = uart_rxBufRead;
  len = uart_rxBuf[i];
  i++;
  if (i == UART_RX_BUF_SIZE)
    i = 0;
  cmd = uart_rxBuf[i];
  i++;
  if (i == UART_RX_BUF_SIZE)
    i = 0;
  cmd <<= 8;
  cmd |= uart_rxBuf[i];
  i++;
  if (i == UART_RX_BUF_SIZE)
    i = 0;
  switch (cmd) {
  case 0xE110: // select device type
    if (len != 1) {
      // invalid length
      return;// Discard it, next call will search next SOF
    }
    switch (uart_rxBuf[i]) {
    case 0:
      nwk_setDeviceType(NWK_DEVTYPE_COORDINATOR);
      break;
    case 1:
      nwk_setDeviceType(NWK_DEVTYPE_ROUTER);
      break;
    case 2:
      nwk_setDeviceType(NWK_DEVTYPE_ENDDEVICE);
      break;
    default:
      // invalid value
      return; // Discard it, next call will search next SOF
    }
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    break;
  case 0xE111: // Select data sink on/off (bind)
    if (len != 1) {
      // invalid length
      return;// Discard it, next call will search next SOF
    }
    nwk_setSink(uart_rxBuf[i]);
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    break;
  case 0xE120: // Set clock time
    if (len != 10) {
      // invalid length
      return;// Discard it, next call will search next SOF
    }
    ((char *) &(time.secondsField.secondsLow))[0] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(time.secondsField.secondsLow))[1] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(time.secondsField.secondsLow))[2] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(time.secondsField.secondsLow))[3] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(time.secondsField.secondsHigh))[0] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(time.secondsField.secondsHigh))[1] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(time.nanoSecondsField))[0] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(time.nanoSecondsField))[1] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(time.nanoSecondsField))[2] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(time.nanoSecondsField))[3] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ptp_setNetTime(&time, 13, PTP_CA_010S, PTP_TS_OTHER);

    break;
  case 0xE121: // Adjust clock tick
    if (len != 4) {
      // invalid length
      return;// Discard it, next call will search next SOF
    }
    ((char *) &(newTickSize))[0] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(newTickSize))[1] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(newTickSize))[2] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(newTickSize))[3] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ptp_setTickTime(&newTickSize);
    break;
  case 0xE122: // Adjust clock time
    if (len != 8) {
      // invalid length
      return;// Discard it, next call will search next SOF
    }
    ((char *) &(timeAdjust))[0] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(timeAdjust))[1] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(timeAdjust))[2] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(timeAdjust))[3] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(timeAdjust))[4] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(timeAdjust))[5] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(timeAdjust))[6] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ((char *) &(timeAdjust))[7] = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    ptp_adjNetTime(&timeAdjust);
    break;
  case 0xE1FD: // Memory data dump to serial
    /*
     * Packet Received:
     *         ----------+--------
     * Bytes  |     2    |    1   |
     *        +----------+--------+
     * Desc   | position | Length |
     *         ----------+--------
     * Offset |     0    |    2   | - not counting header
     *
     * Packet to send:
     *         -----------------+------
     * Bytes  |         1       | 0-64 |
     *        +-----------------+------+
     * Desc   | Status & Length | Data |
     *         -----------------+------
     * Offset |         0       |   1  |
     *
     * Status is first 2 bits and Length is last 6 bits
     *
     */
    dumpPos = (char *) (uart_rxBuf[i] | (uart_rxBuf[i + 1u] << 8));
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    dumpLen = uart_rxBuf[i];
    i++;
    if (i == UART_RX_BUF_SIZE)
      i = 0;
    if (dumpLen > 63)
      dumpLen = 63;

    if (uart_startFrame(dumpLen + 1, 0xE1, 0x03)) {
      // status is 0, no need to insert it as there is a 00 already
      uart_sndUInt8(dumpLen);
      uart_snd(dumpLen, dumpPos);
      uart_endFrame();
    } else {
      dumpLen = uart_txBufFree();
      if (dumpLen) {
        if (uart_startFrame(dumpLen, 0xE1, 0x03)) {
          // status is 1, incomplete dump due to no space on buffer
          uart_sndUInt8((dumpLen - 1u) | (0x01 << 6));
          uart_snd(dumpLen - 1, dumpPos);
          uart_endFrame();
        }
      }
    }

  case 0xE1FE: // Reset CC2480
    if (len != 0) {
      // invalid length
      return;// Discard it, next call will search next SOF
    }
    nwk_init();
    spi_init();
    ccai_resetFull();
    break;
  case 0xE1FF: // reset the MSP430
    if (len != 0) {
      // invalid length
      return;// Discard it, next call will search next SOF
    }
    // Reset by writing an invalid value to watch dog control
    WDTCTL = 0;
    break;
  default:
    // unknown command
    return; // Discard it, next call will search next SOF
  }
  // Command processed, 'i' is pointing FCS, point to byte after packet.
  i++;
  if (i == UART_RX_BUF_SIZE)
    i = 0;
  // set read pointer
  uart_rxBufRead = i;
}

UInt8 uart_forwardCmd(char *pBuf) {
  // Forward report to UART
  if (uart_startFrame(pBuf[0], pBuf[1], pBuf[2])) {
    uart_snd(pBuf[0], &pBuf[3]);
    uart_endFrame();
    return 1;
  }
  return 0;
}