int main( void )
{
  
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT

  FLL_CTL0=XCAP10PF;         // Configure load caps
  
  __delay_cycles(5000);
  
  
  unsigned char answer=0x08;
  TI_CC_SPISetup();                         // Initialize SPI port
  P1DIR |= LED_OFF;                        // Port 1.7 output

  TI_CC_PowerupResetCCxxxx();               // Reset CCxxxx
  __delay_cycles(5000);
  TI_CC_SPIStrobe(TI_CCxxx0_SIDLE);         // Send strobe SIDLE
  __delay_cycles(5000);
  TI_CC_SPIWriteReg(TI_CCxxx0_ADDR, 0x0F);  //ADDR =0x0F
  __delay_cycles(5000);
  answer=TI_CC_SPIReadReg(TI_CCxxx0_ADDR);  //answer = 0x0F

  volatile unsigned int i;

  for (;;) {
    if(answer==0x00) {
      P1OUT ^= LED_OFF; // on/off P1.7
      i = 50000; // delay
      do (i--);
      while (i != 0);
    
      }
      else {
      P1OUT &= ~LED_OFF;
      
    }
  }
}

// Delay function. # of CPU cycles delayed is similar to "cycles". Specifically,
// it's ((cycles-15) % 6) + 15.  Not exact, but gives a sense of the real-time
// delay.  Also, if MCLK ~1MHz, "cycles" is similar to # of useconds delayed.
void TI_CC_Wait(unsigned int cycles)
{
  while(cycles>15)                          // 15 cycles consumed by overhead
    cycles = cycles - 6;                    // 6 cycles consumed each iteration
}

void TI_CC_SPISetup(void)
{
// unsigned short m;
  P4OUT |= ECS_b;
  P4DIR |= ECS_b;                           // /ExternalCS disable
  ME1 |= USPIE0;                            // Enable USART0 SPI mode
  UCTL0 = SWRST;                            // Disable USART state machine
  UCTL0 |= CHAR + SYNC + MM;                // 8-bit SPI Master **SWRST**
  UTCTL0 |= CKPH + SSEL1 + SSEL0 + STC + TXEPT;     // SMCLK, 3-pin mode
  UBR00 = 0x08;                             // UCLK/8
  UBR10 = 0x00;                             // 0
  UMCTL0 = 0x00;                            // No modulation
  P3SEL |= SPI_O | SPI_I | SPI_C;           // SPI option select
  P3DIR |= SPI_O + SPI_C;
                                            // SPI TX out direction
  UCTL0 &= ~SWRST;                          // Initialize USART state machine
}

void TI_CC_SPIWriteReg(char addr, char value)
{
  P4OUT &= ~ECS_b;                          // /ExternalCS enable
  while (!(IFG1&UTXIFG0));                  // Wait for TX to finish
  U0TXBUF = addr;                           // Send address
  while (!(IFG1&UTXIFG0));                  // Wait for TX to finish
  __no_operation();
  __no_operation();
  U0TXBUF = value;                          // Send value
  while(!(UTCTL0&TXEPT));                   // Wait for TX complete
  P4OUT |= ECS_b;                           // /ExternalCS disable
}

char TI_CC_SPIReadReg(char addr)
{
  char x;

  P4OUT &= ~ECS_b;                           // /CS enable
  while (!(IFG1 & UTXIFG0));                // Wait for TX to finish
  U0TXBUF = (addr | TI_CCxxx0_READ_SINGLE); // Send address
  while (!(IFG1 & UTXIFG0));                // Wait for TX to finish
  __no_operation();
  __no_operation();
  U0TXBUF = 0;                              // Dummy write so we can read data
  while(!(UTCTL0 & TXEPT));                 // Wait for TX complete
  x = U0RXBUF;                              // Read data
  P4OUT |= ECS_b;                           // /CS disable

  return x;
}

// For status/strobe addresses, the BURST bit selects between status registers
// and command strobes.
void TI_CC_SPIStrobe(char strobe)
{
  P4OUT &= ~ECS_b;                          // /CS enable
  while (!(IFG1 & UTXIFG0));                // Wait for TX to finish
  U0TXBUF = strobe;                         // Send strobe
  // Strobe addr is now being TX'ed
  IFG1 &= ~URXIFG0;                         // Clear flag
  while(!(UTCTL0 & TXEPT));                 // Wait for TX complete
  P4OUT |= ECS_b;                           // /CS disable
}

void TI_CC_PowerupResetCCxxxx(void)
{
  P4OUT |= ECS_b;
  TI_CC_Wait(30);
  P4OUT &= ~ECS_b;
  TI_CC_Wait(30);
  P4OUT |= ECS_b;
  TI_CC_Wait(45);

  P4OUT &= ~ECS_b;                          // /CS enable
  while (!(IFG1 & UTXIFG0));                // Wait for TX to finish
  U0TXBUF = TI_CCxxx0_SRES;                 // Send strobe
  // Strobe addr is now being TX'ed
  while(!(UTCTL0 & TXEPT));                 // Wait for TX complete
  P4OUT |= ECS_b;                           // /CS disable
}

TI_CC_PowerupResetCCxxxx();               // Reset CCxxxx

Во-вторых: SPI у трансивера с особенностью - надо дожидаться когда MISO 1-->0 (When CSn is pulled low, the MCU must wait
until CC1101 SO pin goes low before starting to transfer the header byte.), байт состояния возвращается одновременно с передачей байта заголовка.

И кстати, для отработки интерфейса более наглядны регистры PARTNUM и VERSION.