MSP430FR6047: Unable to Update Firmware on TDC7200 GUI for MSP430 LaunchPad

#include <msp430.h>
#include <stdint.h>

// Pin Config ******************************************************************
#define SLAVE_CS_OUT    P7OUT
#define SLAVE_CS_DIR    P7DIR
#define SLAVE_CS_PIN    BIT3

#define SLAVE_RST_OUT   P7OUT
#define SLAVE_RST_DIR   P7DIR
#define SLAVE_RST_PIN   BIT5

#define BUTTON_DIR      P1DIR
#define BUTTON_OUT      P1OUT
#define BUTTON_REN      P1REN
#define BUTTON_PIN      BIT3
#define BUTTON_IES      P1IES
#define BUTTON_IE       P1IE
#define BUTTON_IFG      P1IFG
#define BUTTON_VECTOR   PORT1_VECTOR

#define BUTTON_LED_OUT  P1OUT
#define BUTTON_LED_DIR  P1DIR
#define BUTTON_LED_PIN  BIT1

#define COMMS_LED_OUT   P1OUT
#define COMMS_LED_DIR   P1DIR
#define COMMS_LED_PIN   BIT0

// TDC7200 Register Addresses **************************************************
#define CONFIG1_REG     0x00
#define CONFIG2_REG     0x01
#define TIME1_REG       0x10
#define TIME2_REG       0x11
#define CLOCK_COUNT1_REG 0x12
#define CLOCK_COUNT2_REG 0x13

// Bit Definitions *************************************************************
#define START_MEAS      0x01

#define DUMMY   0xFF
#define MAX_BUFFER_SIZE     20

uint8_t MasterType0[1] = {0x11};
uint8_t MasterType1[2] = {8, 9};
uint8_t MasterType2[6] = {'F', '4', '1', '9', '2', 'B'};

uint8_t SlaveType2[6] = {0};
uint8_t SlaveType1[2] = {0};
uint8_t SlaveType0[1] = {0};

// General SPI State Machine ***************************************************
typedef enum SPI_ModeEnum{
    IDLE_MODE,
    TX_REG_ADDRESS_MODE,
    RX_REG_ADDRESS_MODE,
    TX_DATA_MODE,
    RX_DATA_MODE,
    TIMEOUT_MODE
} SPI_Mode;

/* Used to track the state of the software state machine*/
SPI_Mode MasterMode = IDLE_MODE;

/* The Register Address/Command to use*/
uint8_t TransmitRegAddr = 0;

/* ReceiveBuffer: Buffer used to receive data in the ISR
 * RXByteCtr: Number of bytes left to receive
 * ReceiveIndex: The index of the next byte to be received in ReceiveBuffer
 * TransmitBuffer: Buffer used to transmit data in the ISR
 * TXByteCtr: Number of bytes left to transfer
 * TransmitIndex: The index of the next byte to be transmitted in TransmitBuffer
 * */
uint8_t ReceiveBuffer[MAX_BUFFER_SIZE] = {0};
uint8_t RXByteCtr = 0;
uint8_t ReceiveIndex = 0;
uint8_t TransmitBuffer[MAX_BUFFER_SIZE] = {0};
uint8_t TXByteCtr = 0;
uint8_t TransmitIndex = 0;

/* SPI Write and Read Functions */
SPI_Mode SPI_Master_WriteReg(uint8_t reg_addr, uint8_t *reg_data, uint8_t count);
SPI_Mode SPI_Master_ReadReg(uint8_t reg_addr, uint8_t count);
void CopyArray(uint8_t *source, uint8_t *dest, uint8_t count);
void SendUCA2Data(uint8_t val);

void SendUCA2Data(uint8_t val)
{
    while (!(UCA2IFG & UCTXIFG)); // USCI_A2 TX buffer ready?
    UCA2TXBUF = val;
}

void CopyArray(uint8_t *source, uint8_t *dest, uint8_t count)
{
    uint8_t copyIndex = 0;
    for (copyIndex = 0; copyIndex < count; copyIndex++)
    {
        dest[copyIndex] = source[copyIndex];
    }
}
SPI_Mode SPI_Master_WriteReg(uint8_t reg_addr, uint8_t *reg_data, uint8_t count)
{
    MasterMode = TX_REG_ADDRESS_MODE;
    TransmitRegAddr = reg_addr;

    // Copy register data to TransmitBuffer
    CopyArray(reg_data, TransmitBuffer, count);

    TXByteCtr = count;
    RXByteCtr = 0;
    ReceiveIndex = 0;
    TransmitIndex = 0;

    SLAVE_CS_OUT &= ~(SLAVE_CS_PIN);
    SendUCA2Data(TransmitRegAddr);

    __bis_SR_register(GIE); // Enter LPM0 w/ interrupts

    SLAVE_CS_OUT |= SLAVE_CS_PIN;
    return MasterMode;
}

SPI_Mode SPI_Master_ReadReg(uint8_t reg_addr, uint8_t count)
{
    MasterMode = TX_REG_ADDRESS_MODE;
    TransmitRegAddr = reg_addr;
    RXByteCtr = count;
    TXByteCtr = 0;
    ReceiveIndex = 0;
    TransmitIndex = 0;

    SLAVE_CS_OUT &= ~(SLAVE_CS_PIN);
    SendUCA2Data(TransmitRegAddr);

    __bis_SR_register(CPUOFF + GIE); // Enter LPM0 w/ interrupts

    SLAVE_CS_OUT |= SLAVE_CS_PIN;
    return MasterMode;
}

void initSPI()
{
    // Configure SPI
    P7SEL0 |= (BIT0 | BIT1 | BIT2);
    P7SEL1 &= ~(BIT0 | BIT1 | BIT2);
    PM5CTL0 &= ~LOCKLPM5;

    // Clock Polarity: The inactive state is high
    // MSB First, 8-bit, Master, 3-pin mode, Synchronous
    UCA2CTLW0 = UCSWRST; // Put state machine in reset
    UCA2CTLW0 |= UCCKPL | UCMSB | UCSYNC | UCMST | UCSSEL__SMCLK; // 3-pin, 8-bit SPI Master
    UCA2BRW = 0x20;
    UCA2MCTLW = 0;
    UCA2CTLW0 &= ~UCSWRST; // Initialize USCI state machine
    UCA2IE |= UCRXIE; // Enable USCI_A2 RX interrupt
}

void initGPIO()
{
    // LEDs
    COMMS_LED_DIR |= COMMS_LED_PIN;
    COMMS_LED_OUT &= ~COMMS_LED_PIN;

    BUTTON_LED_DIR |= BUTTON_LED_PIN;
    BUTTON_LED_OUT &= ~BUTTON_LED_PIN;

    SLAVE_RST_DIR |= SLAVE_RST_PIN;
    SLAVE_RST_OUT |= SLAVE_RST_PIN;

    SLAVE_CS_DIR |= SLAVE_CS_PIN;
    SLAVE_CS_OUT |= SLAVE_CS_PIN;

    // Button to initiate transfer
    BUTTON_DIR &= ~(BUTTON_PIN); // button input
    BUTTON_OUT |= BUTTON_PIN; // button pull up
    BUTTON_REN |= BUTTON_PIN; // button pull up/down resistor enable
    BUTTON_IES |= BUTTON_PIN; // button Hi/lo edge
    BUTTON_IE |= BUTTON_PIN; // button interrupt enabled

    PM5CTL0 &= ~LOCKLPM5;
    BUTTON_IFG &= ~BUTTON_PIN; // button IFG cleared
}

void initClockTo1MHz()
{
    // Configure one FRAM waitstate as required by the device datasheet for MCLK
       // operation beyond 8MHz _before_ configuring the clock system.
       //FRCTL0 = FRCTLPW | NWAITS_1;

       // Clock System Setup
       CSCTL0_H = CSKEY_H;                     // Unlock CS registers
       CSCTL1 = DCOFSEL_0;                     // Set DCO to 1MHz

       // Set SMCLK = MCLK = DCO, ACLK = LFXTCLK (VLOCLK if unavailable)
       //CSCTL2 = SELA__LFXTCLK | SELS__DCOCLK | SELM__DCOCLK;

       // Per Device Errata set divider to 4 before changing frequency to
       // prevent out of spec operation from overshoot transient
      // CSCTL3 = DIVA__4 | DIVS__4 | DIVM__4;   // Set all corresponding clk sources to divide by 4 for errata
       //CSCTL1 = DCOFSEL_4 | DCORSEL;           // Set DCO to 16MHz

       // Delay by ~10us to let DCO settle. 60 cycles = 20 cycles buffer + (10us / (1/4MHz))
       //__delay_cycles(60);
       CSCTL3 = DIVA__1 | DIVS__1 | DIVM__1;   // Set all dividers to 1 for 16MHz operation
       CSCTL0_H = 0;                           // Lock CS registers
}

int main(void)
{
    WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer

    initClockTo1MHz();
    initGPIO();
    initSPI();

    SLAVE_RST_OUT &= ~SLAVE_RST_PIN; // Now with SPI signals initialized,
    __delay_cycles(100000);
    SLAVE_RST_OUT |= SLAVE_RST_PIN; // reset slave
    __delay_cycles(100000); // Wait for slave to initialize

    COMMS_LED_OUT |= COMMS_LED_PIN;
    __bis_SR_register(GIE); // CPU off, enable interrupts

    // Configure the TDC7200 to start the measurement
    uint8_t config1_data = 20; // Example: Set measurement mode
    uint8_t config2_data = 0x40; // Example: Set averaging cycles, other settings

    while(1){
    SPI_Master_WriteReg(CONFIG1_REG, &config1_data, 1); // Write to CONFIG1
    //__delay_cycles(100000);
    //SPI_Master_WriteReg(CONFIG2_REG, &config2_data, 1); // Write to CONFIG2
    }
    // Trigger measurement by writing to CONFIG1
    uint8_t start_meas = START_MEAS; // Set the START_MEAS bit
    SPI_Master_WriteReg(CONFIG1_REG, &start_meas, 1); // Start measurement

    // Read measurement result from TIME1
    SPI_Master_ReadReg(TIME1_REG, 3); // Read TIME1 register (3 bytes)
    CopyArray(ReceiveBuffer, SlaveType2, 3); // Store results in SlaveType2 array

    // Optionally, read the TIME2 register if multiple stops are used
    SPI_Master_ReadReg(TIME2_REG, 3); // Read TIME2 register (3 bytes)
    CopyArray(ReceiveBuffer, SlaveType1, 3); // Store results in SlaveType1 array

    __bis_SR_register(LPM0_bits + GIE); // Enter low-power mode while waiting for the result

    __no_operation(); // For debugger

    return 0;
}

// SPI Interrupt
#if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
#pragma vector=USCI_A2_VECTOR
__interrupt void USCI_A2_ISR(void)
#elif defined(__GNUC__)
void __attribute__ ((interrupt(USCI_A2_VECTOR))) USCI_A2_ISR(void)
#else
#error Compiler not supported!
#endif
{
    uint8_t uca2_rx_val = 0;
    switch (__even_in_range(UCA2IV, USCI_SPI_UCTXIFG))
    {
    case USCI_NONE:
        break;
    case USCI_SPI_UCRXIFG:
        uca2_rx_val = UCA2RXBUF;
        UCA2IFG &= ~UCRXIFG;
        switch (MasterMode)
        {
        case TX_REG_ADDRESS_MODE:
            if (RXByteCtr)
            {
                MasterMode = RX_DATA_MODE; // Need to start receiving now
                // Send Dummy To Start
                __delay_cycles(2000000);
                SendUCA2Data(DUMMY);
            }
            else
            {
                MasterMode = TX_DATA_MODE; // Continue to transmission with the data in Transmit Buffer
                // Send First
                SendUCA2Data(TransmitBuffer[TransmitIndex++]);
                TXByteCtr--;
            }
            break;

        case TX_DATA_MODE:
            if (TXByteCtr)
            {
                SendUCA2Data(TransmitBuffer[TransmitIndex++]);
                TXByteCtr--;
            }
            else
            {
                // Done with transmission
                MasterMode = IDLE_MODE;
                __bic_SR_register_on_exit(CPUOFF); // Exit LPM0
            }
            break;

        case RX_DATA_MODE:
            if (RXByteCtr)
            {
                ReceiveBuffer[ReceiveIndex++] = uca2_rx_val;
                // Transmit a dummy
                RXByteCtr--;
            }
            if (RXByteCtr == 0)
            {
                MasterMode = IDLE_MODE;
                __bic_SR_register_on_exit(CPUOFF); // Exit LPM0
            }
            else
            {
                SendUCA2Data(DUMMY);
            }
            break;

        default:
            __no_operation();
            break;
        }
        __delay_cycles(1000);
        break;
    case USCI_SPI_UCTXIFG:
        break;
    default:
        break;
    }
}

// Button Port Interrupt
#if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
#pragma vector = BUTTON_VECTOR
__interrupt void Button_ISR(void)
#elif defined(__GNUC__)
void __attribute__((interrupt(BUTTON_VECTOR))) Button_ISR(void)
#else
#error Compiler not supported!
#endif
{
    BUTTON_LED_OUT |= BUTTON_LED_PIN;
    BUTTON_IFG &= ~BUTTON_PIN; // button IFG cleared
    BUTTON_IE &= ~BUTTON_PIN;
    // Initiate
    __bic_SR_register_on_exit(LPM0_bits); // Exit LPM0
}