ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 其他分享> 文章详细

stm32+cc1101外部中断接收信息

2021-11-08 20:58:18  阅读：172  来源： 互联网

标签：接收 uint8 stm32 SPI HandleTypeDef CC1101 cc1101 hspi define


要把外部中断先关掉，在初始化之后再打开。在gpio.c里面注释掉：

上拉，下跳沿检测

    /*Configure GPIO pins : PB0 PB1 */
  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

/* EXTI interrupt init*/
  HAL_NVIC_SetPriority(EXTI0_IRQn, 0, 0);
  //HAL_NVIC_EnableIRQ(EXTI0_IRQn);

  HAL_NVIC_SetPriority(EXTI1_IRQn, 0, 0);
  //HAL_NVIC_EnableIRQ(EXTI1_IRQn);

接收端主函数：

	CC1101Reset(&hspi1);
	CC1101WORInit(&hspi1);
	CC1101Init(&hspi1);
	CC1101WriteCmd( CC1101_SRX ,&hspi1);
	
	HAL_NVIC_EnableIRQ(EXTI0_IRQn);
	HAL_NVIC_EnableIRQ(EXTI1_IRQn);

  while (1)
  {
	  if (rx[0] %2 ==  1)
	  {
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);
	  }
	  else {HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);}
	  
  }

发送端主函数：

CC1101Reset(&hspi1);
CC1101WORInit(&hspi1);
CC1101Init(&hspi1);

  while (1)
  {
    /* USER CODE END WHILE */
	
    /* USER CODE BEGIN 3 */
	  HAL_Delay(1000);
	  tx[0] = tx[0]+1;
	  CC1101SendPacket(tx , sizeof(tx), BROADCAST, &hspi1);
	  if (flag==0){
			HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);
			flag=1;
	  }
	  else {
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);
		  flag=0;
	  }

	  
  }

 cc1101.c:

#include "cc1101.h"
#include "spi.h"

uint8_t Rx_Flag;

static const uint8_t CC1101InitData[30][2]= 
{
/*  {CC1101_IOCFG0,      0x06},
  {CC1101_FIFOTHR,     0x47},
  {CC1101_PKTCTRL0,    0x05},
  {CC1101_CHANNR,      0x00},
  {CC1101_FSCTRL1,     0x08},
	{CC1101_FREQ2,       0x10},//433.92
  {CC1101_FREQ1,       0xB0},
  {CC1101_FREQ0,       0x3f},
//  {CC1101_FREQ2,       0x10},//433.862
//  {CC1101_FREQ1,       0xAf},
//  {CC1101_FREQ0,       0xdf},
  {CC1101_MDMCFG4,     0x5B},
  {CC1101_MDMCFG3,     0xF8},
  {CC1101_MDMCFG2,     0x03},
  {CC1101_DEVIATN,     0x47},
  {CC1101_MCSM0,       0x18},
  {CC1101_FOCCFG,      0x1D},
  {CC1101_WORCTRL,     0xFB},
  {CC1101_FSCAL3,      0xEA},
  {CC1101_FSCAL2,      0x2A},
  {CC1101_FSCAL1,      0x00},
  {CC1101_FSCAL0,      0x11},
  {CC1101_TEST2,       0x81},
  {CC1101_TEST1,       0x35},
  {CC1101_MCSM1,       0x3B},*/
	 //2-FSK
  {CC1101_MCSM1,       0x3c},
  {CC1101_IOCFG2,      0x06},
  {CC1101_IOCFG0,      0x06},
  {CC1101_FIFOTHR,     0x47},
  {CC1101_PKTCTRL0,    0x05},
  {CC1101_CHANNR,      0x01},
  {CC1101_FSCTRL1,     0x06},
  {CC1101_FREQ2,       0x10},   //433.92
  {CC1101_FREQ1,       0xB0},
  {CC1101_FREQ0,       0x3f},
  {CC1101_MDMCFG4,     0xF6},
  {CC1101_MDMCFG3,     0x43},		//2.00224kBaud  58.035714khz
  {CC1101_MDMCFG2,     0x03},
  {CC1101_MDMCFG1,     0x20},
  {CC1101_MDMCFG0,     0x00},	
  {CC1101_DEVIATN,     0x15},   //0x15:5.157471khz 0x34:19khz, 0x77:380.85khz,0x64:152khz,0x71:228.5khz
  {CC1101_MCSM0,       0x18},
  {CC1101_FOCCFG,      0x16},
  {CC1101_WORCTRL,     0xFB},
  {CC1101_FSCAL3,      0xE9},
  {CC1101_FSCAL2,      0x2A},
  {CC1101_FSCAL1,      0x00},
  {CC1101_FSCAL0,      0x1F},
  {CC1101_TEST2,       0x81},
  {CC1101_TEST1,       0x35},
  {CC1101_TEST0,       0x09},	
};

uint8_t PaTabel[] = { 0xc0, 0xC8, 0x84, 0x60, 0x68, 0x34, 0x1D, 0x0E};//433M?table
//uint8_t PaTabel[] = { 0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x00};

/*read a byte from the specified register*/
uint8_t CC1101ReadStatus( uint8_t addr , SPI_HandleTypeDef *hspi);

/*Read some bytes from the rigisters continously*/
void CC1101ReadMultiReg( uint8_t addr, uint8_t *buff, uint8_t size , SPI_HandleTypeDef *hspi);

/*Write a byte to the specified register*/
void CC1101WriteReg( uint8_t addr, uint8_t value , SPI_HandleTypeDef *hspi);

/*Flush the TX buffer of CC1101*/
void CC1101ClrTXBuff( SPI_HandleTypeDef *hspi );

/*Flush the RX buffer of CC1101*/
void CC1101ClrRXBuff( SPI_HandleTypeDef *hspi );

/*Get received count of CC1101*/
uint8_t CC1101GetRXCnt( SPI_HandleTypeDef *hspi );

/*Reset the CC1101 device*/
void CC1101Reset( SPI_HandleTypeDef *hspi );

/*Write some bytes to the specified register*/
void CC1101WriteMultiReg( uint8_t addr, uint8_t *buff, uint8_t size , SPI_HandleTypeDef *hspi);

void CC1101WriteCmd( uint8_t command , SPI_HandleTypeDef *hspi);


/*
================================================================================
Function : CC1101WORInit( )
    Initialize the WOR function of CC1101
INPUT    : None
OUTPUT   : None
================================================================================
*/
void  CC1101WORInit(SPI_HandleTypeDef *hspi )
{

    CC1101WriteReg(CC1101_MCSM0,0x18,hspi);
    CC1101WriteReg(CC1101_WORCTRL,0x78,hspi); //Wake On Radio Control
    CC1101WriteReg(CC1101_MCSM2,0x00,hspi);
    CC1101WriteReg(CC1101_WOREVT1,0x8C,hspi);
    CC1101WriteReg(CC1101_WOREVT0,0xA0,hspi);
	
	CC1101WriteCmd( CC1101_SWORRST ,hspi);
}
/*
================================================================================
Function : CC1101ReadReg( )
    read a byte from the specified register
INPUT    : addr, The address of the register
OUTPUT   : the byte read from the rigister
================================================================================
*/
uint8_t CC1101ReadReg( uint8_t addr , SPI_HandleTypeDef *hspi)
{
	uint8_t input[1];
	uint8_t output[1];

	output[0] = addr | READ_SINGLE; //¶Á¼Ä´æÆ÷ÃüÁî
	CSN_reset;
	while (MISO);
	HAL_SPI_TransmitReceive(hspi, output, input, 1, 2000);
	HAL_SPI_Receive(hspi, input, 1, 2000);
	CSN_set;
	return input[0];
}
/*
================================================================================
Function : CC1101ReadMultiReg( )
    Read some bytes from the rigisters continously
INPUT    : addr, The address of the register
           buff, The buffer stores the data
           size, How many bytes should be read
OUTPUT   : None
================================================================================
*/
void CC1101ReadMultiReg( uint8_t addr, uint8_t *buff, uint8_t size , SPI_HandleTypeDef *hspi)
{
    uint8_t i, j;
	uint8_t input[1];
	uint8_t output[1];
    
	output[0] = addr | READ_BURST; //дÈëÒª¶ÁµÄÅäÖüĴæÆ÷µØÖ·ºÍ¶ÁÃüÁî
	CSN_reset; //CSN = 0;
	while (MISO);
    HAL_SPI_TransmitReceive(hspi, output, input, 1, 2000);
    for( i = 0; i < size; i ++ )
    {
		output[0] = buff[i];
        HAL_SPI_TransmitReceive(hspi, output, input, 1, 2000);
        buff[i] = input[0];
    }
    CSN_set;//CSN = 1;
}
/*
================================================================================
Function : CC1101ReadStatus( )
    Read a status register
INPUT    : addr, The address of the register
OUTPUT   : the value read from the status register
================================================================================
*/
uint8_t CC1101ReadStatus( uint8_t addr , SPI_HandleTypeDef *hspi)
{
	uint8_t input[1];
	uint8_t output[1];

	output[0] = addr | READ_BURST; //дÈëÒª¶ÁµÄ״̬¼Ä´æÆ÷µÄµØַͬʱдÈë¶ÁÃüÁî
	CSN_reset;
	while (MISO);
	HAL_SPI_TransmitReceive(hspi, output, input, 1, 2000);
	HAL_SPI_Receive(hspi, input, 1, 2000);
	CSN_set;
	return input[0];
}
/*
================================================================================
Function : CC1101SetTRMode( )
    Set the device as TX mode or RX mode
INPUT    : mode selection
OUTPUT   : None
================================================================================
*/
void CC1101SetTRMode( TRMODE mode , SPI_HandleTypeDef *hspi)
{
    if( mode == TX_MODE )
    {
        CC1101WriteReg(CC1101_IOCFG0,0x46,hspi);
        CC1101WriteCmd( CC1101_STX ,hspi);
    }
    else if( mode == RX_MODE )
    {
        CC1101WriteReg(CC1101_IOCFG0,0x46,hspi);
        CC1101WriteCmd( CC1101_SRX ,hspi);
    }
}
/*
================================================================================
Function : CC1101WriteReg( )
    Write a byte to the specified register
INPUT    : addr, The address of the register
           value, the byte you want to write
OUTPUT   : None
================================================================================
*/
void CC1101WriteReg( uint8_t addr, uint8_t value , SPI_HandleTypeDef *hspi)
{
	uint8_t input[1];
	uint8_t output[1];

	CSN_reset;
	while (MISO);
	output[0] = addr;
	HAL_SPI_TransmitReceive(hspi, output, input, 1, 2000); //дµØÖ·
	output[0] = value;
	HAL_SPI_TransmitReceive(hspi, output, input, 1, 2000); //дÈëÅäÖÃ
	CSN_set;
}
/*
================================================================================
Function : CC1101WriteMultiReg( )
    Write some bytes to the specified register
INPUT    : addr, The address of the register
           buff, a buffer stores the values
           size, How many byte should be written
OUTPUT   : None
================================================================================
*/
void CC1101WriteMultiReg( uint8_t addr, uint8_t *buff, uint8_t size , SPI_HandleTypeDef *hspi)
{
    uint8_t i, output[1], input[1];
	output[0] = addr | WRITE_BURST;
    CSN_reset; //CSN = 0;
	while (MISO);
    HAL_SPI_TransmitReceive(hspi, output, input, 1, 2000);
    for( i = 0; i < size; i ++ )
    {
        output[0] = buff[i];
		HAL_SPI_TransmitReceive(hspi, output, input, 1, 2000);
    }
    CSN_set;//CSN = 1;
}
/*
================================================================================
Function : CC1101WriteCmd( )
    Write a command byte to the device
INPUT    : command, the byte you want to write
OUTPUT   : None
================================================================================
*/
void CC1101WriteCmd( uint8_t command , SPI_HandleTypeDef *hspi)
{
	uint8_t input[1];
	uint8_t output[1];
	
    CSN_reset; //CSN = 0;
    while (MISO);
	output[0] = command;
	HAL_SPI_TransmitReceive(hspi, output, input, 1, 2000); дÈëÃüÁî
    CSN_set;//CSN = 1;
}
/*
================================================================================
Function : CC1101Reset( )
    Reset the CC1101 device
INPUT    : None
OUTPUT   : None
================================================================================
*/
void CC1101Reset( SPI_HandleTypeDef *hspi )
{
    uint8_t x;

    CSN_set;//CSN = 1;
    CSN_reset; //CSN = 0;
    CSN_set;//CSN = 1;
    for( x = 0; x < 100; x ++ );
    CC1101WriteCmd( CC1101_SRES ,hspi);
}
/*
================================================================================
Function : CC1101SetIdle( )
    Set the CC1101 into IDLE mode
INPUT    : None
OUTPUT   : None
================================================================================
*/
void CC1101SetIdle( SPI_HandleTypeDef *hspi )
{
    CC1101WriteCmd(CC1101_SIDLE,hspi);
}
/*
================================================================================
Function : CC1101ClrTXBuff( )
    Flush the TX buffer of CC1101
INPUT    : None
OUTPUT   : None
================================================================================
*/
void CC1101ClrTXBuff( SPI_HandleTypeDef *hspi )
{
    CC1101SetIdle(hspi);//MUST BE IDLE MODE
    CC1101WriteCmd( CC1101_SFTX ,hspi);
}
/*
================================================================================
Function : CC1101ClrRXBuff( )
    Flush the RX buffer of CC1101
INPUT    : None
OUTPUT   : None
================================================================================
*/
void CC1101ClrRXBuff( SPI_HandleTypeDef *hspi )
{
    CC1101SetIdle(hspi);//MUST BE IDLE MODE
    CC1101WriteCmd( CC1101_SFRX ,hspi);
}
/*
================================================================================
Function : CC1101SendPacket( )
    Send a packet
INPUT    : txbuffer, The buffer stores data to be sent
           size, How many bytes should be sent
           mode, Broadcast or address check packet
OUTPUT   : None
================================================================================
*/
void CC1101SendPacket( uint8_t *txbuffer, uint8_t size, TX_DATA_MODE mode ,SPI_HandleTypeDef *hspi)
{
    uint8_t address;
    if( mode == BROADCAST )             { address = 0; }
    else if( mode == ADDRESS_CHECK )    { address = CC1101ReadReg( CC1101_ADDR ,hspi); }

    CC1101ClrTXBuff( hspi);
    
    if( ( CC1101ReadReg( CC1101_PKTCTRL1 ,hspi) & ~0x03 ) != 0 )
    {
        CC1101WriteReg( CC1101_TXFIFO, size + 1 ,hspi);
        CC1101WriteReg( CC1101_TXFIFO, address ,hspi);
    }
    else
    {
        CC1101WriteReg( CC1101_TXFIFO, size ,hspi);
    }

    CC1101WriteMultiReg( CC1101_TXFIFO, txbuffer, size ,hspi);
    CC1101SetTRMode( TX_MODE ,hspi);
    while( GDO0 != 0 );
    while( GDO0 == 0 );

    CC1101ClrTXBuff( hspi);
}
/*
================================================================================
Function : CC1101GetRXCnt( )
    Get received count of CC1101
INPUT    : None
OUTPUT   : How many bytes hae been received
================================================================================
*/
uint8_t CC1101GetRXCnt( SPI_HandleTypeDef *hspi )
{
    return ( CC1101ReadStatus( CC1101_RXBYTES ,hspi)  & BYTES_IN_RXFIFO );
}
/*
================================================================================
Function : CC1101SetAddress( )
    Set the address and address mode of the CC1101
INPUT    : address, The address byte
           AddressMode, the address check mode
OUTPUT   : None
================================================================================
*/
void CC1101SetAddress( uint8_t address, ADDR_MODE AddressMode,SPI_HandleTypeDef *hspi)
{
    uint8_t btmp = CC1101ReadReg( CC1101_PKTCTRL1 ,hspi) & ~0x03;
    CC1101WriteReg(CC1101_ADDR, address,hspi);
    if     ( AddressMode == BROAD_ALL )     {}
    else if( AddressMode == BROAD_NO  )     { btmp |= 0x01; }
    else if( AddressMode == BROAD_0   )     { btmp |= 0x02; }
    else if( AddressMode == BROAD_0AND255 ) { btmp |= 0x03; }   
}
/*
================================================================================
Function : CC1101SetSYNC( )
    Set the SYNC bytes of the CC1101
INPUT    : sync, 16bit sync 
OUTPUT   : None
================================================================================
*/
void CC1101SetSYNC( uint16_t sync ,SPI_HandleTypeDef *hspi)
{
    CC1101WriteReg(CC1101_SYNC1, 0xFF & ( sync>>8 ) ,hspi);
    CC1101WriteReg(CC1101_SYNC0, 0xFF & sync ,hspi); 
}
/*
================================================================================
Function : CC1101RecPacket( )
    Receive a packet
INPUT    : rxBuffer, A buffer store the received data
OUTPUT   : 1:received count, 0:no data
================================================================================
*/
uint8_t CC1101RecPacket( uint8_t *rxBuffer ,SPI_HandleTypeDef *hspi)
{
    uint8_t status[2];
    uint8_t pktLen;
    uint16_t x;

    if ( CC1101GetRXCnt( hspi) != 0 )
    {
        pktLen = CC1101ReadReg(CC1101_RXFIFO,hspi);           // Read length byte
        if( ( CC1101ReadReg( CC1101_PKTCTRL1 ,hspi) & ~0x03 ) != 0 )
        {
            x = CC1101ReadReg(CC1101_RXFIFO,hspi);
        }
        if( pktLen == 0 )           { return 0; }
        else                        { pktLen --; }
        CC1101ReadMultiReg(CC1101_RXFIFO, rxBuffer, pktLen,hspi); // Pull data
        CC1101ReadMultiReg(CC1101_RXFIFO, status, 2,hspi);   // Read  status bytes

        CC1101ClrRXBuff(hspi );

        if( status[1] & CRC_OK ) {   return pktLen; }
        else                     {   return 0; }
		
		
    }
    else   {  return 0; }                               // Error
}
/*
================================================================================
Function : CC1101Init( )
    Initialize the CC1101, User can modify it
INPUT    : None
OUTPUT   : None
================================================================================
*/
void CC1101Init( SPI_HandleTypeDef *hspi )
{
    volatile uint8_t i, j;

    CC1101Reset(hspi );    
    
    for( i = 0; i < 24; i++ )
    {
        CC1101WriteReg( CC1101InitData[i][0], CC1101InitData[i][1] ,hspi);
    }
    CC1101SetAddress( 0x05, BROAD_0AND255 ,hspi);
    CC1101SetSYNC( 0x8799 ,hspi);
    CC1101WriteReg(CC1101_MDMCFG1,   0x72,hspi); //Modem Configuration

    CC1101WriteMultiReg(CC1101_PATABLE, PaTabel, 8 ,hspi);
		//CC1101WriteReg(CC1101_FREND0,0x40);
    i = CC1101ReadStatus( CC1101_PARTNUM ,hspi);//for test, must be 0x80
    i = CC1101ReadStatus( CC1101_VERSION ,hspi);//for test, refer to the datasheet
		CC1101WriteReg(CC1101_TEST1,0xaa,hspi);
		i=CC1101ReadStatus(CC1101_TEST1,hspi);

    i=0;
}

cc1101.h:

#ifndef __CC1101_H
#define __CC1101_H
#include "main.h"
#include "gpio.h"
//#include "delay.h"


/* define  ********************************************************************/
//#define   CSN   PAout(4) 
#define   CSN_set    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET)	  // оƬѡÔñ	Serial configuration interface, chip
#define   CSN_reset    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET)	  // оƬѡÔñ	Serial configuration interface, chip select (MCU output)	 
#define   GDO0   HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1)	  // cc1101µÄͨÓÃÊä³ö Digital output pin for general use          (MCU input)
#define   MISO   HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_6)	    // cc1101µÄÊý¾ÝÊä³ö Serial configuration interface,data output  (MCU input)
typedef enum {false,true}bool;
/*   **********************************************************************/
typedef enum { TX_MODE, RX_MODE }TRMODE;
typedef enum { BROAD_ALL, BROAD_NO, BROAD_0, BROAD_0AND255 }ADDR_MODE;
typedef enum { BROADCAST, ADDRESS_CHECK} TX_DATA_MODE;

extern uint8_t Rx_Flag;

/* ??  **********************************************************************/

/*read a byte from the specified register*/
uint8_t CC1101ReadReg( uint8_t addr , SPI_HandleTypeDef *hspi);

/*Read a status register*/
uint8_t CC1101ReadStatus( uint8_t addr , SPI_HandleTypeDef *hspi);

/*Set the device as TX mode or RX mode*/
void CC1101SetTRMode( TRMODE mode , SPI_HandleTypeDef *hspi);

/*Write a command byte to the device*/
void CC1101WriteCmd( uint8_t command , SPI_HandleTypeDef *hspi);

/*Set the CC1101 into IDLE mode*/
void CC1101SetIdle( SPI_HandleTypeDef *hspi );

/*Send a packet*/
void CC1101SendPacket( uint8_t *txbuffer, uint8_t size, TX_DATA_MODE mode ,SPI_HandleTypeDef *hspi);

/*Set the address and address mode of the CC1101*/
void CC1101SetAddress( uint8_t address, ADDR_MODE AddressMode,SPI_HandleTypeDef *hspi);

/*Set the SYNC bytes of the CC1101*/
void CC1101SetSYNC( uint16_t sync ,SPI_HandleTypeDef *hspi);

/*Receive a packet*/
uint8_t CC1101RecPacket( uint8_t *rxBuffer ,SPI_HandleTypeDef *hspi);

/*Initialize the WOR function of CC1101*/
void  CC1101WORInit(SPI_HandleTypeDef *hspi );

/*Initialize the CC1101, User can modify it*/
void CC1101Init( SPI_HandleTypeDef *hspi );

void CC1101Reset( SPI_HandleTypeDef *hspi );

//*****************************************************************************************
// CC1100 STROBE, CONTROL AND STATUS REGSITER
#define CC1101_IOCFG2       0x00        // GDO2 output pin configuration
#define CC1101_IOCFG1       0x01        // GDO1 output pin configuration
#define CC1101_IOCFG0       0x02        // GDO0 output pin configuration
#define CC1101_FIFOTHR      0x03        // RX FIFO and TX FIFO thresholds
#define CC1101_SYNC1        0x04        // Sync word, high u8
#define CC1101_SYNC0        0x05        // Sync word, low u8
#define CC1101_PKTLEN       0x06        // Packet length
#define CC1101_PKTCTRL1     0x07        // Packet automation control
#define CC1101_PKTCTRL0     0x08        // Packet automation control
#define CC1101_ADDR         0x09        // Device address
#define CC1101_CHANNR       0x0A        // Channel number
#define CC1101_FSCTRL1      0x0B        // Frequency synthesizer control
#define CC1101_FSCTRL0      0x0C        // Frequency synthesizer control
#define CC1101_FREQ2        0x0D        // Frequency control word, high u8
#define CC1101_FREQ1        0x0E        // Frequency control word, middle u8
#define CC1101_FREQ0        0x0F        // Frequency control word, low u8
#define CC1101_MDMCFG4      0x10        // Modem configuration
#define CC1101_MDMCFG3      0x11        // Modem configuration
#define CC1101_MDMCFG2      0x12        // Modem configuration
#define CC1101_MDMCFG1      0x13        // Modem configuration
#define CC1101_MDMCFG0      0x14        // Modem configuration
#define CC1101_DEVIATN      0x15        // Modem deviation setting
#define CC1101_MCSM2        0x16        // Main Radio Control State Machine configuration
#define CC1101_MCSM1        0x17        // Main Radio Control State Machine configuration
#define CC1101_MCSM0        0x18        // Main Radio Control State Machine configuration
#define CC1101_FOCCFG       0x19        // Frequency Offset Compensation configuration
#define CC1101_BSCFG        0x1A        // Bit Synchronization configuration
#define CC1101_AGCCTRL2     0x1B        // AGC control
#define CC1101_AGCCTRL1     0x1C        // AGC control
#define CC1101_AGCCTRL0     0x1D        // AGC control
#define CC1101_WOREVT1      0x1E        // High u8 Event 0 timeout
#define CC1101_WOREVT0      0x1F        // Low u8 Event 0 timeout
#define CC1101_WORCTRL      0x20        // Wake On Radio control
#define CC1101_FREND1       0x21        // Front end RX configuration
#define CC1101_FREND0       0x22        // Front end TX configuration
#define CC1101_FSCAL3       0x23        // Frequency synthesizer calibration
#define CC1101_FSCAL2       0x24        // Frequency synthesizer calibration
#define CC1101_FSCAL1       0x25        // Frequency synthesizer calibration
#define CC1101_FSCAL0       0x26        // Frequency synthesizer calibration
#define CC1101_RCCTRL1      0x27        // RC oscillator configuration
#define CC1101_RCCTRL0      0x28        // RC oscillator configuration
#define CC1101_FSTEST       0x29        // Frequency synthesizer calibration control
#define CC1101_PTEST        0x2A        // Production test
#define CC1101_AGCTEST      0x2B        // AGC test
#define CC1101_TEST2        0x2C        // Various test settings
#define CC1101_TEST1        0x2D        // Various test settings
#define CC1101_TEST0        0x2E        // Various test settings

// Strobe commands
#define CC1101_SRES         0x30        // Reset chip.
#define CC1101_SFSTXON      0x31        // Enable and calibrate frequency synthesizer (if MCSM0.FS_AUTOCAL=1).
                                        // If in RX/TX: Go to a wait state where only the synthesizer is
                                        // running (for quick RX / TX turnaround).
#define CC1101_SXOFF        0x32        // Turn off crystal oscillator.
#define CC1101_SCAL         0x33        // Calibrate frequency synthesizer and turn it off
                                        // (enables quick start).
#define CC1101_SRX          0x34        // Enable RX. Perform calibration first if coming from IDLE and
                                        // MCSM0.FS_AUTOCAL=1.
#define CC1101_STX          0x35        // In IDLE state: Enable TX. Perform calibration first if
                                        // MCSM0.FS_AUTOCAL=1. If in RX state and CCA is enabled:
                                        // Only go to TX if channel is clear.
#define CC1101_SIDLE        0x36        // Exit RX / TX, turn off frequency synthesizer and exit
                                        // Wake-On-Radio mode if applicable.
#define CC1101_SAFC         0x37        // Perform AFC adjustment of the frequency synthesizer
#define CC1101_SWOR         0x38        // Start automatic RX polling sequence (Wake-on-Radio)
#define CC1101_SPWD         0x39        // Enter power down mode when CSn goes high.
#define CC1101_SFRX         0x3A        // Flush the RX FIFO buffer.
#define CC1101_SFTX         0x3B        // Flush the TX FIFO buffer.
#define CC1101_SWORRST      0x3C        // Reset real time clock.
#define CC1101_SNOP         0x3D        // No operation. May be used to pad strobe commands to two
                                        // u8s for simpler software.

#define CC1101_PARTNUM      0x30
#define CC1101_VERSION      0x31
#define CC1101_FREQEST      0x32
#define CC1101_LQI          0x33
#define CC1101_RSSI         0x34
#define CC1101_MARCSTATE    0x35
#define CC1101_WORTIME1     0x36
#define CC1101_WORTIME0     0x37
#define CC1101_PKTSTATUS    0x38
#define CC1101_VCO_VC_DAC   0x39
#define CC1101_TXBYTES      0x3A
#define CC1101_RXBYTES      0x3B

#define CC1101_PATABLE      0x3E
#define CC1101_TXFIFO       0x3F
#define CC1101_RXFIFO       0x3F

#define WRITE_BURST     	0x40						//????
#define READ_SINGLE     	0x80						//?
#define READ_BURST      	0xC0						//???
#define BYTES_IN_RXFIFO     0x7F  						//???????????
#define CRC_OK              0x80 						//CRC???????



#endif

参考文档：

stm32f103c8 使用cc1101模块_fghjhuangdavid的博客-CSDN博客icon-default.png?t=LA46https://blog.csdn.net/fghjhuangdavid/article/details/102461437

标签：接收,uint8,stm32,SPI,HandleTypeDef,CC1101,cc1101,hspi,define
来源： https://blog.csdn.net/qq_40708778/article/details/121215927

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有