CCS/MSP430FR6879: MSP430FR6879 SPI SLAVE Restarting when trying to transmit

Part Number:MSP430FR6879

Tool/software: Code Composer Studio

i am using msp430fr6879 as spi slave

wherein my master would be continously sending the clock pulse all the time ,

i only enable my interrupt when required to transmit or receive data .

here is my code kindly look into it ..

#include <msp430.h>
#include <string.h>
#include <math.h>
#include "SPI_SendReceive.h"
//#include "globleParam.h"
#include "structure.h"
volatile unsigned char commState;
volatile unsigned char rxCmd;

Tank_Config_struct bTankConfig;

long modbusCRCAddition(unsigned char * arr, int bSize);
char* itoah(long num, char * s, int len);
void BOS_DataParsing(void);
void FillTankConfiguration(void);
unsigned long int readNumber(unsigned char * arr, int size);
void readString(unsigned char * arr, int size, unsigned char * getArr);

volatile unsigned int rxCount=0, txCount=0;
volatile unsigned char *txPtr;
volatile unsigned char rxBuff[rxtxBuffSize], txBuff[rxtxBuffSize], tmpChar;
unsigned char rxData[rxtxBuffSize], txData[rxtxBuffSize];

void BOS_SendReceiveFunction(void)
{
    if(UCB0STATW & UCOE)
        tmpChar= UCB0RXBUF;
    if(commState==Received)
    {
        //IE2 &=~UCB0RXIE;    // Interrupt disable

        char crcData[4];
        int j;
        for(j=0; j<rxCount-6; j++)
            rxData[j]=rxBuff[j+1];
        unsigned long int crc = modbusCRCAddition(rxData, rxCount-6);
        itoah(crc, crcData, sizeof crcData + 1);

        if(crcData[0]==rxBuff[rxCount-5])
            if(crcData[1]==rxBuff[rxCount-4])
                if(crcData[2]==rxBuff[rxCount-3])
                    if(crcData[3]==rxBuff[rxCount-2])
                        commState=ReadyToProcess;
                    else
                        commState=Ideal;

        BOS_DataParsing();
    }
    else if(commState==ReadyToTransmit)
    {
        if(txCount < (rxtxBuffSize-6))
        {
            char crctxData[4];
            unsigned long int crcT = modbusCRCAddition(txData, txCount);
            itoah(crcT, crctxData, sizeof crctxData + 1);
            txBuff[0]=0x02;
            int k;
            for(k=1; k<=txCount; k++)
                txBuff[k]=txData[k-1];
            txBuff[txCount+1]=crctxData[0];
            txBuff[txCount+2]=crctxData[1];
            txBuff[txCount+3]=crctxData[2];
            txBuff[txCount+4]=crctxData[3];
            txBuff[txCount+5]=0x03;

            txCount = txCount+6;
            txPtr = txBuff;
            commState=Transmit;

            //UCB0CTLW0 &= ~UCSWRST;
             tmpChar = UCB0RXBUF;

             UCB0IE |=UCRXIE;        //Interrupt enable
         __delay_cycles(100);
        }
        else
            commState=Ideal;
    }
}

void BOS_DataParsing(void)
{
    if(commState==ReadyToProcess)
    {
        if(rxData[0]==0x30 && rxData[1]==0x31)
            rxCmd = SetTankConfig;
        else if(rxData[0]==0x30 && rxData[1]==0x32)
            rxCmd = GetStatus;
        else if(rxData[0]==0x30 && rxData[1]==0x33)
            rxCmd = GetDeliveryData;
        else if(rxData[0]==0x30 && rxData[1]==0x34)
            rxCmd = AckDelivery;
        else if(rxData[0]==0x30 && rxData[1]==0x35)
            rxCmd = ClearDelivery;
        else if(rxData[0]==0x30 && rxData[1]==0x36)
            rxCmd = SetTankCount;
        else if(rxData[0]==0x30 && rxData[1]==0x37)
            rxCmd = SetLEDStatus;
        else if(rxData[0]==0x30 && rxData[1]==0x38)
            rxCmd = SetTablePoint;
        else
            rxCmd = UnknownCommand;
    }

    if(rxCmd==UnknownCommand)
        commState=WaitForReply;
    else
    {
        if(rxCmd==SetTankConfig)
            FillTankConfiguration();
        else if(rxCmd==GetStatus)
        {
            // Fill structures;
        }
        else if(rxCmd==GetDeliveryData)
        {
            // Fill structures;;
        }
        else if(rxCmd==AckDelivery)
        {
            // Fill structures;
        }
        else if(rxCmd==ClearDelivery)
        {
            // Fill structures;
        }
        else if(rxCmd==SetTankCount)
        {
            // Fill structures;
        }
        else if(rxCmd==SetLEDStatus)
        {
            // Fill structures;
        }
        else if(rxCmd==SetTablePoint)
        {
            // Fill structures;
        }
        commState=WaitForReply;
    }
}

void FillTankConfiguration(void)
{
//    bTankConfig.TankNO = readNumber(rxData+2, 2);    //bTankConfig.TankNO = ((rxData[2]-0x30)*10 + (rxData[3]-0x30));
//    bTankConfig.probeType = readNumber(rxData+4, 1);
//    bTankConfig.ProbeAdd = readNumber(rxData+5, 5);
//    bTankConfig.Productcode = readNumber(rxData+10, 2);
//    bTankConfig.MaxTankVolume = readNumber(rxData+12, 8);
//    bTankConfig.MaxTankHeight = readNumber(rxData+20, 6);
//    bTankConfig.Probeoffset = readNumber(rxData+26, 4);
//    bTankConfig.zero_water = readNumber(rxData+30, 4);
//    bTankConfig.DeliveryDelay = readNumber(rxData+34, 4);
//    bTankConfig.ALARM_MAX_VOLUME = readNumber(rxData+38, 8);
//    bTankConfig.ALARM_PROD_HIGH = readNumber(rxData+46, 8);
//    bTankConfig.ALARM_PROD_LOW = readNumber(rxData+54, 6);
//    bTankConfig.ALARM_waterhigh = readNumber(rxData+60, 6);
//    bTankConfig.waterflaotavailable = readNumber(rxData+66, 1);
//    bTankConfig.point_count = readNumber(rxData+67, 3);
//    readString(rxData+70, 10, bTankConfig.product_name);
}

unsigned long int readNumber(unsigned char * arr, int size)
{
    unsigned long int result = 0;
    unsigned int i=0;
    for(i=0; i < size;i++)
        result += ((arr[i] - 0x30)*(pow(10,(size-i-1))));
    return result;
}

void readString(unsigned char * arr, int size, unsigned char * getArr)
{
    int i=0;
    for(i=0; i < size; i++)
    {
        getArr[i] = (arr[i]);
    }
}

long modbusCRCAddition(unsigned char * arr, int bSize)
{
        unsigned int CRCFull = 0xFFFF;
        char CRCLSB;

        int i;
        for(i=0; i < bSize; i++)
        {
            CRCFull = CRCFull ^ (int)(arr[i]);
            int j;
            for(j=0; j<8; j++)
            {
                CRCLSB = CRCFull & 0x0001;
                CRCFull = (CRCFull >> 1) & 0x7FFF;

                if(CRCLSB==1)
                    CRCFull = CRCFull ^ 0xA001;
            }
        }
        return (CRCFull);
}

char* itoah(long num, char* s, int len)
{
        long n, m = 16;
        int i = 16+2;
        int shift = 'a'- ('9'+1);

        if(!s || len < 1)
                return 0;

        n = num < 0 ? -1 : 1;
        n = n * num;

        len = len > i ? i : len;
        i = len < i ? len : i;

        s[i-1] = 0;
        i--;
        if(!num)
        {
                if(len < 2)
                        return &s[i];

                s[i-1]='0';
                return &s[i-1];
        }
        while(i && n)
        {
                s[i-1] = n % m + '0';

                if (s[i-1] > '9')
                        s[i-1] += shift ;

                n = n/m;
                i--;
        }
        if(num < 0)
        {
                if(i)
                {
                        s[i-1] = '-';
                        i--;
                }
        }
        return &s[i];
}


/** Interrupt service routine
 *
 */

#if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
#pragma vector=USCI_B0_VECTOR
__interrupt void USCI_B0_ISR(void)
#elif defined(__GNUC__)
void __attribute__ ((interrupt(USCI_B0_VECTOR))) USCI_B0_ISR (void)
#else
#error Compiler not supported!
#endif
{
  if(UCB0IFG&UCRXIFG)
  {
        if(commState==Ideal)
        {
            rxCount=0;
            UCB0TXBUF=0;
            if(UCB0RXBUF==0x02)
            {
                rxBuff[rxCount]=UCB0RXBUF;
                if(rxCount<99)
                rxCount++;
                commState=Receiving;
            }
            else
                rxBuff[rxCount]=UCB0RXBUF;
        }
        else if(commState==Receiving)
        {
            UCB0TXBUF=0;
            rxBuff[rxCount]=UCB0RXBUF;
            if(rxCount<99)
            rxCount++;
            if(rxBuff[rxCount-1]==0x03)
            {
                if(rxCount>6)
                {
                    commState=Received;
                    //UCB0CTLW0 |= UCSWRST;
                    UCB0IE &=~UCRXIE;
                }
                else
                    commState=Ideal;
            }
            else if(rxCount >= rxtxBuffSize)
                commState=Ideal;
        }
        else if(commState==Received | commState==ReadyToProcess)
        {
            UCB0TXBUF=0;
            tmpChar=UCB0RXBUF;
        }
        else if(commState==Transmit)
        {
            if((UCB0IFG & UCTXIFG)== UCTXIFG);
            {
             UCB0TXBUF=*txPtr;

             if(txCount>0)
             txCount--;

             if(txCount==1)
             {

             }
             if(txCount==0)
                commState=Ideal;
            }
        }
  }
}