/*
 * MSP432 UART - Poll
 *
 * Copyright (c) Dr. Xinrong Li @ UNT
 * All rights reserved.
 */

#include <stdio.h>
#include <string.h>
#include <stdint.h>  //Exact-width integer types
#include <ti\devices\msp432p4xx\driverlib\driverlib.h>  //Driver library


#define DCO_FREQ    48e6  //unit: Hz; DCO nominal frequencies: 1.5, 3, 6, 12, 24, 48 MHz.
#define TIMER0_FREQ    1  //unit: Hz


#define NUM_DISP_TEXT_LINE    4


//function prototypes
void initDevice(void);
void initGPIO(void);
void initUART(void);

void uart0_transmitStr(const char *str);

// global variables
uint32_t clockMCLK;

uint8_t BlueTooth = 0;
uint8_t Temp;

const char *terminalDisplayText[NUM_DISP_TEXT_LINE] =
{
    "\r\n",
    "UART Demo\r\n",
    "R: red, G: green, B:blue, H: Help\r\n",
    "> "
};


void main(void)
{
    uint32_t i;
    uint8_t data;

    initDevice();
    initGPIO();
    initUART();

    // Enable interrupts
    Interrupt_enableMaster();

    Timer32_startTimer(TIMER32_0_BASE, false);

    //Initial display on terminal.
    for(i=0; i<NUM_DISP_TEXT_LINE; i++)
    {
        uart0_transmitStr(terminalDisplayText[i]);
    }

    while(1)
    {
        if(UART_getInterruptStatus(EUSCI_A0_BASE, EUSCI_A_UART_RECEIVE_INTERRUPT_FLAG))
        {
            data = UART_receiveData(EUSCI_A0_BASE);


            UART_clearInterruptFlag(EUSCI_A0_BASE, EUSCI_A_UART_RECEIVE_INTERRUPT_FLAG);

            switch(data)
            {
                case 'U':
                case 'u':
                    uart0_transmitStr("Sample.\r\n> ");
                    printf("BlueTooth Data = %d   %x \n",BlueTooth,BlueTooth);
                    if(BlueTooth==127)
                    {
                        uart0_transmitStr("High.\r\n> ");
                    }
                    if(BlueTooth==120)
                    {
                        uart0_transmitStr("Low.\r\n> ");
                    }
                    BlueTooth=0;
                    break;
                case 'H':
                case 'h':
                    for(i=0; i<NUM_DISP_TEXT_LINE; i++)
                    {
                        uart0_transmitStr(terminalDisplayText[i]);
                    }
                    break;
            }
        } //end of if
    } //end of while
}


void initDevice(void)
{
    WDT_A_holdTimer();  //stop Watchdog timer

    //Change VCORE to 1 to support a frequency higher than 24MHz.
    //See data sheet for Flash wait-state requirement for a given frequency.
    PCM_setPowerState(PCM_AM_LDO_VCORE1);
    FlashCtl_setWaitState(FLASH_BANK0, 1);
    FlashCtl_setWaitState(FLASH_BANK1, 1);

    //Enable FPU for DCO Frequency calculation.
    FPU_enableModule();
    FPU_enableLazyStacking(); // Required to use FPU within ISR.

    //Only use DCO nominal frequencies: 1.5, 3, 6, 12, 24, 48MHz.
    CS_setDCOFrequency(DCO_FREQ);

    //Divider: 1, 2, 4, 8, 16, 32, 64, or 128.
    //SMCLK used by UART and ADC14.

    CS_initClockSignal(CS_SMCLK, CS_DCOCLK_SELECT, CS_CLOCK_DIVIDER_16);

}


void initGPIO(void)
{
    //                       - P3.2: IN  ( UART: UCA2RXD ).
    //                       - P3.3: OUT ( UART: UCA2TXD ).
   // P3->SEL0    |=   ( BIT2 | BIT3 );
    GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P3, GPIO_PIN2, GPIO_PRIMARY_MODULE_FUNCTION);
    // P3->SEL1    &=  ~( BIT2 | BIT3 );
    GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P3, GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION);
}




void initUART(void)
{
    EUSCI_A2->CTLW0   |=   EUSCI_A_CTLW0_SWRST;
    //Configuration for 3MHz SMCLK, 9600 baud rate.
    //Calculated using the online calculator that TI provides at:
    //http://software-dl.ti.com/msp430/msp430_public_sw/mcu/msp430/MSP430BaudRateConverter/index.html
    const eUSCI_UART_Config config =
    {
        EUSCI_A_UART_CLOCKSOURCE_SMCLK, //SMCLK Clock Source
        19, //BRDIV = 19
        8, //UCxBRF = 8
        85, //UCxBRS = 0
        EUSCI_A_UART_NO_PARITY, //No Parity
        EUSCI_A_UART_LSB_FIRST, //MSB First
        EUSCI_A_UART_ONE_STOP_BIT, //One stop bit
        EUSCI_A_UART_MODE, //UART mode
        EUSCI_A_UART_OVERSAMPLING_BAUDRATE_GENERATION //Oversampling
    };

    const eUSCI_UART_Config config2 =
    {
        EUSCI_A_UART_CLOCKSOURCE_SMCLK, //SMCLK Clock Source
        19, //BRDIV = 19
        9, //UCxBRF = 8
        85, //UCxBRS = 0
        EUSCI_A_UART_NO_PARITY, //No Parity
        EUSCI_A_UART_LSB_FIRST, //MSB First
        EUSCI_A_UART_ONE_STOP_BIT, //One stop bit
        EUSCI_A_UART_MODE, //UART mode
        EUSCI_A_UART_OVERSAMPLING_BAUDRATE_GENERATION //Oversampling
    };

    // Configure GPIO pins for UART. RX: P1.2, TX:P1.3.
    GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1, GPIO_PIN2|GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION);

    UART_initModule(EUSCI_A0_BASE, &config); //takes the config and plugs it into the UART initiation function
    UART_enableModule(EUSCI_A0_BASE);


    UART_initModule(EUSCI_A2_BASE, &config2);
    UART_enableModule(EUSCI_A2_BASE);                                    // Initialize eUSCI

//EUSCI_A2->IFG     &=  ~EUSCI_A_IFG_RXIFG;  //EUSCI_A_IFG_RXIFG=1 Clear eUSCI RX interrupt flag
UART_clearInterruptFlag(EUSCI_A2_BASE,~EUSCI_A_IFG_RXIFG);

//EUSCI_A2->IE      |=   EUSCI_A_IE_RXIE;                                           // Enable USCI_A2 RX interrupt
UART_enableInterrupt(EUSCI_A2_BASE,EUSCI_A_IE_RXIE);

//see website fore more explanation on NVIC: https://www.keil.com/pack/doc/CMSIS/Core/html/group__NVIC__gr.html#ga5bb7f43ad92937c039dee3d36c3c2798
NVIC_EnableIRQ    ( EUSCIA2_IRQn );   //for cortex-M based device
NVIC_SetPriority  ( EUSCIA2_IRQn, 16 );//for cortex-M based device

NVIC_EnableIRQ    ( EUSCIA0_IRQn );   //for cortex-M based device
NVIC_SetPriority  ( EUSCIA0_IRQn, 17 );//for cortex-M based device
}


// Transmit a string through UART0.
void uart0_transmitStr(const char *str)
{
    uint32_t len, i=0;

    len = strlen(str);

    while(i < len)
    {
        UART_transmitData(EUSCI_A0_BASE, str[i++]);

        while(!UART_getInterruptStatus(EUSCI_A0_BASE, EUSCI_A_UART_TRANSMIT_COMPLETE_INTERRUPT_FLAG));
        UART_clearInterruptFlag(EUSCI_A0_BASE, EUSCI_A_UART_TRANSMIT_COMPLETE_INTERRUPT_FLAG);
    }
}

void EUSCIA2_IRQHandler (void)
{
    uint8_t Mask = 0x7f;
    //Bluetooth transmits a packet that can be set to 9 bits that is read LSB first.
    //check to see if setting UART to LSB manipulates the Data to become MSB or manipulation is required
    //Check to see the default HC-06 packet size setting packets vary from 5-9 bits and register is 8 bits
   // UART_clearInterruptFlag(EUSCI_A2_BASE,~EUSCI_A_IFG_RXIFG);

    if (EUSCI_A2->IFG & EUSCI_A_IFG_RXIFG)
    {

        Temp = UART_receiveData(EUSCI_A2_BASE);
        BlueTooth = (Temp & Mask);
        //BlueTooth = EUSCI_A2->RXBUF;
        UART_clearInterruptFlag(EUSCI_A2_BASE,~EUSCI_A_IFG_RXIFG);

    }
}