/*
 *  ==== mon_AP.c ========
 */
#include <xdc/runtime/System.h>
#include <xdc/runtime/Gate.h>
#include <xdc/runtime/Diags.h>
#include <xdc/runtime/Log.h>
#include <xdc/runtime/Types.h>

#include <local/runtime/SysUart.h>
#include <local/runtime/utils/Stack.h>

#include <local/rf/Radio.h>
#include <local/rf/Bsp.h>

#include "msp430x22x4.h"

#define NUM_CONNECTIONS 2   /* should match (or exceed) rf config */
#define MAX_APP_PAYLOAD 20  /* should match (or exceed) rf config */

#define RED         1
#define GREEN       2

#define MESSAGE_LENGTH 3    /* should be <= MAX_APP_PAYLOAD */

#define TRACE       0x01
#define STACK       0x02
#define RADIO       0x04
#define SMPLT       0x08

#define HELP    0x01

void createRandomAddress(void);
Radio_Rssi getRssi(void);
void mcuInit(void);
void printMessage(int addr, signed char rssi,  char msg[MESSAGE_LENGTH]);
Void printEDEvent(char msg[], int len);
void printTempData(int node, int temp, int volt, int rssi_pct);

/* usage message for terminal input */
const char help[] = {
    "Commands:\r\n"
    "    c   - display tempature in Celcius\r\n"
    "    f   - display tempature in Fahrenheit\r\n" 
    "    s   - toggle stack trace\r\n"
    "    r   - toggle radio trace\r\n"
    "    n   - disable all trace\r\n"
    "    0-3 - switch to specified channel\r\n"
    "    ?   - display this menu\r\n"
    "    !   - reset\r\n"};

#define TEMP_OFFSET (*(int *)0x10F4)    /* tempature calibration offset */
#define FLASH_ADDR  ((char *)0x10F0)    /* Tag-Length-Value Table address */

#define INVALID_CHAN    ((char)-1)

/* reserve space for the maximum possible peer Link IDs */
static Radio_LinkId sLID[NUM_CONNECTIONS];
static uint8_t  sNumCurrentPeers;

/* callback handler */
static uint8_t sCB(Radio_LinkId);

/* work loop semaphores */
static uint8_t sPeerFrameSem;
static uint8_t sJoinSem;
static uint8_t sSelfMeasureSem;

/* mode data */
char degCMode = 0;      /* use deg F by default */
char traceMask = 0;     /* disable all trace by default */
char helpMask = 0;      /* don't display help initially */
char radioChan = INVALID_CHAN;

/*
 *  ======== main ========
 */
void main(void)
{
    Radio_Addr lAddr;
    IArg intState;
    volatile int i;
    
    WDTCTL = WDTPW + WDTHOLD;         /* Stop WDT */

    /* delay loop to ensure proper startup before SimpliciTI increases DCO */
    /* This is typically tailored to the power supply used, and in this case */
    /* is overkill for safety due to wide distribution. */
    for (i = 0; i < 0xFFFF; i++){}
    
    if (CALBC1_8MHZ == 0xFF) {  /* Do not run if cal values are erased */
        volatile int i;
        P1DIR |= 0x03;
        Bsp_turnOnLed(RED);
        Bsp_turnOffLed(GREEN);
        while (1) {
            for (i = 0; i < 0x5FFF; i++){}
            Bsp_toggleLed(GREEN);
            Bsp_toggleLed(RED);
        }
    }
    
    if (FLASH_ADDR[0] == 0xFF && FLASH_ADDR[1] == 0xFF
        && FLASH_ADDR[2] == 0xFF && FLASH_ADDR[3] == 0xFF) {

        /* flash a Random device address at startup */
        createRandomAddress();   
    }

    /* copy our address (from flash) into network RAM */
    lAddr.addr[0] = FLASH_ADDR[0];
    lAddr.addr[1] = FLASH_ADDR[1];
    lAddr.addr[2] = FLASH_ADDR[2];
    lAddr.addr[3] = FLASH_ADDR[3];
    
    mcuInit();

    for (i = 0; i < 0xFFFF; i++){}

    /* initialize the radio network */
    Radio_start(sCB, &lAddr);
    System_printf("Network initialization done\n");

    /* main work loop */
    while (1) {
        if (helpMask & HELP) {
            helpMask ^= HELP;
            System_printf((String)help);
        }
        
        if (traceMask & TRACE) {
            Bits16 mask;
            traceMask ^= TRACE;

            mask = ((traceMask & RADIO) ? Diags_ENTRY : 0)
                | ((traceMask & SMPLT) ? Diags_USER1 : 0);
            Radio_Module_setMask(mask);
            Stack_Module_setMask((traceMask & STACK) ? Diags_EXIT : 0);

            Log_print1(Diags_USER1, "trace mask set to 0x%x", traceMask);
        }

        /* Wait for the Join semaphore to be set by the receipt of a
         * Join frame from a device that supports an End Device. 
         */
        if (sJoinSem && (sNumCurrentPeers < NUM_CONNECTIONS)) {
            /* listen for a new connection */
            Radio_listen(&sLID[sNumCurrentPeers]);
            sNumCurrentPeers++;
            intState = Gate_enterSystem();
            if (sJoinSem) {
                sJoinSem--;
            }
            Gate_leaveSystem(intState);
        }
    
        /* change channel if requested */
        if (radioChan != INVALID_CHAN) {
            Radio_setChannel((Int)radioChan);
            radioChan = INVALID_CHAN;
        }
        
        /* if it is time to measure our own temperature... */
        if (sSelfMeasureSem) {
            char msg[MESSAGE_LENGTH];
            int degC, volt;
            volatile long temp;
            int results[2];
            
            ADC10CTL1 = INCH_10 + ADC10DIV_4;   /* Temp Sensor ADC10CLK/5 */
            ADC10CTL0 = SREF_1 + ADC10SHT_3 + REFON + ADC10ON + ADC10IE + ADC10SR;
            for (degC = 240; degC > 0; degC--); /* allow reference to settle */
            ADC10CTL0 |= ENC + ADC10SC;         /* Sample & convertion start */
            __bis_SR_register(CPUOFF + GIE);    /* LPM0 with interupts on */
            results[0] = ADC10MEM;
            
            ADC10CTL0 &= ~ENC;
            
            ADC10CTL1 = INCH_11;                /* AVcc/2 */
            ADC10CTL0 = SREF_1 + ADC10SHT_2 + REFON + ADC10ON + ADC10IE + REF2_5V;
            for (degC = 240; degC > 0; degC--); /* allow reference to settle */
            ADC10CTL0 |= ENC + ADC10SC;         /* Sample & convertion start */
            __bis_SR_register(CPUOFF + GIE);    /* LPM0 with interrupts on */
            results[1] = ADC10MEM;
            ADC10CTL0 &= ~ENC;
            ADC10CTL0 &= ~(REFON + ADC10ON);    /* turn off A/D; saves power */
            
            /* oC = ((A10/1024)*1500mV)-986mV)*1/3.55mV = A10*423/1024 - 278 */
            /* the temperature is printed as an integer where 32.1 = 321 */
            /* hence 4230 instead of 423 */
            temp = results[0];
            degC = ((temp - 673) * 4230) / 1024;
            if (TEMP_OFFSET != 0xFFFF) {
                degC += TEMP_OFFSET; 
            }
            
            temp = results[1];
            volt = (temp * 25) / 512;
            msg[0] = degC & 0xFF;
            msg[1] = (degC >> 8) & 0xFF;
            msg[2] = volt;

            printMessage(-1, getRssi(), msg);
            Bsp_toggleLed(RED);

            sSelfMeasureSem = 0;
        }
    
        /*  Have we received a frame on one of the ED connections?
         *  No critical section -- it doesn't really matter much if we miss a
         *  poll 
         */
        if (sPeerFrameSem) {
            uint8_t msg[MAX_APP_PAYLOAD], len, i;
        
            /* process all frames waiting */
            for (i = 0; i < sNumCurrentPeers; ++i)  {
                if (Radio_receive(sLID[i], msg, &len) == Radio_SUCCESS) {
                    Radio_RxMetrics metrics;

                    Radio_getMetrics(sLID[i], &metrics);
                    printMessage(i, metrics.rssi, (char *)msg);
                    Bsp_toggleLed(GREEN);
                    
                    intState = Gate_enterSystem();
                    sPeerFrameSem--;
                    Gate_leaveSystem(intState);
                }
            }
        }
    }
}

/*
 *  ======== createRandomAddress ========
 */
void createRandomAddress(void)
{
    unsigned int rand, rand2;
    extern int TI_getRandomIntegerFromVLO(void);
    
    do {    /* first byte can't be 0x00 or 0xFF */
        rand = TI_getRandomIntegerFromVLO();    
    } while((rand & 0xFF00) == 0xFF00 || (rand & 0xFF00) == 0x0000);

    rand2 = TI_getRandomIntegerFromVLO();
    
    /* write the random address to Flash */
    BCSCTL1 = CALBC1_1MHZ;              /* Set DCO to 1MHz */
    DCOCTL = CALDCO_1MHZ;
    FCTL2 = FWKEY + FSSEL0 + FN1;       /* MCLK/3 for Flash Timing Generator */
    FCTL3 = FWKEY + LOCKA;              /* Clear LOCK & LOCKA bits */
    FCTL1 = FWKEY + WRT;                /* Set WRT bit for write operation */
    
    FLASH_ADDR[0] = (rand >> 8) & 0xFF;
    FLASH_ADDR[1] = rand & 0xFF;
    FLASH_ADDR[2] = (rand2 >> 8) & 0xFF; 
    FLASH_ADDR[3] = rand2 & 0xFF; 
    
    FCTL1 = FWKEY;                      /* Clear WRT bit */
    FCTL3 = FWKEY + LOCKA + LOCK;       /* Set LOCK & LOCKA bit */
}

/*
 *  ======== printMessage ========
 */
void printMessage(int addr, signed char rssi, char msg[MESSAGE_LENGTH])
{
    int rssi_pct;
    int temp;
    
    /*  Convert raw rssi value into a "percent"
     *  We could scale the rssi value based on the full range of the
     *  data type ([-128,127]):
     *      rssi_pct = (int)rssi_pct + 128;
     *      rssi_pct = (rssi_pct * 100) / 256;
     *
     *  But since rssi is dBm, it's real range is [-110, 0) and, in
     *  practice never seems to go below -98.  So, we simply add 100 to
     *  the raw value.
     */
    rssi_pct = rssi + 100;
    
    temp = msg[0] + (msg[1] << 8);
    if (msg[1] == 0x80) {
        if (traceMask & RADIO) {
            Log_print2(Diags_USER1,
                "trace event received: node: %0.2d, strength: %3d",
                addr + 1, rssi_pct);
        }
        printEDEvent(msg + 2, msg[0]);
    }
    else {
        printTempData(addr + 1, temp, msg[2], rssi_pct);

        if (Stack_getUnused() <= 0) {
            IArg intState;
            System_printf("warning: stack overrun\r\n");
            intState = Gate_enterSystem();
            Stack_fill();
            Gate_leaveSystem(intState);
        }
    }
}

#define EVENT_SUFFIX_SIZE (sizeof(Log_EventRec)-sizeof(Types_Timestamp64))

/*
 *  ======== printEDEvent ========
 */
Void printEDEvent(char msg[], int len)
{
    Log_EventRec evtRec;
    Char *src, *dst;
    Int i;

    if (len > EVENT_SUFFIX_SIZE) {
        len = EVENT_SUFFIX_SIZE;
    }

    /* "unpack" message into a Log_EventRec */
    evtRec.tstamp.hi = 0;
    evtRec.tstamp.lo = 0;
    src = msg;
    dst = (Char *)&evtRec.serial;
    for (i = len; i > 0; i--) {
        *dst++ = *src++;
    }

    /* push ED event out the serial port */

    /* send header */
    SysUart_putch('\01');

    /* send prog id */
    SysUart_putch('\01');

    /* send payload */
    for (src = (Char *)&evtRec, i = 0; i < sizeof(evtRec); i++) {
        SysUart_putch(*src++);
    }
}

/*
 *  ======== printTempData ========
 */
void printTempData(int node, int temp, int volt, int rssi_pct)
{
    int t1, t2;
    char *format = "Node:%0.2d, Temp: %d.%dC, Battery: %d.%dV, Strength: %d\n";

    if (!degCMode) {
        temp = (((float)temp) * 1.8) + 320;
    }

    t1 = temp / 10;
    t2 = temp % 10;
    if (t2 < 0) {
        t2 = -1 * t2;
    }

    if (!degCMode) {
        format = "Node:%0.2d, Temp: %d.%dF, Battery: %d.%dV, Strength: %d\n";
    }

    System_printf(format, node, t1, t2, volt / 10, volt % 10, rssi_pct);
}

/*
 *  ======== mcuInit ========
 */
void mcuInit(void)
{
    BCSCTL1 = CALBC1_8MHZ;              /* Set DCO */
    DCOCTL = CALDCO_8MHZ;
    BCSCTL3 |= LFXT1S_2;                /* LFXT1 = VLO */
    
    TBCCTL0 = CCIE;                     /* Timer_B interrupt enabled */
    TBCCR0 = 12000;                     /* ~1 second */
    TBCTL = TASSEL_1 + MC_1;            /* ACLK, upmode */
}

/*
 *  ======== getRssi ========
 *  Compute a measure of the signal strength on the current channel.  This
 *  gives a measure of interference from other wireless devices and can be
 *  used to decide to switch channels to avoid interference.
 */
#define WLEN   2
#define NUMSAMPLES  (24 / WLEN)

Radio_Rssi getRssi()
{
    Int max = -100;
    Int total;
    Int i, j;
    Radio_Rssi window[WLEN];
    
    for (i = 1; i <= NUMSAMPLES; i++) {
        if (sPeerFrameSem || sJoinSem) {
            return ((Radio_Rssi)max);
        }

        window[i % WLEN] = Radio_getRssi();
        if (i >= WLEN) {
            for (total = j = 0; j < WLEN; j++) {
                total += window[j];
            }
            total = total / WLEN;
            if (max < total) {
                max = total;
            }
        }
        Bsp_delay(1);
    }
    
    return ((Radio_Rssi)max);
}

/*
 *  ======== sCB ========
 *  Runs in ISR context. Reading the frame should be done in the
 *  application thread not in the ISR thread.
 */
static uint8_t sCB(Radio_LinkId lid)
{
    if (lid)  {
        sPeerFrameSem++;
    }
    else {
        sJoinSem++;
    }
    
    /* leave frame to be read by application. */
    return (0);
}

/*------------------------------------------------------------------------------
* ADC10 interrupt service routine
------------------------------------------------------------------------------*/
__asm("\t.global ADC10_ISR");
__asm("\t.sect   \".adc10\"");
__asm("\t.align  2");
__asm("_ADC10_vector:\n\t.field ADC10_ISR, 16");
__interrupt void ADC10_ISR(void)
{
    __bic_SR_register_on_exit(CPUOFF);  /* Clear CPUOFF bit from 0(SR) */
}

/*------------------------------------------------------------------------------
* Timer A0 interrupt service routine
------------------------------------------------------------------------------*/
__asm("\t.global TIMER_A0_ISR");
__asm("\t.sect   \".timer_a0\"");
__asm("\t.align  2");
__asm("_TIMER_A0_vector:\n\t.field TIMER_A0_ISR, 16");
__interrupt void TIMER_A0_ISR (void)
{
    sSelfMeasureSem = 1;
}

/*------------------------------------------------------------------------------
* Timer B0 interrupt service routine
------------------------------------------------------------------------------*/
__asm("\t.global TIMER_B0_ISR");
__asm("\t.sect   \".timer_b0\"");
__asm("\t.align  2");
__asm("_TIMER_B0_vector:\n\t.field TIMER_B0_ISR, 16");
__interrupt void TIMER_B0_ISR (void)
{
    sSelfMeasureSem = 1;
}

/*
 *  ======== uartRxCallback ========
 */
void uartRxCallback(char *buf, int len)
{
    char rx = buf[0];
    extern void _c_int00(void);
    
    if (rx == 'F' || rx == 'f') {
        degCMode = 0;
    }
    else if (rx == 'C' || rx == 'c') {
        degCMode = 1;
    }
    else if (rx == 'r') {
        traceMask ^= (RADIO | TRACE);
    }
    else if (rx == 'R') {
        traceMask ^= (SMPLT | TRACE);
    }
    else if (rx == 'N' || rx == 'n') {
        traceMask = TRACE;
    }
    if (rx == 'S' || rx == 's') {
        traceMask ^= (STACK | TRACE);
    }
    if (rx == '?') {
        helpMask = HELP;
    }
    if (rx >= '0' && rx <= '3') {
        radioChan = rx - '0';
    }
    if (rx == '!') {
        Bsp_reset();
    }
}