main.c

Go to the documentation of this file.

/*
 * main.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
 *  The contents of this file can also be found at:
 *  http://www.biazi.eng.br/mack/Mestrado/2014/SZS/license.txt
 *
 * Using Template: Code Composer Studio 5.3.0.00090 grace empty project
 *
 */

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

/*
 * ======== Grace related includes ========
 */
#include <ti/mcu/msp430/Grace.h>

/*
 *  ======== user includes ========
 */

#include <xdc/std.h>

#include "clock.h" // Clock routines
#include "spi.h" // SPI routines
#include "cc2480ai.h" // CC2480 routines
#include "nwk.h" // Network routines
#include "ptp.h" // PTP routines
#include "adc.h" // ADC routines
#include "uart.h" // Clock routines
#include "led.h" // Led control routines
#include "but.h" // Button control routines
#include "rep.h" // Report control routines
#include "im.h" // Interruption management
/*
 * ======== Doxygen ========
 */
/*
 *  ======== macros ========
 */

// Task schedules
#define MAIN_TASK_SCH_SPI main_taskSchedule[0]
#define MAIN_TASK_SCH_CCAI  main_taskSchedule[1]
#define MAIN_TASK_SCH_NWK main_taskSchedule[2]
#define MAIN_TASK_SCH_PTPDR main_taskSchedule[3]
#define MAIN_TASK_SCH_PTP main_taskSchedule[4]
#define MAIN_TASK_SCH_ADC main_taskSchedule[5]
#define MAIN_TASK_SCH_UART  main_taskSchedule[6]
#define MAIN_TASK_SCH_LED main_taskSchedule[7]
#define MAIN_TASK_SCH_BUT main_taskSchedule[8]
#define MAIN_TASK_SCH_REP main_taskSchedule[9]
#define MAIN_TASK_SCH_WDT main_taskSchedule[10]

#define MAIN_TASK_COUNT 11

#define MAIN_FLAG_WDT_BIT 1

/*
 *  ======== variables ========
 */

UInt16 main_taskSchedule[MAIN_TASK_COUNT];

void main() {
  UInt16 main_runCounter = 0;
  Uint8 main_flags = 0;
  UInt16 i;

  Grace_init();                   // Activate Grace-generated configuration

// >>>>> Fill-in user code here <<<<<

  // Check if WDT+ caused the prior reset condition
  if (IFG1 & WDTIFG) {
    // WDT+ initiated the prior reset condition
    IFG1 &= ~WDTIFG; // Software clear WDTIFG
    main_flags |= MAIN_FLAG_WDT_BIT;
  }
  //WDTCTL = WDTPW | WDTHOLD; // turn off Watch dog (for testing)

  clock_init();
  spi_init();
  ccai_init();
  nwk_init();
  ptp_init(); // PTP initialization is done after network is running by a call to ptp_initEnd.
  adc_init();
  uart_init();
  led_init();
  but_init();
  rep_init();

  // Report the reset
  if (uart_startFrame(1, 0xE1, 0)) {
    if (main_flags & MAIN_FLAG_WDT_BIT) {
      uart_snd(1, "\x01"); // Reset by WDT+
    } else {
      uart_snd(1, "\x00"); // Normal initialization
    }
    uart_endFrame();
  }

  // Hello message
  rep_hello();

  // If all tasks run at the same 1ms cycle, they may take more than 1ms to finish, and then
  // the next cycle will be delayed in units of ms. A better practice would be define delays
  // from one task to another here, for example main_taskSchedule[i] = 0x0001 << i; but
  // defining all tasks to start at the same time can be a good test to the tolerance of the
  // system to delays on the execution of his tasks.
  i = MAIN_TASK_COUNT;
  while (i) {
    i--;
    main_taskSchedule[i] = 0;
  }

  // Delay report task 200ms on first run
  MAIN_TASK_SCH_REP= 200;

  // Main loop
  for (;;) {

    // SPI routines
    if (MAIN_TASK_SCH_SPI== main_runCounter)
    MAIN_TASK_SCH_SPI = main_runCounter + spi_proccess();

    // CC2480 routines
    if (MAIN_TASK_SCH_CCAI == main_runCounter)
    MAIN_TASK_SCH_CCAI = main_runCounter + ccai_proccess();

    // Network routines
    if (MAIN_TASK_SCH_NWK == main_runCounter)
    MAIN_TASK_SCH_NWK = main_runCounter + nwk_process();

    // PTP routines
    if (MAIN_TASK_SCH_PTPDR == main_runCounter)
    MAIN_TASK_SCH_PTPDR = main_runCounter + ptp_processPDelayReq();
    if (MAIN_TASK_SCH_PTP == main_runCounter)
    MAIN_TASK_SCH_PTP = main_runCounter + ptp_process();

    // ADC routines
    if (MAIN_TASK_SCH_ADC == main_runCounter)
    MAIN_TASK_SCH_ADC = main_runCounter + adc_proccess();

    // UART routines
    if (MAIN_TASK_SCH_UART == main_runCounter)
    MAIN_TASK_SCH_UART = main_runCounter + uart_proccess();

    // Led routines
    if (MAIN_TASK_SCH_LED == main_runCounter)
    MAIN_TASK_SCH_LED = main_runCounter + led_proccess();

    // Button routines
    if (MAIN_TASK_SCH_BUT == main_runCounter)
    MAIN_TASK_SCH_BUT = main_runCounter + but_proccess();

    // Report status
    if (MAIN_TASK_SCH_REP == main_runCounter)
    MAIN_TASK_SCH_REP = main_runCounter + rep_proccess();

    // Watch dog routines
    if (MAIN_TASK_SCH_WDT == main_runCounter) {
      MAIN_TASK_SCH_WDT = main_runCounter + 2000;
      // Say "I'm here!" to watch dog.
      WDTCTL = WDTPW | WDTCNTCL | WDTSSEL;// Set WDT+ counter Clear and SourceSel bits (instruction clears other bits)
    }

    // Put device on LPM and wait next time to run main loop
    __bis_SR_register(LPM3_bits + GIE);

    // Increment main_runCounter
    main_runCounter++;
  }
}

UInt8 TMRB0_ISR() {
  Bool result = 0;
  static Uint8 main_timerCount = 0;

  __disable_interrupt();

  // run on each timer event
  clock_tick();

  main_timerCount++;

  if (!(main_timerCount & 0x03)) { // each 4 timer events (~1ms)
    result = 1; // Exit LPM by returning 1
  }

  __enable_interrupt();

  return result;
}