rep.c

Go to the documentation of this file.

/*
 * rep.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 "rep.h"
#include "adc.h"
#include "ptp.h"
#include "uart.h"
#include "nwk.h"
#include "clock.h"

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

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

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

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

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

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

UInt8 rep_startFrame(UInt8 len, UInt8 reportType);
UInt8 rep_snd(UInt8 len, void *pBuf);
void rep_endFrame(UInt8 forwardToSerial);
UInt8 rep_sndUInt8(UInt8 v);
UInt8 rep_sndUInt16(UInt16 v);
UInt8 rep_sndUInt32(UInt32 *p);
UInt8 rep_sndUInt48(uint64_t *p);
UInt8 rep_sndUInt48sc(clock_secondsCount *p);
UInt8 rep_sndUInt64(uint64_t *p);
UInt8 rep_sndInt64(int64_t *p);

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

void rep_init() {

}

UInt16 rep_proccess() {
  UInt16 v16 = 0;
  clock_timeStamp time;
  UInt8 portIndex;

  if (nwk_isBound() || nwk_isSink()) {
    if (rep_startFrame(76, 1)) {
      rep_sndUInt64(nwk_getPIeeeAddress()); // 8 bytes
      adc_getTemp(&v16, &time); // get temperature/timestamp
      rep_sndUInt16(v16); // 2 bytes
      rep_sndUInt48sc(&(time.seconds)); // 6 bytes
      rep_sndUInt32(&(time.nanoSeconds)); // 4 bytes
      adc_getVolt(&v16, &time); // get voltage/timestamp
      rep_sndUInt16(v16); // 2 bytes
      rep_sndUInt48sc(&(time.seconds)); // 6 bytes
      rep_sndUInt32(&(time.nanoSeconds)); // 4 bytes
      adc_getLux(&v16, &time); // get luminescence/timestamp
      rep_sndUInt16(v16); // 2 bytes
      rep_sndUInt48sc(&(time.seconds)); // 6 bytes
      rep_sndUInt32(&(time.nanoSeconds)); // 4 bytes
      // clock adjusting information:
      portIndex = ptpClock.defaultDS.numberPorts;
      while (portIndex) {
        portIndex--;
        if (ptpClock.parentDS.parentPortIdentity.clockIdentity
            == &(ptp_foreignMaster[portIndex][0].clockIdentity)) {
          rep_sndUInt16(nwk_neighbors[portIndex].foreignAddress);
          portIndex = 0;
        } else if (!portIndex) {
          rep_snd(2, "\xFF\xFF");
        }
      } // 2 bytes
      rep_sndUInt64(&ptp_meanDelayAtLastAdjust); // 8 bytes
      rep_sndInt64(&ptp_lastAdjust); // 8 bytes
      rep_sndUInt48sc((void*) &(ptp_lastAdjustTime.secondsField)); // 6 bytes
      rep_sndUInt32(&(ptp_lastAdjustTime.nanoSecondsField)); // 4 bytes
      rep_sndUInt32(&clock_tickSize); // 4 bytes
      rep_endFrame(TRUE); // If true, the sending command is forwarded to serial port
    } else
      return 5; // If no buffer space, try again in 5ms
  }
  return (REP_SENSORS_REPORT_PERIOD * 1000);
}

void rep_hello() {
  // delay loop, until 85 bytes are free on TX buffer.
  while (uart_txBufFree() < 85)
    __bis_SR_register(LPM3_bits + GIE);

  if (uart_startFrame(85, 0xE1, 2)) { // Send text message
    uart_snd(31, "******************************\n");
    uart_snd(16, " Sensor network\n");
    uart_snd(29, " with timestamp synchronized\n");
    uart_snd(9, " by PTP.\n");
    uart_endFrame();
  }

  // delay loop, until 81 bytes are free on TX buffer.
  while (uart_txBufFree() < 81)
    __bis_SR_register(LPM3_bits + GIE);

  if (uart_startFrame(81, 0xE1, 2)) { // Send text message
    uart_snd(9, "\n Autor:\n");
    uart_snd(27, " Fernando Biazi Nascimento\n");
    uart_snd(1, "\n");
    uart_snd(13, " Orientador:\n");
    uart_snd(31, " Prof. Dr. Paulo Batista Lopes\n");
    uart_endFrame();
  }

  // delay loop, until 30 bytes are free on TX buffer.
  while (uart_txBufFree() < 30)
    __bis_SR_register(LPM3_bits + GIE);

  if (uart_startFrame(30, 0xE1, 2)) { // Send text message
    uart_snd(30, "******************************");
    uart_endFrame();
  }

  // delay loop, until 100 bytes are free on TX buffer.
  while (uart_txBufFree() < 100)
    __bis_SR_register(LPM3_bits + GIE);
}

UInt8 rep_startFrame(UInt8 len, UInt8 reportType) {
  if (nwk_isBound()) {
    if (reportType == 1) // Only sensor report goes to the network
      return nwk_startFrame(0xFFFE, NWK_CMDIDRPT, NWK_DEFRADIUS, len);
  }
  if (nwk_isSink()) {
    return uart_startFrame(len, 0xE1, reportType);
  }
  return 0;
}

UInt8 rep_snd(UInt8 len, void *pBuf) {
  if (nwk_isBound()) {
    return nwk_snd(len, pBuf);

  }
  if (nwk_isSink()) {
    return uart_snd(len, pBuf);
  }
  return 0;
}

void rep_endFrame(UInt8 forwardToSerial) {
  if (nwk_isBound()) {
    nwk_endFrame(forwardToSerial);
  } else if (nwk_isSink()) {
    uart_endFrame();
  }
}

UInt8 rep_sndUInt8(UInt8 v) {
  if (nwk_isBound()) {
    return nwk_sndUInt8(v);
  }
  if (nwk_isSink()) {
    return uart_sndUInt8(v);
  }
  return 0;
}

UInt8 rep_sndUInt16(UInt16 v) {
  if (nwk_isBound()) {
    return nwk_sndUInt16(v);
  }
  if (nwk_isSink()) {
    return uart_sndUInt16(v);
  }
  return 0;
}

UInt8 rep_sndUInt32(UInt32 *p) {
  if (nwk_isBound()) {
    return nwk_sndUInt32(p);
  }
  if (nwk_isSink()) {
    return uart_sndUInt32(p);
  }
  return 0;
}

UInt8 rep_sndUInt48(uint64_t *p) {
  if (nwk_isBound()) {
    return nwk_sndUInt48(p);
  }
  if (nwk_isSink()) {
    return uart_sndUInt48(p);
  }
  return 0;
}

UInt8 rep_sndUInt48sc(clock_secondsCount *p) {
  if (nwk_isBound()) {
    if (nwk_sndUInt32(&(p->secondsLow)))
      return nwk_sndUInt16(p->secondsHigh);
    else
      return 0;
  }
  if (nwk_isSink()) {
    if (uart_sndUInt32(&(p->secondsLow)))
      return uart_sndUInt16(p->secondsHigh);
    else
      return 0;
  }
  return 0;
}

UInt8 rep_sndUInt64(uint64_t *p) {
  if (nwk_isBound()) {
    return nwk_sndUInt64(p);
  }
  if (nwk_isSink()) {
    return uart_sndUInt64(p);
  }
  return 0;
}

UInt8 rep_sndInt64(int64_t *p) {
  if (nwk_isBound()) {
    return nwk_sndInt64(p);
  }
  if (nwk_isSink()) {
    return uart_sndInt64(p);
  }
  return 0;
}