ptp.c

Go to the documentation of this file.

/*
 * ptp.c
 *
 *  Date: 19/06/2014
 *  Author: Fernando Biazi Nascimento
 *  Copyright © 2014 Fernando Biazi Nascimento. All rights reserved.
 *
 *  License of use and copy on file license.txt
 *
 */

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

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

#include "ptp.h"
#include "ptp_util.h"
#include "ptp_messages.h"
#include "clock.h"
#include "uart.h"

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

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

#define PTP_FLAGRUNNING   0x01

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

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

ptp_clock ptpClock;
ptp_uinteger64 ptp_meanPathDelay[PTP_NUMBERPORTS];
PTP_foreignMasterDS ptp_foreignMaster[PTP_NUMBERPORTS][1];
ptp_integer64 ptp_lastAdjust;
ptp_uinteger64 ptp_meanDelayAtLastAdjust;
PTP_TimeStamp ptp_lastAdjustTime;

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

ptp_uinteger8 ptp_flags;
ptp_uinteger8 ptp_tsTimeout;

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


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

void ptp_init() {
  ptp_uinteger8 portIndex;

  // ensure that ptp_process won't run before initialization end.
  ptp_flags &= !PTP_FLAGRUNNING;
  ptpClock.portDS[0].portState = PTP_PS_INITIALIZING;

  ptp_lastAdjust = 0;
  ptp_meanDelayAtLastAdjust = 0;
  ptp_lastAdjustTime.secondsField.secondsLow = 0;
  ptp_lastAdjustTime.secondsField.secondsHigh = 0;
  ptp_lastAdjustTime.nanoSecondsField = 0;

  ptp_tsTimeout = 255;

  ptpClock.defaultDS.numberPorts = 1;
  portIndex = PTP_NUMBERPORTS;
  while (portIndex) {
    portIndex--;
    ptp_meanPathDelay[portIndex] = 0;
  }
  ptp_clock_initialize();
}

void ptp_initEnd() {
  ptpClock.defaultDS.clockIdentity = ptp_getClockIdentity();
  ptpClock.parentDS.parentPortIdentity.clockIdentity =
      ptpClock.defaultDS.clockIdentity; // 8.2.3.2
  ptpClock.parentDS.grandMasterIdentity = ptpClock.defaultDS.clockIdentity; // 8.2.3.6
  ptp_portsSetListening();
}

UInt16 ptp_process() {
  static ptp_uinteger16 runCounter = 0;
  static ptp_uinteger8 portNumber = 0;
  ptp_uinteger8 portIndex;
  clock_timeStamp ts;

  if ((ptpClock.defaultDS.clockQuality.clockClass == 13)
      || (ptpClock.defaultDS.clockQuality.clockClass == 14))
    if ((runCounter & ((1 << PTP_LOG2TSVERIFY) - 1)) == 0)
      // if External time source, verify timeout
      // verify timeout
      if (ptp_tsTimeout == 0) {
        // Set time source to internal oscillator
        ptpClock.timePropertiesDS.timeSource =
            PTP_TS_INTERNAL_OSCILLATOR;
      } else {
        // send time stamp message to source
        if (uart_startFrame(14, 0xE1, 0x04)) {
          clock_getTime(&ts);
          uart_sndUInt32(&(ts.seconds.secondsLow));
          uart_sndUInt16(ts.seconds.secondsHigh);
          uart_sndUInt32(&(ts.nanoSeconds));
          uart_sndUInt32(&(clock_tickSize));
          uart_endFrame();
        } else {
          // decrease timeout
          ptp_tsTimeout--;
        }
      }

  // Check if protocol is running
  if (!(ptp_flags & PTP_FLAGRUNNING)) {
    // STATE_DECISION_EVENT only occur if no port is in the PTP_PS_INITIALIZING state
    // no processing is made until no port is in this state.
    portIndex = ptpClock.defaultDS.numberPorts;
    while (portIndex) {
      portIndex--;
      if (ptpClock.portDS[portIndex].portState == PTP_PS_INITIALIZING){
        runCounter++;
        return 1000;}
    }
    ptp_flags |= PTP_FLAGRUNNING;
  }

  // verify need to send messages
  // timeouts are represented in log value, 0x0 means 2^0 = 1, 0x1 represents 2^1 = 2 and so on.
  // This intervals must agree with configurations
  // better prevent simultaneous execution of more than one code that sends messages, specially timed messages.
  switch (runCounter & ((1 << PTP_LOG2ANNOUNCESYNCPDELEREQ) - 1)) {
  case 1:
    // run the STATE_DECISION_EVENT
    // At least once per announce message transmission interval - 9.2.6.8
    ptp_state_decision_event();
    if (!ptp_MsgAnnounceSnd())
      return 2;
    break;
  case 2:
    // send PdelayReq to all known neighbors.
    // 9.5.13.1, 8.2.5.4.4, 9.5.13.2
    if (portNumber) {
      portIndex = portNumber - 1;
      if ((nwk_getNeighborAddress(portNumber) != 0xFFFF)
          && (ptpClock.portDS[portIndex].delayMechanism == PTP_DM_P2P)) {
        if (ptp_MsgPdelayReqSnd(portNumber))
          portNumber = portIndex;
      } else {
        portNumber = portIndex;
      }
    }
    if (portNumber)
      return 50; // this time should be enough to free the cache from previous port message
    else {
      portNumber = ptpClock.defaultDS.numberPorts;
      runCounter++;
      if (ptpClock.defaultDS.numberPorts == 1) {
        return 1000 - 50;
      } else {
        return 1000 - (50 * PTP_NUMBERPORTS);
      }
    }
  default:
    break;
  }

  runCounter++;
  return 1000;
}

UInt16 ptp_processPDelayReq() {
  ptp_MsgPdelayReqCheck();
  return 1;
}

void ptp_rcvmessage(ptp_octet *pBuf, ptp_uinteger8 portNumber,
    ptp_uinteger16 size) {
  // processing semantics: 9.5
  // formats: 13
  PTP_TimeStamp ts;

  // time stamp for event messages
  ptp_getCurrentTime(&ts);

  // check version
  if ((pBuf[1] & 0x0F) != 2)
    return;

  // check informed size
  if (size != ptp_rcvUInt16(&(pBuf[2]))) {
    return;
  }

  // check for message from self. 9.5.2
  if (ptp_clockIdentityCompare((&pBuf[20]),
      *(ptpClock.defaultDS.clockIdentity)) == 0)
    return;

  // message type
  switch (pBuf[0] & 0x0F) {
  case PTP_MSGTYPE_SYNC: // Event

    break;
  case PTP_MSGTYPE_DELAY_REQ: // Event

    break;
  case PTP_MSGTYPE_PDELAY_REQ: // Event
    ptp_MsgPdelayReqRcv(pBuf, &ts, portNumber);
    break;
  case PTP_MSGTYPE_PDELAY_RESP: // Event
    ptp_MsgPdelayRespRcv(pBuf, &ts, portNumber);
    break;
  case PTP_MSGTYPE_FOLLOW_UP: // General

    break;
  case PTP_MSGTYPE_DELAY_RESP: // General

    break;
  case PTP_MSGTYPE_PDELAY_RESP_FOLLOW_UP: // General

    break;
  case PTP_MSGTYPE_ANNOUNCE: // General
    ptp_MsgAnnounceRcv(pBuf, portNumber);
    break;
  case PTP_MSGTYPE_SIGNALING: // General

    break;
  case PTP_MSGTYPE_MANAGEMENT: // General

    break;
  default:
    break;
  }
}

void ptp_setNetTime(PTP_TimeStamp *time, ptp_uinteger8 clockClass,
    ptp_clockAccuracy clockAccuracy, ptp_timeSource timeSource) {
  clock_setTime((void *) time);
  ptpClock.defaultDS.clockQuality.clockClass = clockClass;
  ptpClock.defaultDS.clockQuality.clockAccuracy = clockAccuracy;
  ptpClock.timePropertiesDS.timeSource = timeSource;
  ptp_tsTimeout = PTP_TSTIMEOUT;
  if (ptp_flags & PTP_FLAGRUNNING) {
    ptp_state_decision_event();
  }
}


void ptp_setTickTime(ptp_uinteger32 *newTickSize) {
  if (*newTickSize)
    clock_tickSize = *newTickSize;
}


void ptp_adjNetTime(ptp_integer64 *timeAdjust) {
  ptp_boolean flags = 0;

  clock_adjTime(timeAdjust);
  if (*timeAdjust < 0) {
    *timeAdjust = -*timeAdjust;
    flags |= 1;
  }
  if (*timeAdjust < 1000000)
    ptpClock.defaultDS.clockQuality.clockAccuracy = PTP_CA_001MS;
  else if (*timeAdjust < 10000000)
    ptpClock.defaultDS.clockQuality.clockAccuracy = PTP_CA_010MS;
  else if (*timeAdjust < 100000000)
    ptpClock.defaultDS.clockQuality.clockAccuracy = PTP_CA_100MS;
  else if (*timeAdjust < 1000000000)
    ptpClock.defaultDS.clockQuality.clockAccuracy = PTP_CA_001US;
  else if (*timeAdjust < 10000000000)
    ptpClock.defaultDS.clockQuality.clockAccuracy = PTP_CA_010S;

  if (flags & 1) {
    *timeAdjust = -*timeAdjust;
  }
  ptp_tsTimeout = PTP_TSTIMEOUT;
}