/**
  * @brief  Writes several byte to the CC2500 registers.
  * @param  pBuffer : pointer to the buffer  containing the data to be written to the CC2500 registers.
  * @param  WriteAddr : CC2500's internal address to write to.
  * @param  NumByteToWrite: Number of bytes to write.
  * @retval None
  */
void CC2500_WriteRegister(uint8_t* pBuffer, uint8_t WriteAddr, uint16_t NumByteToWrite)
{
  //set the first bit of header to 0 (write)
  //if multiple bytes to read, set the secodn bit of header to 1 (burst)
  if(NumByteToWrite > 0x01)
  {
    WriteAddr = (uint8_t) ((WriteAddr & CC2500_ADDRESS_MASK) | BURST_MODE);
  }
  else
  {
    WriteAddr = (uint8_t) (WriteAddr & CC2500_ADDRESS_MASK);
  }

  /* Set chip select Low at the start of the transmission */
  if (CC2500_Chip_Select() == CC2500_TIMEOUT_ERROR)
  {
    //terminate the transaction and return
    CC2500_CS_HIGH();
    return;
  }
  
  /* Send the Address of the indexed register */
  CC2500_SendByte(WriteAddr);

  /* Send the data that will be written into the device (MSB First) */
  while(NumByteToWrite >= 0x01)
  {
    CC2500_SendByte(*pBuffer);
    NumByteToWrite--;
    pBuffer++;
  }
  
  /* Set chip select High at the end of the transmission */ 
  CC2500_CS_HIGH();
}
/**
  * @brief  Writes one CC2500 Command.
  * @param  WriteCommand : CC2500 Command.
  * @param  ReadWriteFIFOFlag : 1: return RX FIFO available bytes; 0: return TX FIFO available bytes
  * @retval uint8_t status
  */
uint8_t CC2500_WriteCommand(uint8_t WriteCommand, uint8_t ReadWriteFIFOFlag)
{
	uint8_t status;
	WriteCommand &= (uint8_t) CC2500_ADDRESS_MASK;
	if ((WriteCommand < 0x30) || (WriteCommand > 0x3D))
	{
		return CC2500_STATUS_ERROR;
  }
	if (ReadWriteFIFOFlag)
	{
		WriteCommand |= (uint8_t) 0x80;
	}

  /* Set chip select Low at the start of the transmission */
  if (CC2500_Chip_Select() == CC2500_TIMEOUT_ERROR)
  {
    //terminate the transaction and return
    CC2500_CS_HIGH();
    return CC2500_STATUS_ERROR;
  }
  
  /* Send the Address of the indexed register */
  status = CC2500_SendByte(WriteCommand);
  
  /* Set chip select High at the end of the transmission */ 
  CC2500_CS_HIGH();
	
	return status;
}
/**
	* @brief  Reads a block of data from the CC2500.
	* @param  pBuffer : pointer to the buffer that receives the data read from the CC2500.
	* @param  ReadAddr : CC2500's internal address to read from.
	* @param  NumByteToRead : number of bytes to read from the CC2500.
	* @retval None
	*/
void CC2500_Read(uint8_t* pBuffer, uint8_t ReadAddr, uint16_t NumByteToRead)
{
	if(NumByteToRead > 0x01)
	{
		ReadAddr |= (uint8_t)(READWRITE_CMD | MULTIPLEBYTE_CMD);
	}
	else
	{
		ReadAddr |= (uint8_t)READWRITE_CMD;
	}
	/* Set chip select Low at the start of the transmission */
	CC2500_CS_LOW();
	
	/* Send the Address of the indexed register */
	CC2500_SendByte(ReadAddr);
	
	/* Receive the data that will be read from the device (MSB First) */
	while(NumByteToRead > 0x00)
	{
		/* Send dummy byte (0x00) to generate the SPI clock to CC2500 (Slave device) */
		*pBuffer = CC2500_SendByte(DUMMY_BYTE);
		NumByteToRead--;
		pBuffer++;
	}
	
	/* Set chip select High at the end of the transmission */ 
	CC2500_CS_HIGH();
}
/**
	* @brief  Writes one byte to the CC2500.
	* @param  pBuffer : pointer to the buffer  containing the data to be written to the CC2500.
	* @param  WriteAddr : CC2500's internal address to write to.
	* @param  NumByteToWrite: Number of bytes to write.
	* @retval None
	*/
void CC2500_Write(uint8_t* pBuffer, uint8_t WriteAddr, uint16_t NumByteToWrite)
{
	/* Configure the MS bit: 
			 - When 0, the address will remain unchanged in multiple read/write commands.
			 - When 1, the address will be auto incremented in multiple read/write commands.
	*/
	if(NumByteToWrite > 0x01)
	{
		WriteAddr |= (uint8_t)MULTIPLEBYTE_CMD;
	}
	/* Set chip select Low at the start of the transmission */
	CC2500_CS_LOW();
	
	/* Send the Address of the indexed register */
	CC2500_SendByte(WriteAddr);
	/* Send the data that will be written into the device (MSB First) */
	while(NumByteToWrite >= 0x01)
	{
		CC2500_SendByte(*pBuffer);
		NumByteToWrite--;
		pBuffer++;
	}
	
	/* Set chip select High at the end of the transmission */ 
	CC2500_CS_HIGH();
}
Beispiel #5
0
/**
  * @brief  Sends a single strobe command to CC2500
  * @param  Strobe command to send
  * @param 	1 for the FIFO_BYTES_AVAILABLE field in status byte should be for 
			the RX FIFO, 0 if it should be for the TX FIFO
  * @retval Status update received from CC2500
  */
uint8_t CC2500_Strobe(StrobeCommand StrobeCmd, uint8_t RX_FIFO) {
	//Set the Chip Select to low at the beginning of the transmission (page 21, CC2500)
	CC2500_CS_LOW(); 
	
	//The address we'll be writing to 
	uint8_t StrobeAddr; 
	
	//Check which FIFO status should be sent back with the status byte (page 24, CC2500)
	if(RX_FIFO){
		//Set the read/write bit if we want the RX FIFO
		StrobeAddr = ((uint8_t)StrobeCmd) | READWRITE_BIT; 
	}
	else{
		//If not, just use the StrobeCmd address
		StrobeAddr = (uint8_t)StrobeCmd; 
	}
	
	//Send the address of the register, get the response
	uint8_t statusByte = CC2500_SendByte(StrobeAddr); 
	
	//Set the Chip Select to high at the end of the transmission 
	//only for the SPWD and SXOFF strobes (page 24, CC2500)
	if(StrobeCmd == (CC2500_STROBE_SPWD || CC2500_STROBE_SXOFF)){
		CC2500_CS_HIGH(); 
	}
	
	//Return the response
	return statusByte;
}
Beispiel #6
0
/**
  * @brief  Writes bytes to the CC2500.
  * @param  pBuffer : pointer to the buffer  containing the data to be written to the CC2500.
  * @param  WriteAddr : CC2500's internal address to write to.
  * @param  NumByteToWrite: Number of bytes to write.
  * @retval None
  */
void CC2500_Write(uint8_t* pBuffer, uint8_t WriteAddr, uint16_t NumByteToWrite) {//Configure the header byte: burst access bit (B) and a 6-bit address (page 21, CC2500)
	//If more than one register needs to be written to, set B to 1 (page 23, CC2500)
	if(NumByteToWrite > 0x01){
		WriteAddr |= BURST_BIT;
	}
	
	//Set the Chip Select to low at the beginning of the transmission (page 21, CC2500)
	CC2500_CS_LOW(); 
	
	//Send the address of the register
	CC2500_SendByte(WriteAddr); 
	//Then loop through all of the bytes that need ot be send (MSB first)
	while(NumByteToWrite > 0x00){
		//Send the current byte at the pBuffer address
		CC2500_SendByte(*pBuffer);

		//Decrement the number of bytes to write
		NumByteToWrite--; 
		
		//Increment the pBuffer pointer position
		pBuffer++; 
	}
	
	//Set the Chip Select to high at the end of the transmission (page 23, CC2500)
	CC2500_CS_HIGH(); 
}
Beispiel #7
0
/**
  * @brief  Reads a block of data from the CC2500.
  * @param  pBuffer : pointer to the buffer that receives the data read from the CC2500.
  * @param  ReadAddr : CC2500's internal address to read from.
  * @param  NumByteToRead : number of bytes to read from the CC2500.
  * @retval None
  */
void CC2500_Read(uint8_t* pBuffer, uint8_t ReadAddr, uint16_t NumByteToRead) {
  //Configure the header byte: burst access bit (B) and a 6-bit address (page 21, CC2500)
	//If more than one register needs to be written to, set B to 1 (page 23, CC2500)
	//Regardless, set the read/write bit 
	if(NumByteToRead > 0x01){
		ReadAddr |= BURST_BIT | READWRITE_BIT;
	}	
	else{
		ReadAddr |= READWRITE_BIT;
	}
	
	//Set the Chip Select to low at the beginning of the transmission (page 21, CC2500)
	CC2500_CS_LOW(); 
	
	//Send the address of the register
   CC2500_SendByte(ReadAddr);
	//Then loop through the number of bytes that need to be read (MSB first)
	while(NumByteToRead > 0x00){
		//Send a dummy byte, store the response in the buffer
		*pBuffer = CC2500_SendByte(DUMMY_BYTE);
		
		//Decrement the number of bytes to read
		NumByteToRead--; 
		
		//Increment the pBuffer pointer position
		pBuffer++; 
	}
	
	//Set the Chip Select to high at the end of the transmission (page 23, CC2500)
	CC2500_CS_HIGH();
}
/**
  * @brief  Sends command strobe to the CC2500.
  * @param  cmd representing command strobe to be issued (see CC2500 UM page 60, table 37).
  * @param  Pointer to the current state of the CC2500(before strobe was issued).
	* @param  Pointer to number of free bytes in the CC2500 FIFO(before strobe was issued).
  * @retval None
  */
void CC2500_StrobeSend(uint8_t cmd, uint8_t* state, uint8_t* buffer_space)
{
	uint8_t chip_status =0;
	
  /* Set chip select Low at the start of the transmission */
  CC2500_CS_LOW();
  
  /* Send the command and receive chip ststus byte, and extract the state (bytes 6:4) */
  chip_status = CC2500_SendByte(cmd);

  /* Set chip select High at the end of the transmission */ 
  CC2500_CS_HIGH();
	
 //	osDelay(10);
 //	CC2500_CS_LOW();
//   
//   /* Send the command and receive chip ststus byte, and extract the state (bytes 6:4) */
  // chip_status = CC2500_SendByte(DUMMY_BYTE);
//   
//   /* Set chip select High at the end of the transmission */ 
  // CC2500_CS_HIGH();
	
	*state = chip_status & 0x70;
	*buffer_space = chip_status & 0x0F;
	
}
Beispiel #9
0
/**
  * @brief  Read status registor on he device
  * @param  Address of the status register to read
  * @retval Status register bits received from CC2500
  */
uint8_t CC2500_StatusReg(uint8_t StatusRegAddr) {
	uint8_t reg;
	//Set the Chip Select to low at the beginning of the transmission (page 21, CC2500)
	CC2500_CS_LOW();
	
	// set burst bit to high to distinct from strobe command (page 5, cc2500 design note)
	StatusRegAddr |= BURST_BIT;
	CC2500_Read(&reg, StatusRegAddr, 1);
 	
	// set the chip select to high marking end of transmission	
	CC2500_CS_HIGH(); 
	return reg;
}
/**
  * @brief  Reads a block of data from the CC2500 registers.
  * @param  pBuffer : pointer to the buffer that receives the data read from the CC2500.
  * @param  ReadAddr : CC2500's internal address to read from.
  * @param  NumByteToRead : number of bytes to read from the CC2500 registers.
  * @retval None
  */
void CC2500_ReadRegister(uint8_t* pBuffer, uint8_t ReadAddr, uint16_t NumByteToRead)
{
	ReadAddr = (uint8_t) (ReadAddr & CC2500_ADDRESS_MASK);
  //set the first bit of header to 1 (read)
  //if multiple bytes to read or read status registers, set the second bit of header to 1 (burst)
  if((NumByteToRead > 0x01) || ((ReadAddr >= 0x30) && (ReadAddr <=0x3D)))
  {
    ReadAddr |= (uint8_t) (READ_MODE | BURST_MODE);
  }
  else
  {
    ReadAddr |= (uint8_t) READ_MODE;
  }
  /* Set chip select Low at the start of the transmission */
  if (CC2500_Chip_Select() == CC2500_TIMEOUT_ERROR)
  {
    //terminate the transaction and return
    CC2500_CS_HIGH();
    return;
  }
  
  /* Send the Address of the indexed register */
  CC2500_SendByte(ReadAddr);
  
  /* Receive the data that will be read from the device (MSB First) */
  while(NumByteToRead > 0x00)
  {
    /* Send dummy byte (0x00) to generate the SPI clock to LIS302DL (Slave device) */
    *pBuffer = CC2500_SendByte(DUMMY_BYTE);
    NumByteToRead--;
    pBuffer++;
  }
  
  /* Set chip select High at the end of the transmission */ 
  CC2500_CS_HIGH();
}
Beispiel #11
0
void cc2500_One_Byte_Read(uint8_t* pBuffer, uint8_t ReadAddr)
{
	 /* Set chip select Low at the start of the transmission */
  CC2500_CS_LOW();
  
  /* Send the Address of the indexed register */
  cc2500_SendByte(ReadAddr);
  
	/* Send dummy byte (0x00) to generate the SPI clock to cc2500 (Slave device) */
	*pBuffer = cc2500_SendByte(DUMMY_BYTE);
	pBuffer++;
	
  /* Set chip select High at the end of the transmission */ 
  CC2500_CS_HIGH();
}
Beispiel #12
0
/**
 * @brief Sends a command stobe to the wireless chipset.
 *
 * @retval The current state of the wireless chipset.
 */
uint8_t CC2500_Strobe(uint8_t Strobe){
// 	uint8_t *buff;
// 	CC2500_CS_LOW();
// 	CC2500_SendByte(Strobe);
// 	//Wait until SO goes high
// 	CC2500_Read(buff, 0xBF, 0);
// 	CC2500_CS_HIGH();
	
	CC2500_CS_LOW();

	while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE)== RESET);	// check flag for transmission to be RESET
	SPI_I2S_SendData(SPI1, Strobe);												// condition satisfied --> send command strobe

	while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == SET);		// check flag for being busy to be SET
	CC2500_state = (SPI_I2S_ReceiveData(SPI1) & 0x70) >> 4;											// set status to most recent received data on SPI1

	// Set chip select High at the end of the transmission
	CC2500_CS_HIGH();   
	return CC2500_state;
}
/**
  * @brief  Reads a block of data from the CC2500.
  * @param  pBuffer : pointer to the buffer that receives the data read from the CC2500.
  * @param  ReadAddr : CC2500's internal address to read from.
  * @param  NumByteToRead : number of bytes to read from the CC2500.
  * @retval None
  */
void CC2500_Read(uint8_t* pBuffer, uint8_t ReadAddr, uint16_t NumByteToRead)
{  
  if(NumByteToRead > 0x01)
  {
		//differentiate command strobes from status registers using burst mode
		//ie. must use burst mode to read status registers however chip will
		//only return single register (single byte access for status registers)
		//as a result, we check to see if the address is in the status register range,
		//if so, keep the burst bit so the chip interprets the right instruction,
		//but modify NumByteToRead to only expect single byte return
		if((ReadAddr >= 0x30) && (ReadAddr <= 0x3D)){  //address limits for status registers
			NumByteToRead = 0x01;
		}
		
		//0 is single op, 1 is burst
    ReadAddr |= (uint8_t)(READWRITE_CMD | MULTIPLEBYTE_CMD);

  }
  else
  {
    ReadAddr |= (uint8_t)READWRITE_CMD;
  }
  /* Set chip select Low at the start of the transmission */
  CC2500_CS_LOW();
  
  /* Send the Address of the indexed register */
  *pBuffer = CC2500_SendByte(ReadAddr);
  
  /* Receive the data that will be read from the device (MSB First) */
  while(NumByteToRead > 0x00)
  {
    /* Send dummy byte (0x00) to generate the SPI clock to LIS302DL (Slave device) */
    *pBuffer = CC2500_SendByte(DUMMY_BYTE);
    NumByteToRead--;
    pBuffer++;
  }
  
  /* Set chip select High at the end of the transmission */ 
  CC2500_CS_HIGH();
}
Beispiel #14
0
/**
 * @brief Configures the SPI and starts the wireless chipset.
 *
 * @notes Configures SPI with the pins defined in the CC2500.h file. Then uses
 *				the SPI to put the wireless chipset through its manual restart
 *				procedure.
 */
void CC2500_LowLevel_Init(void){
	GPIO_InitTypeDef GPIO_InitStructure;
  SPI_InitTypeDef  SPI_InitStructure;
	uint8_t ctrl;

  /* Enable the SPI periph */
  RCC_APB2PeriphClockCmd(CC2500_SPI_CLK, ENABLE);

  /* Enable SCK, MOSI and MISO GPIO clocks */
  RCC_AHB1PeriphClockCmd(CC2500_SPI_SCK_GPIO_CLK | CC2500_SPI_MISO_GPIO_CLK | CC2500_SPI_MOSI_GPIO_CLK, ENABLE);

  /* Enable CS  GPIO clock */
  RCC_AHB1PeriphClockCmd(CC2500_SPI_CS_GPIO_CLK, ENABLE);

  GPIO_PinAFConfig(CC2500_SPI_SCK_GPIO_PORT, CC2500_SPI_SCK_SOURCE, CC2500_SPI_SCK_AF);
  GPIO_PinAFConfig(CC2500_SPI_MISO_GPIO_PORT, CC2500_SPI_MISO_SOURCE, CC2500_SPI_MISO_AF);
  GPIO_PinAFConfig(CC2500_SPI_MOSI_GPIO_PORT, CC2500_SPI_MOSI_SOURCE, CC2500_SPI_MOSI_AF);

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_DOWN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  /* SPI SCK pin configuration */
  GPIO_InitStructure.GPIO_Pin = CC2500_SPI_SCK_PIN;
  GPIO_Init(CC2500_SPI_SCK_GPIO_PORT, &GPIO_InitStructure);

  /* SPI  MOSI pin configuration */
  GPIO_InitStructure.GPIO_Pin =  CC2500_SPI_MOSI_PIN;
  GPIO_Init(CC2500_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure);

  /* SPI MISO pin configuration */
  GPIO_InitStructure.GPIO_Pin = CC2500_SPI_MISO_PIN;
  GPIO_Init(CC2500_SPI_MISO_GPIO_PORT, &GPIO_InitStructure);

  /* SPI configuration -------------------------------------------------------*/
  SPI_I2S_DeInit(CC2500_SPI);
  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
  SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;
  SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  SPI_InitStructure.SPI_CRCPolynomial = 7;
  SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  SPI_Init(CC2500_SPI, &SPI_InitStructure);

  /* Enable SPI1  */
  SPI_Cmd(CC2500_SPI, ENABLE);

  /* Configure GPIO PIN for Lis Chip select */
  GPIO_InitStructure.GPIO_Pin = CC2500_SPI_CS_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_Init(CC2500_SPI_CS_GPIO_PORT, &GPIO_InitStructure);

  /* Deselect : Chip Select high */
  GPIO_SetBits(CC2500_SPI_CS_GPIO_PORT, CC2500_SPI_CS_PIN);
	
	//CC2500_Read(&ctrl, 0x30, 1);
	CC2500_CS_LOW();
	delay(100);
	CC2500_CS_HIGH();
	delay(100);
	CC2500_CS_LOW();
	delay(150);
	
	// Send reset command
	CC2500_Strobe(SRES); 
	while(!GPIO_ReadInputDataBit(CC2500_SPI_MISO_GPIO_PORT, CC2500_SPI_MISO_PIN));
	CC2500_CS_HIGH();

	// Set to IDLE state
	CC2500_Strobe(SIDLE);
}
Beispiel #15
0
/**
  * @brief  Initializes the low level interface used to drive the CC2500
  * @param  None
  * @retval None
  */
static void CC2500_LowLevel_Init(void)
{
   GPIO_InitTypeDef GPIO_InitStructure;
   SPI_InitTypeDef  SPI_InitStructure;
   
   /* Enable the SPI periph */
   RCC_APB1PeriphClockCmd(CC2500_SPI_CLK, ENABLE);
   
   /* Enable SCK, CS, INT, MOSI and MISO GPIO clocks */
   RCC_AHB1PeriphClockCmd(CC2500_SPI_SCK_GPIO_CLK | CC2500_SPI_MISO_GPIO_CLK | CC2500_SPI_MOSI_GPIO_CLK | CC2500_SPI_CS_GPIO_CLK | CC2500_SPI_INT_GPIO_CLK, ENABLE);
   
   GPIO_PinAFConfig(CC2500_SPI_SCK_GPIO_PORT, CC2500_SPI_SCK_SOURCE, CC2500_SPI_SCK_AF);
   GPIO_PinAFConfig(CC2500_SPI_MISO_GPIO_PORT, CC2500_SPI_MISO_SOURCE, CC2500_SPI_MISO_AF);
   GPIO_PinAFConfig(CC2500_SPI_MOSI_GPIO_PORT, CC2500_SPI_MOSI_SOURCE, CC2500_SPI_MOSI_AF);
   
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
   GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_DOWN;
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

   /* SPI SCK pin configuration */
   GPIO_InitStructure.GPIO_Pin = CC2500_SPI_SCK_PIN;
   GPIO_Init(CC2500_SPI_SCK_GPIO_PORT, &GPIO_InitStructure);

   /* SPI  MOSI pin configuration */
   GPIO_InitStructure.GPIO_Pin =  CC2500_SPI_MOSI_PIN;
   GPIO_Init(CC2500_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure);

   /* SPI MISO pin configuration */
   GPIO_InitStructure.GPIO_Pin = CC2500_SPI_MISO_PIN;
   GPIO_Init(CC2500_SPI_MISO_GPIO_PORT, &GPIO_InitStructure);
   
     /* SPI configuration -------------------------------------------------------*/
   SPI_I2S_DeInit(CC2500_SPI);
   SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
   SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
   SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
   SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
   SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
   SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;
   SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
   SPI_InitStructure.SPI_CRCPolynomial = 7;
   SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
   SPI_Init(CC2500_SPI, &SPI_InitStructure);

   /* Enable SPI1  */
   SPI_Cmd(CC2500_SPI, ENABLE);
   
   /* Configure GPIO PIN for cc2500 Chip select */
   GPIO_InitStructure.GPIO_Pin = CC2500_SPI_CS_PIN;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
   GPIO_Init(CC2500_SPI_CS_GPIO_PORT, &GPIO_InitStructure);
   
   /* Deselect : Chip Select high */
   CC2500_CS_HIGH();
   
     /* Configure GPIO PINs to detect Interrupts */
   GPIO_InitStructure.GPIO_Pin = CC2500_SPI_INT_PIN;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
   GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;
   GPIO_Init(CC2500_SPI_INT_GPIO_PORT, &GPIO_InitStructure);
}