[参考译文] CC1101：STM32CubeMX IDE 中存在 STM32 SPI 错误

Other Parts Discussed in Thread: CC1101, CC1100

https://e2e.ti.com/support/wireless-connectivity/sub-1-ghz-group/sub-1-ghz/f/sub-1-ghz-forum/886066/cc1101-stm32-spi-error-in-stm32cubemx-ide

器件型号：CC1101
主题中讨论的其他器件： CC1100

您好！  

我在 STM32CubeMX IDE 上使用的是 STM32L432KC 与 CC1101 (433MHz)。当我读取状态寄存器时，始终得到0xF。 为什么我得到它？ 我在哪里出错了？ 我有问题。 请帮我解决这个问题、我正在工作2周、但我无法解决。

这是我的代码：

rf_driver.h

/*
* rf_driver.h
*
*创建日期：2020年2月6日
*作者：suleyman.eskil
*

#ifndef INC_RF_DRIVER_H_
#define INC_RF_DRIVER_H_

#include
#ifndef __STM32L4xx_HAL_H
#include "stm32l4xx_hal.h"
#endif
#include "dw_STM32_delay.h"

/**引脚分配------------------------------------------------------- /
* VDD --> 3.3V
* GND --> GND
* CS --> PD14
* MOSI --> PA7
* MISO --> PA6
* SCK --> PA5
* GDO0 -> PD15 // PD5 (UART2 TX)
* GDO2 -> PF12 // PA3 (UART2 RX)
*

/*私人定义------------------------------------------------------- *

#define true 1.
#define false 0

/*------------------ [数据]------------------------------------------ *
#define FIFO_SIZE 64 // TX 和 RX FIFO 缓冲区的大小
#define fixed_length_limit 255 //对于长度大于255的数据包，必须使用无限数据包长度模式
#define DATA_TUNK_SIZE 32 //数据以32个块的块从缓冲区中读取并写入缓冲区
#define buffer_size (1<<16)//将其更改为能够接收更长(或更短)的帧。 GET_FRAME_LENGTH 也应修改。

/*------------------ [CC1100 - R/W 偏移]----- *
#define WRITE (ADDR) ADDR
#define WRITE_BURST (ADDR) ADDR | 0x40
#define READ (ADDR) ADDR | 0x80
#define READ_BURST (ADDR) ADDR | 0xC0
#define CRC_OK 0x80
#define RSSI_OFFSET 0x4A
/*------------------ [结束 R/W 偏移]--------------- *

/*---------------- [CC1100 - FIFO 命令]----- *

/*不使用写入/读取和突发偏移来指出 TX 和 RX 即使具有"相同"地址也是2个不同的缓冲区。
TXFIFO 不是写入 WRITE (FIFO)、而是写入 TXFIFO
*
#define TXFIFO_BURST 0x7F //仅突发写入
#define TXFIFO 0x3F //只写单个
#define RXFIFO_BURST 0xFF //只读突发
#define RXFIFO 0xBF //只读单个

#define PATABLE_BURST 0x7E //功率控制读取/写入
#define PATABLE_SINGLE_BYTE 0xFE //功率控制读取/写入
/*------------------ [结束 FIFO 命令]----- *

/*-------------- [CC1100 -配置寄存器]----- *

#define IOCFG2_W 0x00
#define IOCFG2_WB 0x40
#define IOCFG2_R 0x80
#define IOCFG2_RB 0xC0

#define IOCFG1_W 0x01
#define IOCFG1_WB 0x41
#define IOCFG1_R 0x81
#define IOCFG1_RB 0xC1 // GDO1输出引脚配置

#define IOCFG0_W 0x02
#define IOCFG0_WB 0x42
#define IOCFG0_R 0x82
#define IOCFG0_RB 0xC2 // GDO0输出引脚配置

#define FIFOTHR_W 0x03
#define FIFOTHR_WB 0x43
#define FIFOTHR_R 0x83
#define FIFOTHR_RB 0xC3 // RX FIFO 和 TX FIFO 阈值

#define SYNC1_W 0x04
#define SYNC1_WB 0x44
#define SYNC1_R 0x84
#define SYNC1_RB 0xC4 //同步字、高字节

#define SYNC0_W 0x05
#define SYNC0_WB 0x45
#define SYNC0_R 0x85
#define SYNC0_RB 0xC5 //同步字、低字节

#define PKTLEN_W 0x06
#define PKTLEN_WB 0x46
#define PKTLEN_R 0x86
#define PKTLEN_RB 0xC6 //数据包长度

#define PKTCTRL1_W 0x07
#define PKTCTRL1_WB 0x47
#define PKTCTRL1_R 0x87
#define PKTCTRL1_RB 0xC7 //数据包自动化控制

#define PKTCTRL0_W 0x08
#define PKTCTRL0_WB 0x48
#define PKTCTRL0_R 0x88
#define PKTCTRL0_RB 0xC8 //数据包自动化控制

#define ADDR_W 0x09
#define ADDR_WB 0x49
#define ADDR_R 0x89
#define ADDR_RB 0xC9 //器件地址

#define CHANNR_W 0x0A
#define CHANNR_WB 0x4A
#define CHANNR_R 0x8A
#define CHANNR_RB 0xCA //通道编号

#define FSCTRL1_W 0x0B
#define FSCTRL1_WB 0x4B
#define FSCTRL1_R 0x8B
#define FSCTRL1_RB 0xCB //频率合成器控制

#define FSCTRL0_W 0x0C
#define FSCTRL0_WB 0x4C
#define FSCTRL0_R 0x8C
#define FSCTRL0_RB 0xCC //频率合成器控制

#define FREQ2_W 0x0D
#define FREQ2_WB 0x4D
#define FREQ2_R 0x8D
#define FREQ2_RB 0xCD //频率控制字、高字节

#define FREQ1_W 0x0E
#define FREQ1_WB 0x4E
#define FREQ1_R 0x8E
#define FREQ1_RB 0xCE //频率控制字、中间字节

#define FREQ0_W 0x0F
#define FREQ0_WB 0x4F
#define FREQ0_R 0x8F
#define FREQ0_RB 0xCF //频率控制字、低字节

#define MDMCFG4_W 0x10
#define MDMCFG4_WB 0x50
#define MDMCFG4_R 0x90
#define MDMCFG4_RB 0xD0 //调制解调器配置

#define MDMCFG3_W 0x11
#define MDMCFG3_WB 0x51
#define MDMCFG3_R 0x91
#define MDMCFG3_RB 0xD1 //调制解调器配置

#define MDMCFG2_W 0x12
#define MDMCFG2_WB 0x52
#define MDMCFG2_R 0x92
#define MDMCFG2_RB 0xD2 //调制解调器配置

#define MDMCFG1_W 0x13
#define MDMCFG1_WB 0x53
#define MDMCFG1_R 0x93
#define MDMCFG1_RB 0xD3 //调制解调器配置

#define MDMCFG0_W 0x14
#define MDMCFG0_WB 0x54
#define MDMCFG0_R 0x94
#define MDMCFG0_RB 0xD4 //调制解调器配置

#define DEVIATN_W 0x15
#define DEVIATN_WB 0x55
#define DEVIATN_R 0x95
#define DEVIATN_RB 0xD5 //调制解调器偏差设置

#define MCSM2_W 0x16
#define MCSM2_WB 0x56
#define MCSM2_R 0x96
#define MCSM2_RB 0xD6 //主对讲机控制状态机配置

#define MCSM1_W 0x17
#define MCSM1_WB 0x57
#define MCSM1_R 0x97
#define MCSM1_RB 0xD7 //主对讲机控制状态机配置

#define MCSM0_W 0x18
#define MCSM0_WB 0x58
#define MCSM0_R 0x98
#define MCSM0_RB 0xD8 //主对讲机控制状态机配置

#define FOCCFG_W 0x19
#define FOCCFG_WB 0x59
#define FOCCFG_R 0x99
#define FOCCFG_RB 0xD9 //频率偏移补偿配置

#define BSCFG_W 0x1A
#define BSCFG_WB 0x5A
#define BSCFG_R 0x9A
#define BSCFG_RB 0xDA //位同步配置

#define AGCCTRL2_W 0x1B
#define AGCCTRL2_WB 0x5B
#define AGCCTRL2_R 0x9B
#define AGCCTRL2_RB 0xDB // AGC 控制

#define AGCCTRL1_W 0x1C
#define AGCCTRL1_WB 0x5C
#define AGCCTRL1_R 0x9C
#define AGCCTRL1_RB 0xDC // AGC 控制

#define AGCCTRL0_W 0x1D
#define AGCCTRL0_WB 0x5D
#define AGCCTRL0_R 0x9D
#define AGCCTRL0_RB 0xDD // AGC 控制

#define WOREVT1_W 0x1E
#define WOREVT1_WB 0x5E
#define WOREVT1_R 0x9E
#define WOREVT1_RB 0xDE //高字节事件0超时

#define WOREVT0_W 0x1F
#define WOREVT0_WB 0x5F
#define WOREVT0_R 0x9F
#define WOREVT0_RB 0xDF //低字节事件0超时

#define WORCTRL_W 0x20
#define WORCTRL_WB 0x60
#define WORCTRL_R 0xA0
#define WORCTRL_RB 0xE0 //无线唤醒控制

#define FREND1_W 0x21
#define FREND1_WB 0x61
#define FREND1_R 0xA1
#define FREND1_RB 0xE1 //前端 RX 配置

#define FREND0_W 0x22
#define FREND0_WB 0x62
#define FREND0_R 0xA2
#define FREND0_RB 0xE2 //前端 TX 配置

#define FSCAL3_W 0x23
#define FSCAL3_WB 0x63
#define FSCAL3_R 0xA3
#define FSCAL3_RB 0xE3 //频率合成器校准

#define FSCAL2_W 0x24
#define FSCAL2_WB 0x64
#define FSCAL2_R 0xA4
#define FSCAL2_RB 0xE4 //频率合成器校准

#define FSCAL1_W 0x25
#define FSCAL1_WB 0x65
#define FSCAL1_R 0xA5
#define FSCAL1_RB 0xE5 //频率合成器校准

#define FSCAL0_W 0x26
#define FSCAL0_WB 0x66
#define FSCAL0_R 0xA6
#define FSCAL0_RB 0xE6 //频率合成器校准

#define RCCTRL1_W 0x27
#define RCCTRL1_WB 0x67
#define RCCTRL1_R 0xA7
#define RCCTRL1_RB 0xE7 // RC 振荡器配置

#define RCCTRL0_W 0x28
#define RCCTRL0_WB 0x68
#define RCCTRL0_R 0xA8
#define RCCTRL0_RB 0xE8 // RC 振荡器配置

#define FSTEST_W 0x29
#define FSTEST_WB 0x69
#define FSTEST_R 0xA9
#define FSTEST_RB 0xE9 //频率合成器校准控制

#define Ptest_W 0x2A
#define Ptest_WB 0x6A
#define ptest_R 0xAA
#define ptest_rB 0xEA //生产测试

#define AGCTEST_W 0x2B
#define AGCTEST_WB 0x6B
#define AGCTEST_R 0xAB
#define AGCTEST_RB 0xEB // AGC 测试

#define TEST2_W 0x2C
#define TEST2_WB 0x6C
#define TEST2_R 0xAC
#define TEST2_RB 0xEC //各种测试设置

#define TEST1_W 0x2D
#define TEST1_WB 0x6D
#define TEST1_R 0xAD
#define TEST1_RB 0xED //各种测试设置

#define TEST0_W 0x2E
#define TEST0_WB 0x6E
#define TEST0_R 0xAE
#define TEST0_RB 0xEE //各种测试设置

/*
#define IOCFG2 0x00
#define IOCFG1 0x01 // GDO1输出引脚配置
#define IOCFG0 0x02 // GDO0输出引脚配置
#define FIFOTHR 0x03 // RX FIFO 和 TX FIFO 阈值
#define SYNC1 0x04 //同步字、高字节
#define SYNC0 0x05 //同步字、低字节
#define PKTLEN 0x06 //数据包长度
#define PKTCTRL1 0x07 //数据包自动化控制
#define PKTCTRL0 0x08 //数据包自动化控制
#define ADDR 0x09 //器件地址
#define CHANNR 0x0A //通道编号
#define FSCTRL1 0x0B //频率合成器控制
#define FSCTRL0 0x0C //频率合成器控制
#define FREQ2 0x0D //频率控制字、高字节
#define FREQ1 0x0E //频率控制字、中间字节
#define FREQ0 0x0F //频率控制字、低字节
#define MDMCFG4 0x10 //调制解调器配置
#define MDMCFG3 0x11 //调制解调器配置
#define MDMCFG2 0x12 //调制解调器配置
#define MDMCFG1 0x13 //调制解调器配置
#define MDMCFG0 0x14 //调制解调器配置
#define DEVIATN 0x15 //调制解调器偏差设置
#define MCSM2 0x16 //主对讲机控制状态机配置
#define MCSM1 0x17 //主对讲机控制状态机配置
#define MCSM0 0x18 //主对讲机控制状态机配置
#define FOCCFG 0x19 //频率偏移补偿配置
#define BSCFG 0x1A //位同步配置
#define AGCCTRL2 0x1B // AGC 控制
#define AGCCTRL1 0x1C // AGC 控制
#define AGCCTRL0 0x1D // AGC 控制
#define WOREVT1 0x1E //高字节事件0超时
#define WOREVT0 0x1F //低字节事件0超时
#define WORCTRL 0x20 //无线唤醒控制
#define FREND1 0x21 //前端 RX 配置
#define FREND0 0x22 //前端 TX 配置
#define FSCAL3 0x23 //频率合成器校准
#define FSCAL2 0x24 //频率合成器校准
#define FSCAL1 0x25 //频率合成器校准
#define FSCAL0 0x26 //频率合成器校准
#define RCCTRL1 0x27 // RC 振荡器配置
#define RCCTRL0 0x28 // RC 振荡器配置
#define FSTEST 0x29 //频率合成器校准控制
#define Ptest 0x2A //生产测试
#define AGCTEST 0x2B // AGC 测试
#define TEST2 0x2C //各种测试设置
#define TEST1 0x2D //各种测试设置
#define TEST0 0x2E //各种测试设置
*

/*---------------- [结束配置寄存器]----- *

/*---------------- [CC1100-命令选通]----------------- *

#define SRES_W 0x30
#define SRES_R 0xB0 //复位芯片
#define SFSTXON_W 0x31
#define SFSTXON_R 0xB1 //启用
#define SXOFF_W 0x32
#define SXOFF_R 0xB2 //关闭晶体振荡器。
#define SCAL_W 0x33
#define SCAL_R 0xB3 //校准频率合成器和禁用
#define SRX_W 0x34
#define SRX_R 0xB4 //启用 RX。
#define STX_W 0x35
#define STX_R 0xB5 //启用 TX。
#define sidle_W 0x36
#define sidle_R 0xB6 //退出 RX
#define SWOR_W 0x38
#define SWOR_R 0xB8 //开始自动 RX 轮询序列
#define SPWD_W 0x39
#define SPWD_R 0xB9 //在 CSn 变为高电平时进入断电模式
#define SFRX_W 0x3A
#define SFRX_R 0xBA //刷新 RX FIFO 缓冲区。
#define SFTX_W 0x3B
#define SFTX_R 0xBB //刷新 TX FIFO 缓冲区。
#define SWORRST_W 0x3C
#define SWORRST_R 0xBC //重置实时时钟。
#define SNOP_W 0x3D
#define SNOP_R 0xBD //无操作。

/*#define SRES 0x30 //复位芯片
#define SFSTXON 0x31 //启用/校准频率合成器
#define SXOFF 0x32 //关闭晶体振荡器。
#define SCAL 0x33 //校准频率合成器和禁用
#define SRX 0x34 //启用 RX。
#define STX 0x35 //启用 TX。
#define sidle 0x36 //退出 RX/TX
#define SAFC 0x37 // f频率 合成器的 AFC 调整//数据表 böyle bir 寄存器 yok
#define SWOR 0x38 //开始自动 RX 轮询序列
#define SPWD 0x39 //在 CSn 变为高电平时进入断电模式
#define SFRX 0x3A //刷新 RX FIFO 缓冲区。
#define SFTX 0x3B //刷新 TX FIFO 缓冲区。
#define SWORRST 0x3C //重置实时时钟。
#define SNOP 0x3D //无操作。*/
/*---------------- [结束命令选通]----------------- *

/*-------------- [CC1100 -状态寄存器]----- *

#define PARTNUM_R 0xF0 //器件型号
#define VERSION_R 0xF1 //当前版本号
#define FREQEST_R 0xF2 //频率偏移估算
#define LQI_R 0xF3 //解调器估算链路质量
#define RSSI_R 0xF4 //接收信号强度指示
#define MARCSTATE_R 0xf5 //控制状态机状态
#define WORTIME1_R 0xF6 // WOR 计时器的高字节
#define WORTIME0_R 0xF7 // WOR 计时器的低字节
#define PKTSTATUS_R 0xf8 //当前 GDOx 状态和数据包状态
#define VCO_VC_DAC_R 0xF9 // PLL 校准模块的电流设置
#define TXBYTES_R 0xFA //下溢和 TXFIFO 中的字节数
#define RXBYTES_R 0xFB //溢出和 RXFIFO 中的字节数
#define RCCTRL1_STATUS_R 0xFC //最后一个 RC 振荡器校准结果
#define RCCTRL0_STATUS_R 0xFD //最后一个 RC 振荡器校准结果

/*#定义 PARTNUM 0xF0 //器件型号
#define 版本0xF1 //当前版本号
#define FREQEST 0xF2 //频率偏移估算
#define LQI 0xF3 //解调器估算链接质量
#define RSSI 0xF4 //接收信号强度指示
#define MARCSTATE 0xf5 //控制状态机状态
#define WORTIME1 0xF6 // WOR 计时器的高字节
#define WORTIME0 0xF7 // WOR 计时器的低字节
#define PKTSTATUS 0xf8 //当前 GDOx 状态和数据包状态
#define VCO_VC_DAC 0xF9 // PLL 校准模块的电流设置
#define TXBYTES 0xFA //下溢和 TXFIFO 中的字节数
#define RXBYTES 0xFB //溢出和 RXFIFO 中的字节数
#define RCCTRL1_STATUS 0xFC //最后一个 RC 振荡器校准结果
#define RCCTRL0_STATUS 0xFD //最后一个 RC 振荡器校准结果*/

///------------------ [结束状态寄存器]-----

/*-------------- [CC1100 -杂项]----------------- *
#define crystal_frequency 26000
#define crystal_frequency _M crystal_frequency /1000
#define CFG_register 0x2F //47寄存器
#define MAX_CHANNEL SPACING (0xFF+256)* crystal_frequency *(1<<3)/(1<<18)
#define MIN_CHANNEL SPACING (0x0+256)* CRYSTICL_FREQUENCY /(1<<18)//最小值可能、但最小合法值？

#define RSSI_OFFSET_868MHz 0x4E //解码= 74
#define TX_RETESS_MAX 0x05 //TX_RETESS_max
#define ACK_TIMEOUT 200 // ACK TIMEOUT、单位为 ms
#define CC1100_COMPARE_register 0x00 //寄存器比较0=无比较1=比较
//#define broadcast_address 0x00 //广播地址
//#define CC1100_FREQ_315MHZ 0x01
//#define CC1100_FREQ_434MHZ 0x02
//#define CC1100_FREQ_868MHz 0x03
//#define CC1100_FREQ_915MHz 0x04
//#define CC1100_FREQ_2430MHZ 0x05
#define CC1100_TEMP_ADC_MV 3.225 //3.3V/1023。 MV 专业数字
#define CC1100_TEMP_CELS_CO 2.47 //温度系数2.47mV (每摄氏度)

/*私人 typedef ------------------------------------------------------- *
typedef 枚举｛
//sleep = 0x00、//无法访问
IDLE = 0x01、
//XOFF = 0x02、
VCOON_MC = 0x03、//MANCAL
REGON_MC = 0x04、//MANCAL
MANCAL = 0x05、
VCOON = 0x06、//FS_WAKEUP
REGON = 0x07、//FS_WAKEUP
STARTCAL = 0x08、//校准
BWBOOST = 0x09、//SETTLIG
FS_LOCK = 0x0A、//SETTLIG
IFADCON = 0x0B、//SETTLIG
ENDCAL = 0x0C、//校准
RX = 0x0D、
RX_END = 0x0E、//RX
RX_RST = 0x0F、//RX
TXRX_SWITCH = 0x10、//TXRX_Settling
RXFIFO_OVERflow = 0x11、
FSTXON = 0x12、
TX = 0x13、
TX_END = 0x14、//TX
RxTx_switch = 0x15、//RxTx_Settling
TXFIFO_欠 流= 0x16
}状态 typedef；

typedef 枚举｛
GFSK_1_2_KB = 1、
GFSK_38_4_KB、
GFSK_100_KB、
MSK_250_KB、
MSK_500_KB、
OK_4_8_KB
}调制 typedef；

typedef 枚举｛
MHz315 = 1、
MHz434、
MHz868、
MHz915、
}ISMBAND_typedef；

typedef 枚举｛
超时=-1、
FRAME_BAD = 0、接收时//CRC 错误
FRAME_OK = 1、接收时为//CRC OK、发送时为帧传输
}FRAMESTATUS_typedef；

/*私有函数原型------------------------------------------------------- *

/* SPI 数据流--- *
void rf_spi_write (uint8_t reg、uint8_t data)；
uint8_t rf_spi_read (uint8_t reg)；
void rf_spi_read_data (uint8_t addr、uint8_t*数据、uint8_t 大小)；
void rf_spi_write_data (uint8_t addr、uint8_t* data、uint8_t size)；
void rf_spi_write_strobe (uint8_t strobe)；

void rf_write_strobe (uint8_t strobe)；
uint8_t rf_read_register (uint8_t reg)；
void rf_write_register (uint8_t reg、uint8_t data)；
void rf_read_data (uint8_t addr、uint8_t*数据、uint8_t 大小)；
void rf_write_data (uint8_t addr、uint8_t* data、uint8_t size)；
HAL_StatusTypeDef __SPI_WRITE (uint8_t* addr、uint8_t *pData、uint16_t size)；
HAL_StatusTypeDef __SPI_read (uint8_t* addr、uint8_t *pData、uint16_t size)；

/*驱动程序初始化------------------------------------------------------- *
uint8_t rf_check()；
void rf_reset ()；
void Power_up_reset ()；

uint8_t rf_begin (SPI_HandleTypeDef* hspi、model_typedef 模式、ISMBAND_typedef ISM_band、GPIO_typedef* cs_port、uint16_t cs_pin、 uint16_t gdo0_pin)；

/*驱动程序配置--- *
void rf_set_model_mode (model_typedef mod)；
void rf_set_ismband (ismBAND_typedef 频段)；
void rf_set_channel (uint8_t channel)；
void rf_set_output_power_level (INT8_t)；
void rf_set_syncword (uint16_t syncword)；
//数据包控制
void rf_set_addr (uint8_t addr)；
//FSCTRL1–频率合成器控制？
float rf_set_carrier_offset (float offset)；
float rf_set_carrier_frequency (float target_freq)；
float rf_set_channel_spacing (float cpsacing)；
void rf_set_帧 头(uint8_t nbytes)；
void rf_set_前导 码阈值(uint8_t nbytes)；

/*Gonder-Al*/
void SpiPaketgonder (uint8_t* TxBuffer、uint8_t size)；
uint8_t SpiPaketal (uint8_t* RxBuffer、uint8_t*大小)；
uint8_t SpiDurumOku (uint8_t Addr)；

/*STATE ------------ *
void rf_sidle()；
void rf_power_down ()；
void rf_wakeup()；
void rf_receive()；
uint8_t rf_get_settings()；
void rf_wor_enable ()；
void rf_wor_disable()；
void rf_wor_reset ()；

/*通信-------- *
uint16_t _get_FRAME_SIZE (uint8_t*标头、uint8_t DATA_len_loc、uint8_t DATA_len_size)；
uint8_t _keep_transming_data (uint8_t* data、int len)；
FRAMESTATUS_typedef SEND_FRAME (uint8_t*帧、int len)；
uint8_t _keep_receiving_data (uint8_t* data、int len)；
FRAMESTATUS_typedef receive_frame (uint8_t* frame_buffer、uint16_t* len、uint8_t data_len_loc、uint8_t data_len_size、uint8_t* lqi、 uint8_t* RSSI)；
uint8_t POLLING_while 更低(uint8_t reg、uint8_t size)；
uint8_t POLLING_while 较大(uint8_t reg、uint8_t size)；
uint8_t rf_incoming_packet ()；
void send_packet_rf (uint8_t* txBuffer、uint8_t size)；

/*其他--- *
void init_serial (UART_HandleTypeDef* huart)；
int _io_putchar (int ch)；
int _write (int file、char * ptr、int len)；

void init_led()；

#endif /* INC_RF_DRIVER_H_*

rf_driver.c

/*
* rf_driver.c
*
*创建日期：3月29日。 2019年
*作者：dsoldevila
*以下代码由 SpaceTeddy (github.com/.../CC1101):)制作
*可申请专利的预设
*调制预设
* rf_set_model_mode (mode)；
RF_SET_ISMband (ISM_BAND)；
rf_set_output_power_level (-30)；
WOR_ENABLE()
一些进入 x 状态函数(但它们非常简单、因此无关紧要)
以下代码来自 EMC.EU (www.emcu.eu/how-imple-imple-printf-用于发送消息-通过 USB-on-STM32-Nucleo-boards-use-use-atollic)
_io_putchar()

TODO 注意：调制预设 GFSK_1_2KB 具有正确的值。 其他预设可能需要进行一些修改才能工作。
仅测试了 GFSK_1_2KB 调制、不希望其他调制器正常工作。
*
*
//#define RF_DRIVER_H_
#include "rf_driver.h"
#include "dw_STM32_delay.h"
#include
#include

/*私有变量------------------------------------------------------- *
SPI_HandleTypeDef* hal_SPI；
UART_HandleTypeDef* hal_UART；

uint16_t CS_Pin；
GPIO_typedef* CS_GPIO_Port；

uint16_t GDO0_Pin；//板引脚连接到 CC1101的 GDO0引脚
uint16_t GDO2_Pin；
uint8_t RSSI_DBM = 0；
uint8_t GDO0_FLAG = 0；// TX 阈值中断的标志。 用于控制对缓冲器的读取和写入、并检查
//数据包到达。

uint32_t TIMEOUT = 0x6FF；//TODO 它是硬编码的

///---------------- [PATABLES]--------------------
/*各种频率的 PATABLES 寄存器预设。 该值是-30、-20、-15、
每个载波频率为-10、0、5、7、10dBm。
*
uint8_t patable_power_315[]=｛0x17、0x1D、0x26、0x69、0x51、0x86、0xCC、0xC3｝；
uint8_t patable_power_433[]=｛0x6C、0x1C、0x06、0x3A、0x51、0x85、0xC8、0xC0｝；
uint8_t patable_power_868[]=｛0x03、0x17、0x1D、0x26、0x50、0x86、0xCD、0xC0｝；
uint8_t patable_power_915[]=｛0x0B、0x1B、0x6D、0x67、0x50、0x85、0xC9、0xC1｝；

///---------------- [寄存器基本配置]-----
//高斯移频键控模块的预设值为1.2KBITS
uint8_t CC1100_GFSK_1_2_KB[]=｛
0x07、// IOCFG2 GDO2输出引脚配置
0x2E、// IOCFG1 GDO1输出引脚配置
0x80、// IOCFG0 GDO0_Pin 输出引脚配置
0x07、// FIFOHR RX FIFO 和 TX FIFO 阈值
0x57、// SYNC1同步字、高字节
0x43、// SYNC0同步字、低字节
0x3E、// PKTLEN 数据包长度
0xD8、// PKTCTRL1数据包自动化控制//TODO 从 DC 更改为禁用 LQI 和 RSSI 附加
0x45、// PKTCTRL0数据包自动化控制
0xFF、// ADDR 设备地址
0x00、// CHANNR 通道编号
0x08、// FSCTRL1频率合成器控制
0x00、// FSCTRL0频率合成器控制
0x21、// FREQ2频率控制字、高字节
0x65、// FREQ1频率控制字、中间字节
0x6A、// FREQ0频率控制字、低字节
0xf5、// MDMCFG4调制解调器配置
0x83、// MDMCFG3调制解调器配置
0x13、// MDMCFG2调制解调器配置
0xC0、// MDMCFG1调制解调器配置
0xf8、// MDMCFG0调制解调器配置
0x15、// DEVIATN 调制解调器偏差设置
0x07、// MCSM2主无线电控制状态机配置
0x00、// MCSM1主无线电控制状态机配置//TODO 为0x0C
0x18、// MCSM0主无线电控制状态机配置
0x16、// FOCCFG 频率偏移补偿配置
0x6C、// BSCFG 位同步配置
0x03、// AGCCTRL2 AGC 控制
0x40、// AGCCTRL1 AGC 控制
0x91、// AGCCTRL0 AGC 控制
0x02、// WOREVT1高字节 Event0超时
0x26、// WOREVT0低字节 Event0超时
0x09、//对讲机控制上的 WORCTRL 唤醒
0x56、// FREND1前端 RX 配置
0x17、// FREND0前端 TX 配置
0xA9、// FSCAL3频率合成器校准
0x0A、// FSCAL2频率合成器校准
0x00、// FSCAL1频率合成器校准
0x11、// FSCAL0频率合成器校准
0x41、// RCCTRL1 RC 振荡器配置
0x00、// RCCTRL0 RC 振荡器配置
0x59、// FSTEST 频率合成器校准控制、
0x7f、// ptest 生产测试
0x3F、// AGCTEST AGC 测试
0x81、// TEST2各种测试设置
0x3F、// TEST1各种测试设置
0x0B // TEST0各种测试设置
}；

uint8_t CC1100_GFSK_38_4_KB[]=｛
0x07、// IOCFG2 GDO2输出引脚配置
0x2E、// IOCFG1 GDO1输出引脚配置
0x80、// IOCFG0 GDO0_Pin 输出引脚配置
0x07、// FIFOHR RX FIFO 和 TX FIFO 阈值
0x57、// SYNC1同步字、高字节
0x43、// SYNC0同步字、低字节
0x3E、// PKTLEN 数据包长度
0xDC、// PKTCTRL1数据包自动化控制
0x45、// PKTCTRL0数据包自动化控制
0xFF、// ADDR 设备地址
0x00、// CHANNR 通道编号
0x06、// FSCTRL1频率合成器控制
0x00、// FSCTRL0频率合成器控制
0x21、// FREQ2频率控制字、高字节
0x65、// FREQ1频率控制字、中间字节
0x6A、// FREQ0频率控制字、低字节
0xCA、// MDMCFG4调制解调器配置
0x83、// MDMCFG3调制解调器配置
0x13、// MDMCFG2调制解调器配置
0xA0、// MDMCFG1调制解调器配置
0xf8、// MDMCFG0调制解调器配置
0x34、// DEVIATN 调制解调器偏差设置
0x07、// MCSM2主无线电控制状态机配置
0x0C、// MCSM1主无线控制状态机配置
0x18、// MCSM0主无线电控制状态机配置
0x16、// FOCCFG 频率偏移补偿配置
0x6C、// BSCFG 位同步配置
0x43、// AGCCTRL2 AGC 控制
0x40、// AGCCTRL1 AGC 控制
0x91、// AGCCTRL0 AGC 控制
0x02、// WOREVT1高字节 Event0超时
0x26、// WOREVT0低字节 Event0超时
0x09、//对讲机控制上的 WORCTRL 唤醒
0x56、// FREND1前端 RX 配置
0x17、// FREND0前端 TX 配置
0xA9、// FSCAL3频率合成器校准
0x0A、// FSCAL2频率合成器校准
0x00、// FSCAL1频率合成器校准
0x11、// FSCAL0频率合成器校准
0x41、// RCCTRL1 RC 振荡器配置
0x00、// RCCTRL0 RC 振荡器配置
0x59、// FSTEST 频率合成器校准控制、
0x7f、// ptest 生产测试
0x3F、// AGCTEST AGC 测试
0x81、// TEST2各种测试设置
0x3F、// TEST1各种测试设置
0x0B // TEST0各种测试设置
}；

uint8_t CC1100_GFSK_100_KB[]=｛
0x07、// IOCFG2 GDO2输出引脚配置
0x2E、// IOCFG1 GDO1输出引脚配置
0x80、// IOCFG0 GDO0_Pin 输出引脚配置
0x07、// FIFOHR RX FIFO 和 TX FIFO 阈值
0x57、// SYNC1同步字、高字节
0x43、// SYNC0同步字、低字节
0x3E、// PKTLEN 数据包长度
0xDC、// PKTCTRL1数据包自动化控制
0x45、// PKTCTRL0数据包自动化控制
0xFF、// ADDR 设备地址
0x00、// CHANNR 通道编号
0x08、// FSCTRL1频率合成器控制
0x00、// FSCTRL0频率合成器控制
0x21、// FREQ2频率控制字、高字节
0x65、// FREQ1频率控制字、中间字节
0x6A、// FREQ0频率控制字、低字节
0x5B、// MDMCFG4调制解调器配置
0xf8、// MDMCFG3调制解调器配置
0x13、// MDMCFG2调制解调器配置
0xA0、// MDMCFG1调制解调器配置
0xf8、// MDMCFG0调制解调器配置
0x47、// DEVIATN 调制解调器偏差设置
0x07、// MCSM2主无线电控制状态机配置
0x0C、// MCSM1主无线控制状态机配置
0x18、// MCSM0主无线电控制状态机配置
0x1D、// FOCCFG 频率偏移补偿配置
0x1C、// BSCFG 位同步配置
0xC7、// AGCCTRL2 AGC 控制
0x00、// AGCCTRL1 AGC 控制
0xB2、// AGCCTRL0 AGC 控制
0x02、// WOREVT1高字节 Event0超时
0x26、// WOREVT0低字节 Event0超时
0x09、//对讲机控制上的 WORCTRL 唤醒
0xB6、// FREND1前端 RX 配置
0x17、// FREND0前端 TX 配置
0xEA、// FSCAL3频率合成器校准
0x0A、// FSCAL2频率合成器校准
0x00、// FSCAL1频率合成器校准
0x11、// FSCAL0频率合成器校准
0x41、// RCCTRL1 RC 振荡器配置
0x00、// RCCTRL0 RC 振荡器配置
0x59、// FSTEST 频率合成器校准控制、
0x7f、// ptest 生产测试
0x3F、// AGCTEST AGC 测试
0x81、// TEST2各种测试设置
0x3F、// TEST1各种测试设置
0x0B // TEST0各种测试设置
}；

uint8_t CC1100_MSK_250_KB[]=｛
0x07、// IOCFG2 GDO2输出引脚配置
0x2E、// IOCFG1 GDO1输出引脚配置
0x80、// IOCFG0 GDO0_Pin 输出引脚配置
0x07、// FIFOHR RX FIFO 和 TX FIFO 阈值
0x57、// SYNC1同步字、高字节
0x43、// SYNC0同步字、低字节
0x3E、// PKTLEN 数据包长度
0xDC、// PKTCTRL1数据包自动化控制
0x45、// PKTCTRL0数据包自动化控制
0xFF、// ADDR 设备地址
0x00、// CHANNR 通道编号
0x0B、// FSCTRL1频率合成器控制
0x00、// FSCTRL0频率合成器控制
0x21、// FREQ2频率控制字、高字节
0x65、// FREQ1频率控制字、中间字节
0x6A、// FREQ0频率控制字、低字节
0x2D、// MDMCFG4调制解调器配置
0x3B、// MDMCFG3调制解调器配置
0x73、// MDMCFG2调制解调器配置
0xA0、// MDMCFG1调制解调器配置
0xf8、// MDMCFG0调制解调器配置
0x00、// DEVIATN 调制解调器偏差设置
0x07、// MCSM2主无线电控制状态机配置
0x0C、// MCSM1主无线控制状态机配置
0x18、// MCSM0主无线电控制状态机配置
0x1D、// FOCCFG 频率偏移补偿配置
0x1C、// BSCFG 位同步配置
0xC7、// AGCCTRL2 AGC 控制
0x00、// AGCCTRL1 AGC 控制
0xB2、// AGCCTRL0 AGC 控制
0x02、// WOREVT1高字节 Event0超时
0x26、// WOREVT0低字节 Event0超时
0x09、//对讲机控制上的 WORCTRL 唤醒
0xB6、// FREND1前端 RX 配置
0x17、// FREND0前端 TX 配置
0xEA、// FSCAL3频率合成器校准
0x0A、// FSCAL2频率合成器校准
0x00、// FSCAL1频率合成器校准
0x11、// FSCAL0频率合成器校准
0x41、// RCCTRL1 RC 振荡器配置
0x00、// RCCTRL0 RC 振荡器配置
0x59、// FSTEST 频率合成器校准控制、
0x7f、// ptest 生产测试
0x3F、// AGCTEST AGC 测试
0x81、// TEST2各种测试设置
0x3F、// TEST1各种测试设置
0x0B // TEST0各种测试设置
}；

uint8_t CC1100_MSK_500_KB[]=｛
0x07、// IOCFG2 GDO2输出引脚配置
0x2E、// IOCFG1 GDO1输出引脚配置
0x80、// IOCFG0 GDO0_Pin 输出引脚配置
0x07、// FIFOHR RX FIFO 和 TX FIFO 阈值
0x57、// SYNC1同步字、高字节
0x43、// SYNC0同步字、低字节
0x3E、// PKTLEN 数据包长度
0xDC、// PKTCTRL1数据包自动化控制
0x45、// PKTCTRL0数据包自动化控制
0xFF、// ADDR 设备地址
0x00、// CHANNR 通道编号
0x0C、// FSCTRL1频率合成器控制
0x00、// FSCTRL0频率合成器控制
0x21、// FREQ2频率控制字、高字节
0x65、// FREQ1频率控制字、中间字节
0x6A、// FREQ0频率控制字、低字节
0x0E、// MDMCFG4调制解调器配置
0x3B、// MDMCFG3调制解调器配置
0x73、// MDMCFG2调制解调器配置
0xA0、// MDMCFG1调制解调器配置
0xf8、// MDMCFG0调制解调器配置
0x00、// DEVIATN 调制解调器偏差设置
0x07、// MCSM2主无线电控制状态机配置
0x0C、// MCSM1主无线控制状态机配置
0x18、// MCSM0主无线电控制状态机配置
0x1D、// FOCCFG 频率偏移补偿配置
0x1C、// BSCFG 位同步配置
0xC7、// AGCCTRL2 AGC 控制
0x40、// AGCCTRL1 AGC 控制
0xB2、// AGCCTRL0 AGC 控制
0x02、// WOREVT1高字节 Event0超时
0x26、// WOREVT0低字节 Event0超时
0x09、//对讲机控制上的 WORCTRL 唤醒
0xB6、// FREND1前端 RX 配置
0x17、// FREND0前端 TX 配置
0xEA、// FSCAL3频率合成器校准
0x0A、// FSCAL2频率合成器校准
0x00、// FSCAL1频率合成器校准
0x19、// FSCAL0频率合成器校准
0x41、// RCCTRL1 RC 振荡器配置
0x00、// RCCTRL0 RC 振荡器配置
0x59、// FSTEST 频率合成器校准控制、
0x7f、// ptest 生产测试
0x3F、// AGCTEST AGC 测试
0x81、// TEST2各种测试设置
0x3F、// TEST1各种测试设置
0x0B // TEST0各种测试设置
}；

uint8_t CC1100_OOK_4_8_kb[]=｛//事实上它是2.4Kb/s、这是因为曼哈顿的编码、请参阅数据表。
0x02、// IOCFG2 GDO2输出引脚配置//0x06 -> 0x02 (低于阈值时无效)
0x2E、// IOCFG1 GDO1输出引脚配置
0x06、// IOCFG0 GDO0_Pin 输出引脚配置
0x48、// FIFOTHR RX FIFO 和 TX FIFO 阈值//0x47 --> 0x48
0x57、// SYNC1同步字、高字节
0x43、// SYNC0同步字、低字节
0xFF、// PKTLEN 数据包长度
0xDC、// PKTCTRL1数据包自动化控制
0x05、// PKTCTRL0数据包自动化控制
0x00、// ADDR 设备地址
0x00、// CHANNR 通道编号
0x06、// FSCTRL1频率合成器控制
0x00、// FSCTRL0频率合成器控制
0x21、// FREQ2频率控制字、高字节
0x65、// FREQ1频率控制字、中间字节
0x6A、// FREQ0频率控制字、低字节
0x87、// MDMCFG4调制解调器配置
0x83、// MDMCFG3调制解调器配置
0x3B、// MDMCFG2调制解调器配置
0x22、// MDMCFG1调制解调器配置
0xf8、// MDMCFG0调制解调器配置
0x15、// DEVIATN 调制解调器偏差设置
0x07、// MCSM2主无线电控制状态机配置
0x30、// MCSM1主无线控制状态机配置
0x18、// MCSM0主无线电控制状态机配置
0x14、// FOCCFG 频率偏移补偿配置
0x6C、// BSCFG 位同步配置
0x07、// AGCCTRL2 AGC 控制
0x00、// AGCCTRL1 AGC 控制
0x92、// AGCCTRL0 AGC 控制
0x87、// WOREVT1高字节 Event0超时
0x6B、// WOREVT0低字节 Event0超时
0xFB、//对讲机控制上的 WORCTRL 唤醒
0x56、// FREND1前端 RX 配置
0x17、// FREND0前端 TX 配置
0xE9、// FSCAL3频率合成器校准
0x2A、// FSCAL2频率合成器校准
0x00、// FSCAL1频率合成器校准
0x1f、// FSCAL0频率合成器校准
0x41、// RCCTRL1 RC 振荡器配置
0x00、// RCCTRL0 RC 振荡器配置
0x59、// FSTEST 频率合成器校准控制
0x7f、// ptest 生产测试
0x3F、// AGCTEST AGC 测试
0x81、// TEST2各种测试设置
0x35、// TEST1各种测试设置
0x09、// TEST0各种测试设置
}；
///---------------- [结束寄存器基本配置]-----

/*私人用户代码------------------------------------------------------- *

/*射频驱动器------------------------------------------------------- *
uint8_t 版本；
/*------------------ [CC1101初始化和设置]----- *
uint8_t rf_begin (SPI_HandleTypeDef* hspi、model_typedef 模式、ISMBAND_typedef ISM_band、GPIO_typedef* cs_port、uint16_t cs_pin、 uint16_t gdo0)｛
/**
*@简单调用使射频芯片运行所需的所有函数。 这应该是在时使用的第一个函数
*使用射频芯片。
*@param hspi：指向 SPI 处理程序的指针
*@param 模式：使用调制
*@使用的 param ISM_band 频率
*@param cs_port：芯片选择(SPI)引脚端口(即：GPIOD)
*@param cs_pin：芯片选择(SPI)引脚编号(即 GPIO_PIN_14)
*@param gdo0：连接到 C1101 CGDO0的引脚的引脚编号、用于中断。 中断被配置为下降沿。
*
*

//引脚分配链接
HAL_SPI = hspi；
CS_GPIO_Port = cs_port；
CS_Pin = CS_Pin；
GDO0_Pin = gdo0；

//打开芯片
POWER_UP_RESET ()；

//检查 SPI 是否正常工作
//if (！rf_check())
｛
//返回 false；
｝

RF_WRITE_STROBE (SFTX_W)；//刷新 TX FIFO
HAL_DELAY (1)；//TODO 我认为这不是真正需要的
RF_WRITE_STROBE (SFRX_W)；//刷新 RX FIFO
HAL_DELAY (1)；

RF_SET_MODE_MODE (MODE)；

RF_SET_ISMband (ISM_BAND)；
RF_SET_CHANNEL (0)；
rf_set_output_power_level (0)；
rf_set_carrier_frequency (433.98)；
rf_set_carrier_offset (50)；
版本= RF_SPI_Read (version_R)；
版本= RF_SPI_READ (PARTNUM_R)；
返回 true；

｝

void Power_up_reset ()
｛
// Güç geldikten sonra CC1101 I Macro resetlemek için

dwt_delay_Init()；
HAL_GPIO_WritePin (CS_GPIO_Port、CS_Pin、GPIO_PIN_SET)；
dwt_delay_us (1)；
HAL_GPIO_WritePin (CS_GPIO_Port、CS_Pin、GPIO_PIN_RESET)；
dwt_delay_us (1)；
HAL_GPIO_WritePin (CS_GPIO_Port、CS_Pin、GPIO_PIN_SET)；
dwt_delay_us (41)；

HAL_GPIO_WritePin (CS_GPIO_Port、CS_Pin、GPIO_PIN_RESET)；
while (HAL_GPIO_ReadPin (GPIOA、GPIO_PIN_6))；//CS Pini low yaptığımızd MISO Pini adres yazılmadan önce low da beklemeli
RF_WRITE_STROBE (SRES_W)；
HAL_GPIO_WritePin (CS_GPIO_Port、CS_Pin、GPIO_PIN_SET)；
｝

void rf_reset ()｛
/**
*@通过 CS 引脚上的特定序列和 SRES 命令来简要打开射频芯片。
*只有在冷启动时才需要前者。
*
dwt_delay_Init()；

HAL_GPIO_WritePin (CS_GPIO_Port、CS_Pin、GPIO_PIN_RESET)；
while (HAL_GPIO_ReadPin (GPIOA、GPIO_PIN_6))；//CS Pini low yaptığımızd MISO Pini adres yazılmadan önce low da beklemeli
HAL_GPIO_WritePin (CS_GPIO_Port、CS_Pin、GPIO_PIN_SET)；
dwt_delay_us (40)；

RF_WRITE_STROBE (SRES_W)；
HAL_DELAY (1)；

｝

uint8_t rf_check ()｛
/**
*@brief 检查 RF 芯片的版本以检查 SPI 是否正常。 它会检查10次、以确保导线确实正常。
*

uint8_t ok = true；
uint8_t i；
uint8_t 版本；
for (i=0；i<10；i++)｛
版本= RF_SPI_Read (version_R)；
if (版本！=0x14)
OK = false；
｝

如果(ok)｛
printf ("RF 校验：确定\n\r\n)；
｝否则｛
printf (“射频检查：运气不佳：(\n\r\n)；
｝
返回正常；

｝

void rf_set_model_mode (model_typedef 模式)｛
/*
*@brief 会将所需的调制预设加载到 CC1101。
*

uint8_t* cfg_reg；

开关(模式)
｛
案例 GFSK_1_2_KB：
CFG_reg = CC1100_GFSK_1_2_KB；
中断；
案例 GFSK_38_4_KB：
CFG_reg = CC1100_GFSK_38_4_KB；
中断；
案例 GFSK_100_KB：
CFG_reg = CC1100_GFSK_100_KB；
中断；
MSK_250_KB 案例：
CFG_reg = CC1100_MSK_250_KB；
中断；
MSK_500_KB 案例：
CFG_reg = CC1100_MSK_500_KB；
中断；
案例 OOK_4_8_KB：
CFG_reg = CC1100_OOK_4_8_KB；
中断；
默认值：
CFG_reg = CC1100_GFSK_38_4_KB；
中断；
｝

RF_SPI_WRITE_DATA (WRITE_BURST (0)、cfg_reg、CFG_register)；//写入所有47个配置寄存器

｝

//(半自动)已弃用
void rf_set_ismband (ismBAND_typedef 频带)｛
/*
* RF_SET_FREQUENCY (float)已弃用、但第二个寄存器仍不配置 PATABLES 寄存器、因此仍需要该寄存器。
*
uint8_t freq2、freq1、freq0；
uint8_t*可申请专利；

开关(带)
｛
案例 MHz315：
freq2=0x0C；
freq1=0x1D；
FREQ0=0x89；
patable = patable_power_315；
中断；
案例 MHz434：//433.92MHz
freq2=0x10；
FREQ1=0xB0；
freq0=0x71；
patable = patable_power_433；
中断；
案例 MHz868：//868.3MHz
freq2=0x21；
freq1=0x65；
freq0=0x6A；
patable = patable_power_868；
中断；
案例 MHz915：
freq2=0x23；
freq1=0x31；
FREQ0=0x3B；
patable = patable_power_915；
中断；
默认值：//868.3MHz
freq2=0x21；
freq1=0x65；
freq0=0x6A；
patable = patable_power_868；
中断；
｝
RF_SPI_WRITE (FREQ2_W、freq2)；
RF_SPI_WRITE (FREQ1_W、freq1)；
RF_SPI_WRITE (FREQ0_W、freq0)；
RF_SPI_WRITE_DATA (PATABLE_BURST、可申请专利、8)；
｝

void rf_set_channel (uint8_t channel)｛
/*
*@简要设置通道编号。
*
RF_SPI_WRITE (CHANNR_W、通道)；
｝

void rf_set_output_power_level (INT8_t dBm)
/*
*@brief 会选择先前选择的 PATABLES 预设的条目。
*
｛
uint8_t pA = 0xC0；

如果(dBm <=-30) PA = 0x00；
否则、如果(dBm <=-20) PA = 0x01；
否则、如果(dBm <=-15) PA = 0x02；
否则、如果(dBm <=-10) PA = 0x03；
否则、如果(dBm <= 0) PA = 0x04；
否则、如果(dBm <= 5) PA = 0x05；
否则、如果(dBm <= 7) PA = 0x06；
否则、如果(dBm <= 10) PA = 0x07；

RF_SPI_WRITE (FREND0_W、PA)；
｝

float rf_set_carrier_offset (float offset)｛
/*
*@Brief 配置频率偏移寄存器以实现已设置的偏移量。
*@param 偏移所需偏移。 应介于-200kHz 和+200kHz 之间、具体取决于晶振。
*@返回实际偏移
*
//RF_SPI_WRITE (FSCTRL0、偏移量)；
int8_t freqoff = offset*(1<<14)/crystal_frequency；
RF_SPI_WRITE (FSCTRL0_W、freqoff)；
return freqoff*(crystal_frequency /(1<<14))；
｝

float rf_set_carrier_frequency (float target_freq)｛
/*请注意、此函数取决于 crystal_frequency _M 的值
*@以 MHz 为目标的 param target_freq 频率。 正数。 请注意、实际频率可能会有所不同。
*@返回实际配置的频率。
*
target_freq = target_freq*1000000；
float freqf = target_freq*65536.0/（float) crystal_frequency _M；
uint32_t freq =(uint32_t) freqf；
FREQ = FREQ&0x00FFFFFF；
RF_SPI_WRITE (FREQ0_W、频率)；
RF_SPI_WRITE (FREQ1_W、(FREQ>>8))；
RF_SPI_WRITE (FREQ2_W、(FREQ>>16))；
float t =((float) freq*(float) crystal_frequency _M)/65536.0；

返回 t；
｝

float RF_SET_CHANNEL SPACING (float cspacing)｛
/*
*@brief 会配置通道间距寄存器以实现尽可能与目标间距更近的间距
*请注意、此函数取决于 crystal_frequency _M 的值
*@param cspacing 目标间距、单位为 KHz。 正数。
*@返回实际配置的间距、单位为 KHz
*
uint8_t chanspc_e = 0；
uint8_t chanspc_m = 0；
float tmp；

tmp = cspacing*((1<<18)/((float) crystal_frequency *(<chanspc_e)))-256.0;
while (tmp>256 && chanspc_e<4)｛
chanspc_e++；
tmp = cspacing*((1<<18)/((float) crystal_frequency *(<chanspc_e)))-256.0;
｝
chanspc_m =(uint8_t) tmp；
RF_SPI_WRITE (MDMCFG0_W、chanspc_m)；

uint8_t mdmcfg1 = RF_SPI_Read (MDMCFG1_W)；
mdmcfg1 &= 0xFC；
mdmcfg1 ||(chanspc_e 和0x2)；
RF_SPI_WRITE (MDMCFG1_W、mdmcfg1)；

cspacing=((float) crystal_frequise/（1<<18))*((float) chanspc_m+256.0)*(<chanspc_e);
返回间距；
｝

void rf_set_帧 头(uint8_t nbytes)｛
/*
*@brief 设置前导码大小。 前导码是在数据包之前发送的1和0流。
*
rf_sidle()；
//toto Rright 现在已硬编码为8个字节。

｝

void rf_set_前导 码阈值(uint8_t nbytes)｛
/*
*@brief 会设置要检测的最小前导码字节。
*
rf_sidle()；
//TODO 现在已添加到4个字节。

｝

/*-------------------- [CC1101状态]----------------- *
void rf_sidle()｛
/**
*@将射频芯片短暂设置为空闲状态
*
uint8_t marcstate；

rf_write_strobe (sidle_W)；//首先设置为空闲。 必须在中

marcstate = 0xFF；//设置未知/虚拟状态值

while (marcstate！= IDLE)
｛
marcstate =(RF_SPI_Read (MARCSTATE_R))；//& 0x1F)；
｝

｝

void rf_receive()｛
/*
*@将射频芯片简要设置为接收状态(RX)
*
//配置中断，当传入数据包时为1
RF_SPI_WRITE (IOCFG0_W、0x46)；
RF_WRITE_STROBE (SFRX_W)；
RF_WRITE_STROBE (SRX_W)；

uint8_t marcstate = 0xFF；
while (marcstate！= RX)｛
marcstate =(RF_SPI_Read (MARCSTATE_R))；//读取 CC1100的状态以确保在 RX 中
｝
GDO0_FLAG = 0；

｝

//TODO 未测试
void rf_power_down ()｛
rf_sidle()；
RF_WRITE_STROBE (SPWD_W)；// CC1100掉电
｝

//TODO 未测试
void rf_wakeup (void)｛
/*
*@简要从断电状态唤醒 c1101。
*
HAL_GPIO_WritePin (CS_GPIO_Port、CS_Pin、GPIO_PIN_RESET)；
HAL_DELAY (10)；
HAL_GPIO_WritePin (CS_GPIO_Port、CS_Pin、GPIO_PIN_SET)；
HAL_DELAY (10)；
//TODO RF_Receive ()；//进入 RX 模式
｝

/*//TODO 未测试
uint8_t rf_get_settings()｛
uint8_t 设置[CFG_REGISTER]；
RF_SPI_READ_DATA (0、设置、CFG_REGTER)；
返回设置；
}*/

//TODO 未测试
void rf_wor_enable ()｛
/*
*@简要启用 WOR 模式 EVENT0 ~1890ms；RX_TIMEOUT ~235ms
*
/*
EVENT1 = WORCTRL[6：4]->数据表第88页
EVENT0 =(750/XTAL)*(WOREVT1<<8+WOREVT0)*2^(5*WOR_RES)=(750/26Meg)*65407*2^(5*0)=1.89s
(WOR_RES=0；RX_TIME=0)->数据表第80页
即 RX_TIMEOUT = EVENT0*(3.6038)* 26/26Meg = 235.8ms
(WOR_RES=0；RX_TIME=1)->数据表第80页
I.E.RX_TIMEOUT = EVENT0*(1.8029)*26Meg = 117.9ms
*
rf_sidle()；

RF_SPI_WRITE (MCSM0_W、0x18)；//FS 自动校准
RF_SPI_WRITE (MCSM2_W、0x01)；//MCSM2.RX_TIME = 1b

//配置 EVENT0时间
RF_SPI_WRITE (WOREVT1_W、0xFF)；//高字节 Event0超时
RF_SPI_WRITE (WOREVT0_W、0x7F)；//低字节 Event0超时

//配置 EVENT1时间
RF_SPI_WRITE (WORCTRL_W、0x78)；//WOR_RES=0b；tEVENT1=0111b=48d -> 48*(750/26MHz)= 1.385ms

RF_WRITE_STROBE (SFRX_W)；//清除 RX 缓冲器
RF_WRITE_STROBE (SWORRST_W)；//将 WOR 计时器重置为编程的事件1
RF_WRITE_STROBE (SWOR_W)；//在 CSn 被释放时将无线电置于 WOR 模式

HAL_DELAY (1)；//TODO 是否真的有必要？
｝

//TODO 未测试
void rf_wor_disable()｛
rf_sidle()；//exit WOR Mode
RF_SPI_WRITE (MCSM2_W、0x07)；//保持在 RX 中。 无 RX 超时
｝

//TODO 未测试
void rf_wor_reset ()｛
rf_sidle ()；//go to idle
RF_SPI_WRITE (MCSM2_W、0x01)；//MCSM2.RX_TIME = 1b
RF_WRITE_STROBE (SFRX_W)；//清除 RX 缓冲器
RF_WRITE_STROBE (SWORRST_W)；//将 WOR 计时器重置为编程的事件1
RF_WRITE_STROBE (SWOR_W)；//在 CSn 被释放时将无线电置于 WOR 模式

HAL_DELAY (100)；//真的有必要？
｝

/*-------------------- [CC1101数据流]--------------- *

uint8_t _keep_transming_data (uint8_t* data、int len)｛
/**
*@简短此函数继续传输数据、但不会启动数据。 控制一次从 MCU 到 C1101的数据流
*已开始。
*
int len_transmited = 0；
uint32_t start_tick = HAL_GetTick ()；
uint8_t last_chunk = len%data_chunch_size；
GDO0_FLAG = 0；
while (len_transmited <len-last_chunk){)
if (GDO0_FLAG)｛
//while (rf_spi_read (TXBYTES)>data_chunch_size)；//由于 OBC Int. 不奏效。
GDO0_FLAG = 0；
rf_spi_write_data (TXFIFO、&data[len_transmed]、data_chunch_size)；
len_transmited +=data_chunch_size；
START_TICK = HAL_GetTick ()；

｝
if (HAL_GetTick ()-start_tick> timeout)返回 false；
｝
if (last_chunk)｛
while (！GDO0_FLAG)；
//while (rf_spi_read (TXBYTES)>data_chunch_size)；//由于 OBC Int. 不奏效。
GDO0_FLAG = 0；
rf_spi_write_data (TXFIFO、&data[len_transmed]、last_chunk)；
if (HAL_GetTick ()-start_tick> timeout)返回 false；
｝

返回 true；
｝

FRAMESTATUS_typedef SEND_FRAME (uint8_t*帧、int len)｛
/**
*@短发送和长度不受限制的帧
* TODO RSSI 和 LQI 值被附加到数据包中、如何处理它们？
*

rf_sidle()；//将 rf 设置为空闲状态
uint8_t pktcrtl0 = rf_spi_read (PKTCTRL0_R)；
uint8_t frame_len = len%256；
pktcrtl0 = pktcrtl0 & 0b11111100；//重置 len 模式
int len_sent = 0；

//配置中断，低于阈值时从高到低
uint8_t iocfg0 = 0x2；
RF_SPI_WRITE (IOCFG0_W、iocfg0)；
GDO0_FLAG = 0；

RF_WRITE_STROBE (SFTX_W)；//清除 TX
//TODO 检查是否冲洗

//设置数据包长度
RF_SPI_WRITE (PKTLEN_W、FRAME_Len)；

if (len>fixed_length_limit)｛//使用无限数据包长度模式
//将 len 模式设置为无限
pktcrtl0 = pktcrtl0 | 0x2；
RF_SPI_WRITE (PKTCTRL0_W、pktcrtl0)；

//在激活 TX 模式之前需要填充缓冲区，否则芯片将进入 TX 下溢状态。
RF_SPI_WRITE_DATA (TXFIFO、FRAME、FIFO_SIZE)；//完全填充缓冲器
RF_WRITE_STROBE (STX_W)；//开始转换
len_sent +=FIFO_SIZE；

int 时间=(len-len_sent)/FIFO_SIZE–1；//-1以确保剩余字节在接收模式下发送它们
//传输(len -d -255)字节的数据，其中 d 是已发送的字节数
if (！_keep_transminging_data (&frame[len_sent]、times*FIFO_size))返回超时；
len_sent += times*FIFO_SIZE；

//在固定长度模式下发送剩余字节。

//将 len 模式设置为固定
pktcrtl0 = pktcrtl0 & 0b11111100；
RF_SPI_WRITE (PKTCTRL0_W、pktcrtl0)；

if (！_keep_transming_data (&frame[len_sent]、len_sent))返回超时；

｝否则｛
//将 len 模式设置为固定模式(默认)
RF_SPI_WRITE (PKTCTRL0_W、pktcrtl0)；

if (len>FIFO_SIZE)｛//使用可变数据包长度模式
RF_SPI_WRITE_DATA (TXFIFO、FRAME、FIFO_SIZE)；
RF_WRITE_STROBE (STX_W)；
len_sent += FIFO_SIZE；
if (！_keep_transming_data (&frame[len_sent]、len_sent))返回超时；
}else｛//如果 len <= FIFO_SIZE，则需要填充一次 FIFO
RF_SPI_WRITE_DATA (TXFIFO、帧、长度)；
RF_WRITE_STROBE (STX_W)；
｝
｝

uint32_t start_tick = HAL_GetTick ()；
uint8_t state = rf_spi_read (MARCSTATE_R)；

while (state！= IDLE)｛
//printf ("%#20x\n\r"、状态)；
STATE = RF_SPI_READ (MARCSTATE_R)；
HAL_DELAY (100)；
if (HAL_GetTick ()- start_tick > timeout)｛
if (state=TXFIFO_undercflow)｛
RF_WRITE_STROBE (SFTX_W)；
｝否则｛
rf_sidle()；
｝
返回 frame_Bad；
｝
｝

printf ("frame sened\n\r")；
返回 FRAME_OK；
｝

uint8_t rf_incoming_packet ()｛

返回 GDO0_FLAG；
｝

uint8_t _keep_receiving_data (uint8_t* data、int len)｛
/**
*@简短此函数继续接收数据、但不会启动数据。 控制从 C1101到 MCU 的数据流
* TODO RSSI 和 LQI 值被附加到数据包中、如何处理它们？
*
int len_received = 0；
uint32_t start_tick = HAL_GetTick ()；
uint8_t last_chunk = len%data_chunch_size；
GDO0_FLAG = 0；
while (len_received <len-last_chunk){)
//printf ("%d\n"rf_spi_read (PKTSTATUS)&1)；
if (GDO0_FLAG)｛//if buffer 为半空
GDO0_FLAG = 0；
rf_spi_read_data (RXFIFO、&data[len_received]、data_chunch_size)；
len_received +=data_chunch_size；
START_TICK = HAL_GetTick ()；
｝
if (HAL_GetTick ()-start_tick> timeout)返回 false；
｝
if (last_chunk)｛
if (！POLLING_while (RXBYTES_R、LAST_TUNK))返回 false；//轮询、因为它不会触发阈值。
GDO0_FLAG = 0；
rf_spi_read_data (RXFIFO、&data[len_received]、last_chunk)；
｝

返回 true；
｝

uint8_t POLLING_while 更低(uint8_t reg、uint8_t size)｛
uint8_t = rf_spi_read (reg)；
uint32_t start_tick = HAL_GetTick ()；
while (注意事项<size){
T = RF_SPI_Read (reg)；
//printf ("轮询：%d\n\r"、t)；
HAL_DELAY (10)；
if (HAL_GetTick()-start_tick>timeout)返回 false；
｝
返回 true；
｝

uint8_t POLLING_while 更大(uint8_t reg、uint8_t size)｛
uint8_t = rf_spi_read (reg)；
while (t> size)｛
T = RF_SPI_Read (reg)；
HAL_DELAY (10)；
｝
返回 true；
｝

uint16_t _get_FRAME_SIZE (uint8_t*标头、uint8_t DATA_len_loc、uint8_t DATA_len_size)｛
/*
*@返回帧的长度。
*
uint16_t mask = 1；
for (int i = i；<data_len_size; i++){ 1
MASK= MASK <<1；
MASK+=1；
｝
uint16_t frame_size；
FRAME_SIZE =(header[DATA_len_loc]和0xFF)|(header[DATA_len_loc+1]<<8)和0xFF00；
FRAME_SIZE &=掩码；
返回 frame_size；
｝

FRAMESTATUS_typedef receive_frame (uint8_t* frame_buffer、uint16_t* len、uint8_t data_len_loc、uint8_t data_len_size、uint8_t* lqi、 uint8_t* RSSI)｛
/*
*@Brief 收到一个帧。 当这个函数返回时、芯片返回到 IDLE 模式。 原则上应该有可能
*如果我理解正确、保持 RX 模式以接收另一个数据包、但我无法实现。
*@param frame_buffer 用于存储接收到的数据。
*@param len 最大允许的 len (也称为缓冲区 len)。 还用于返回接收到的数据包的 len。
帧头中数据长度字段的*@参数位置。 必须在前64个字节内。
*@param data_len_size 位中数据长度字段的长度。 用于屏蔽自定义字段大小的2个字节。
*@param LQI Link 质量指标、越低越好。
*@param RSSI 接收信号强度指示器。
*@返回 CRC 校验和是否正常？
*

//初始化一些变量
uint16_t max_len =* len；
*len = 0；
uint16_t frame_len；
uint8_t data_field_size = sizeof (*len)；

//清除标志，因为本函数应该是因为它而被调用的
GDO0_FLAG = 0；

//配置中断。 当 RX 缓冲器高于阈值时触发。
RF_SPI_WRITE (IOCFG0_W、0x40)；

//设置为无限 len 模式
uint8_t pktcrtl0 = rf_spi_read (PKTCTRL0_R)；
pktcrtl0 = pktcrtl0 & 0b11111100；//重置 len 模式
pktcrtl0 = pktcrtl0 | 0x2；
RF_SPI_WRITE (PKTCTRL0_W、pktcrtl0)；

//检查是否接收到内容
uint8_t SFD = 0b00001000；//同步字确定？ ADDR (如果已启用)是否正常？
uint8_t status = 1；//rf_spi_read (PKTSTATUS_R)；

/*
while (！(STATUS&SFD))｛
状态= RF_SPI_Read (PKTSTATUS_R)；
｝
*
//printf ("SFD 确定\n\r\n)；

//获取帧大小
if (！POLLING_while_lower (RXBYTES_R、DATA_len_loc+DATA_FIELD_SIZE))返回超时；//TODO 重新配置 RX 阈值以检测第一个字节？？
rf_spi_read_data (RXFIFO、FRAME_buffer、data_len_loc+data_field_size)；
frame_len =_get_FRAME_size (frame_buffer、data_len_loc、data_len_size)；
*len +=data_len_loc+data_field_size；
if (frame_len > max_len) frame_len = max_len；
printf ("帧 LEN：%d\n\r\n、frame_len)；

uint16_t remain_len = frame_len-*len；
//设置数据包长度
rf_spi_write (PKTLEN_W、(frame_len)%256)；

if (remain_len > fixed_length_limit)｛
int 时间=(remain_len)/FIFO_SIZE；
if (!_keep_receiving_data (&frame_buffer[*len]、times*FIFO_size))返回超时；
*len += times*FIFO_SIZE；

//将数据包长度设置为固定
pktcrtl0 = pktcrtl0 & 0b11111100；
RF_SPI_WRITE (PKTCTRL0_W、pktcrtl0)；

//接收剩余
remain_len = frame_len-*len；
_keep_receiving_data (&frame_buffer[*len]、remain_len)；
*len+=remain_len;

}else if (remain_len>data_chunch_size)｛
//将数据包长度设置为固定
pktcrtl0 = pktcrtl0 & 0b11111100；
RF_SPI_WRITE (PKTCTRL0_W、pktcrtl0)；

//接收剩余
if (!_keep_receiving_data (&frame_buffer[*len]、remain_len))返回超时；
*len+=remain_len;

｝否则｛
//将数据包长度设置为固定
pktcrtl0 = pktcrtl0 & 0b11111100；
RF_SPI_WRITE (PKTCTRL0_W、pktcrtl0)；

//TODO 使用轮询不重新配置中断
if (！POLLING_while (RXBYTES_R、LEFT_Len))返回超时；
rf_spi_read_data (RXFIFO、&frame_buffer[*len]、remain_len)；
*len+=remain_len;
｝
/*
int i = 0；
for (i=2；<frame_len; i++)
//if (i%256！=frame_buffer[i])
printf ("%d：%d \r"、i、frame_buffer[i])；
*
//IF RSSI 和 LQI 被启用

*LQI = RF_SPI_Read (LQI_R)；
uint8_t CRC =(* LQI)& 0x80；
*LQI =*LQI & 0x7F；

* RSSI = RF_SPI_Read (RSSI_R)；
while ((STATUS&SFD))｛
状态= RF_SPI_Read (PKTSTATUS_R)；
｝

状态= 0xFF；
uint32_t start_tick = HAL_GetTick ()；
while (status！= IDLE)｛//PKTCTRL0配置为在接收完成后返回空闲状态
状态= RF_SPI_Read (MARCSTATE_R)；
HAL_DELAY (100)；
if (HAL_GetTick ()- start_tick > timeout)｛
if (status=RXFIFO_overflow)｛
RF_WRITE_STROBE (SFRX_W)；
｝否则｛
rf_sidle()；
｝
返回 frame_Bad；
｝
｝
//printf ("%d crc：%d\n\r"、*len、crc)；
FRAMESTATUS_typedef frame_status；
if (CRC)｛
FRAME_STATUS = FRAME_OK；
｝否则｛
FRAME_STATUS = FRAME_BAD；
｝
返回 FRAME_STATUS；
｝

/* SPI 通信------------------------------------------------------- *

/*void rf_write_strobe (uint8_t strobe)｛

//@将命令简短地写入 CC1101以更改其状态机状态。

选通信号= WRITE (选通信号)；
_SPI_WRITE (选通、0、0)；
}*/

uint8_t rf_read_register (uint8_t reg)｛
/**
*@brief 读取单个1字节寄存器的内容。
*@返回寄存器值。
*
uint8_t 数据；

reg=读取(reg)；
__SPI_READ(，&data，1)；
返回数据；
｝

void rf_write_register (uint8_t reg、uint8_t data)｛
/**
*@brief 会覆盖一个寄存器。
*
reg =写入(reg)；
__SPI_WRITE(，&data，1)；
｝

void rf_read_data (uint8_t addr、uint8_t* data、uint8_t size)｛
/**
*@简要读取多个数据。
*@param addr 基地址。
*@param data 将存储读取数据的缓冲区。
*@param 大小要读取的字节数。
*
if (size>1)｛
ADDR = READ_BURST (addr)；
｝否则｛
Addr =读取(addr)；
｝
_spi_read (&addr、数据、大小)；
｝

void rf_write_data (uint8_t addr、uint8_t* data、uint8_t size)｛
/**
*@简要写入多个数据。
*@param addr 基地址。
*@param 数据要写入的数据所在的缓冲区。
*@param 大小要写入的字节数。
*
if (size>1)｛
ADDR = WRITE_BURST (addr)；
｝否则｛
ADDR = WRITE (addr)；
｝
_spi_write (&addr、data、size)；
｝

// Aşağıdakiler 测试 edilmiş

uint8_t rf_spi_read (uint8_t reg)
｛
//单字节 ve burst reg leri okumak için
uint8_t 数据；
//
__SPI_READ(，&data，1)；

返回数据；
｝

void rf_spi_write (uint8_t reg、uint8_t data)
｛
//单字节 ve 猝发 reg Lere yazmak için
__SPI_WRITE(，&data，1)；
｝

void rf_spi_read_data (uint8_t addr、uint8_t* data、uint8_t size)｛
//Çoklu dataları okumak için
//地址寄存器地址
// okunan buffer değerinin adres
// okunan 字节 sayısı
_spi_read (&addr、数据、大小)；
｝

void rf_spi_write_data (uint8_t addr、uint8_t* data、uint8_t size)｛
//Çoklu dataları okumak için
//地址寄存器地址
// lokasyonda kaydilen buffer değerinin adres
// yazılacak 字节 sayısı
_spi_write (&addr、data、size)；
｝

void send_packet_rf (uint8_t* txBuffer、uint8_t 大小)
｛
RF_SPI_WRITE_DATA (TXFIFO_BURST、txBuffer、SIZE)；
RF_WRITE_STROBE (STX_W)；
while (！HAL_GPIO_ReadPin (GPIOB、GDO0_Pin))；//CS Pini low yaptığımızd MISO Pini adres yazılmadan önce low da beklemeli
while (HAL_GPIO_ReadPin (GPIOB、GDO0_Pin))；//CS Pini low yaptığımızd MISO Pini adres yazılmadan önce low da beklemeli
｝

void rf_write_strobe (uint8_t strobe)｛

//strobe reg e yazmak için herhangi bir veri olmayacağı için 0 yapılmıştır
_SPI_WRITE (选通、0、0)；
｝

/* SPI 处理------------------------------------------------------- *

HAL_StatusTypeDef __SPI_write (uint8_t *addr、uint8_t *pData、uint16_t size)｛
HAL_StatusTypeDef 状态；
HAL_GPIO_WritePin (CS_GPIO_Port、CS_Pin、GPIO_PIN_RESET)；//将芯片选择设置为低电平
while (HAL_GPIO_ReadPin (GPIOA、GPIO_PIN_6))；//CS Pini low yaptığımızd MISO Pini adres yazılmadan önce low da beklemeli
状态= HAL_SPI_transmit (hal_SPI、addr、1、0xFFFF)；
if (status=HAL_OK && pData！=NULL)
状态= HAL_SPI_transmit (hal_SPI、pData、大小、0xFFFF)；
HAL_GPIO_WritePin (CS_GPIO_Port、CS_Pin、GPIO_PIN_SET)；//将芯片选择设置为高电平
退货状态；

｝

HAL_StatusTypeDef __SPI_read (uint8_t *addr、uint8_t *pData、uint16_t size)｛

HAL_StatusTypeDef 状态；
HAL_GPIO_WritePin (CS_GPIO_Port、CS_Pin、GPIO_PIN_RESET)；//将芯片选择设置为低电平
while (HAL_GPIO_ReadPin (GPIOA、GPIO_PIN_6))；//CS Pini low yaptığımızd MISO Pini adres yazılmadan önce low da beklemeli
//HAL_StatusTypeDef HAL_SPI_Transmit (SPI_HandleTypeDef * hspi、uint8_t * pData、uint16_t Size、uint32_t Timeout)
状态= HAL_SPI_transmit (hal_SPI、addr、1、0xFFFF)；
状态= HAL_SPI_Receive (hal_SPI、pData、size、0xFFFF)；
while (HAL_GPIO_ReadPin (GPIOA、GPIO_PIN_6))；//CS Pini low yaptığımızd MISO Pini adres yazılmadan önce low da beklemeli
HAL_GPIO_WritePin (CS_GPIO_Port、CS_Pin、GPIO_PIN_SET)；//将芯片选择设置为高电平

退货状态；

｝

/*中断--------------------------------------------------- *
void HAL_GPIO_EXTI_Callback (uint16_t GPIO_Pin)｛
/*
IF (GPIO_Pin =GPIO_PIN_15)
TX_RX_LEART= 1；
*
if (GPIO_Pin = GDO0_Pin)｛
GDO0_FLAG = 1；
//HAL_GPIO_TogglePin (GPIOB、GPIO_PIN_7)；
｝
/*
if (GPIO_Pin =CS_Pin)｛//用户 B1按钮(F446ZE 上的蓝色按钮)
HAL_GPIO_TogglePin (GPIOB、GPIO_PIN_7)；
}*/
｝

/*杂项--------------------------------------------------------- *

void init_serial (UART_HandleTypeDef* huart)｛

HAL_UART = huart；
｝

int _io_putchar (int ch)
｛
uint8_t c[1]；
C[0]= CH & 0x00FF；
HAL_UART_Transmit (hal_UART、&*c、1、10)；
返回通道；
｝

int _write (int 文件、char * ptr、int len)
｛
Int DataIdx；
for (DataIdx=0；DataIdx< len；DataIdx++)
｛
_io_putchar (* ptr++)；
｝
返回 len；
｝

/*uint8_t SpiDurumOku (uint8_t Addr)
｛
uint8_t 数据；
ADDR = READ_BURST (Addr)；
__SPI_read (&Addr，&Data，1)；
返回数据；
｝

void SpiPaketgonder (uint8_t* TxBuffer、uint8_t 大小)
｛
rf_sidle()；
HAL_DELAY (10)；
RF_WRITE_STROBE (SFTX)；
RF_SPI_WRITE (TXFIFO、大小)；
RF_SPI_WRITE_DATA (TXFIFO、TxBuffer、Size)；
rf_sidle()；
RF_WRITE_STROBE (STX)；
//while (！GDO0_Pin)；
//while (GDO0_Pin)；
RF_WRITE_STROBE (SFTX)；
rf_sidle()；
｝
uint8_t SpiPaketal (uint8_t* RxBuffer、uint8_t*大小)
｛
uint8_t Status[2]；
uint8_t 封装长度；
uint8_t i=(*siz)*4;
uint8_t RSSI_dec = 0；
RF_WRITE_STROBE (SRX)；
HAL_DELAY (10)；
while (GDO2_Pin)
｛
HAL_DELAY (1)；
－－－－一；
如果(i<1)返回0；
｝
IF (SpiDurumOku (RXBYTES)&RXFIFO)
｛
PacketLength = RF_SPI_Read (RXFIFO)；
printf ("@@%d @@\r\n"、PacketLength)；
if (PacketLength <=*大小)
｛
RF_SPI_READ_DATA (RXFIFO、RxBuffer、PacketLength)；
*大小=封装长度；
//数据 Oku
RF_SPI_READ_DATA (RXFIFO、状态、2)；
RSSI_解码= SpiDurumOku (RSSI)；
printf ("RSSI_dec =%d\r\n"、RSSI_dec)；
if (RSSI_dec >= 128)
｛
RSSI_DBM =(int)((int)(RSSI_dec - 256)/ 2)- RSSI_OFFSET；
printf ("RSSI_dec >=128 RSSI_DBM =%d\r\n"、256-RSSI_DBM)；
｝
其他
｛
RSSI_DBM =(RSSI_dec / 2)- RSSI_OFFSET；
printf ("RSSI_dec < 128 RSSI_DBM =%d\r\n"、256-RSSI_DBM)；
｝
RF_WRITE_STROBE (SFRX)；//bufferi 温度
eğer doğruysa (Status[1]|CRC_OK)；//μ s 返回1
｝
其他
｛
*大小=封装长度；
RF_WRITE_STROBE (SFRX)；//bufferi 温度
返回0；
｝
｝
其他
｛
返回0；
｝
｝

*

/*
uint8_t __io_getchar ()｛
uint8_t c；
HAL_UART_Receive (hal_UART、&c、1、10)；
返回 c；
｝

int _read (int 文件、char * ptr、int len)
｛
Int DataIdx；

对于(DataIdx = 0；DataIdx < len；DataIdx++)
｛
*PTR++=__IO_getchar()；
｝

返回 len；
｝
*

main.c

/*用户代码 begin Header */
/**
秘书长的报告
*@文件：main.c
*@简介：主要节目机构
秘书长的报告
*@注意
*
*

版权所有(c) 2020 STMicroelectronics。
*保留所有权利。

*
*此软件组件由 ST 根据 BSD 3条款许可、
*"许可证"；除非符合、否则不得使用此文件
*许可证。 您可以在以下位置获取许可证副本：
* opensource.org/licenses/BSD-3-Clause
*
秘书长的报告
*
/*用户代码结尾标头*/

/*包括------------------------------------------ *
#include "main.h"
#include "rf_driver.h"
/*私有包括---------------------------------------------- *
/*用户代码 begin 包括*/

/*用户代码末尾包括*/

/*私人 typedef ------------------------------------------------------- *
/*用户代码 begin PTD */
void transmit 演示(uint8_t*大小)；

/*用户代码结束 PTD */

/*私人定义------------------------------------------------------- *
/* USER CODE BEGIN PD */
/*用户代码末尾 PD */

/*私有宏------------------------------------------------------- *
/*用户代码 begin PM */

/*用户代码结束 PM */

/*私有变量------------------------------------------------------- *
ADC_HandleTypeDef hadc1；

SPI_HandleTypeDef hspi1；

TIM_HandleTypeDef htim1；

UART_HandleTypeDef huart2；

/*用户代码 begin PV */

/*用户代码末尾 PV */

/*私有函数原型------------------------------------------------------- *
void SystemClock_Config (void)；
静态空 MX_GPIO_Init (空)；
静态空 MX_SPI1_Init (空)；
静态空 MX_USART2_UART_Init (空)；
静态空 MX_TIM1_Init (空)；
静态空 MX_ADC1_Init (空)；
/*用户代码 begin PFP */

/*用户代码末尾 PFP */

/*私人用户代码------------------------------------------------------- *
/*用户代码开始0 */
//uint8_t 版本；
uint8_t* i = 2；
uint8_t txBuffer = 5；
/*用户代码结束0 */

/**
*@简要介绍应用程序入口点。
*@retval int
*
int main (空)
｛
/*用户代码 begin 1 */

/*用户代码结束1 */

/* MCU 配置------------------------------------------------------- *

/*复位所有外设、初始化闪存接口和 SysTick。 *
HAL_Init()；

/*用户代码 begin Init */

/*用户代码结束初始化*/

/*配置系统时钟*/
SystemClock_Config()；

/*用户代码 begin sysinit */

/*用户代码结束 sysinit */

/*初始化所有已配置的外设*/
mx_GPIO_Init()；
mx_SPI1_Init()；
//SPI1 haberleşme 4MHz 250ns DE yapılmaktadır Ω
// CC1101 SPI haberleşmesi için maksimum 10MHz 100ns de olmalıdır
mx_USART2_UART_Init()；
MX_TIM1_Init()；
mx_ADC1_Init()；
/*用户代码 begin 2 */
init_serial (&huart2)；
printf ("############# 4\n");
//Init 射频驱动器
RF_BEGIN (&hspi1、GFSK_1_2_KB、MHz434、CS_GPIO_Port、CS_Pin、 GDO0_Pin)；
//检查是否空闲
rf_sidle()；
uint8_t 结果= RF_SPI_Read (MARCSTATE_R)；
printf ("rresult%#02x (应为0x01)\n"result)；

while (1)｛
Transmit _demo (i)；
HAL_DELAY (100)；
I +=1；
｝
/*用户代码末尾2 */

｝

/**
*@简要系统时钟配置
*@Retval 无
*
空系统时钟配置(空)
｛
RCC_OscInitTypeDef RCC_OscInitStruct=｛0｝；
RCC_ClkInitTypeDef RCC_ClkInitStruct=｛0｝；
RCC_PeriphCLKInitTypeDef PeriphClkInit =｛0｝；

/**配置 LSE 驱动器功能
*
HAL_PWR_EnableBkUpAccess()；
_HAL_RCC_LSEDRIVE_CONFIG (RCC_LSEDRIVE_LOW)；
/**初始化 CPU、AHB 和 APB 总线时钟
*
RCC_OscInitStruct.OscatorType = RCC_OSCILLATORTYPE_HSI|RCC_OSCILLATORTYPE_LSE
|RCC_OSCILATORTYPE_MSI；
RCC_OscInitStruct.LSEState = RCC_LSE_ON；
RCC_OscInitStruct.HSIState = RCC_HSI_ON；
RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT；
RCC_OscInitStruct.MSIState = RCC_MSI_ON；
RCC_OscInitStruct.MSICalibrationValue = 0；
RCC_OscInitStruct.MSIClockRange = RCC_MSIRANGE_6；
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE；
IF (HAL_RCC_OscConfig (&RCC_OscInitStruct）！= HAL_OK)
｛
ERROR_Handler()；
｝
/**初始化 CPU、AHB 和 APB 总线时钟
*
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2；
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI；
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV2；
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1；
RCC_ClkInitStruct.APB2CLK 分频器= RCC_HCLK_DIV1；

if (HAL_RCC_ClockConfig (&RCC_ClkInitStruct, flash_latit_0)！= HAL_OK)
｛
ERROR_Handler()；
｝
PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART2|RCC_PERIPHCLK_ADC；
PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_PCLK1；
PeriphClkInit.AdcClockSelection = RCC_ADCCLKSOURCE_PLLSAI1；
PeriphClkInit.PLLSAI1.PLLSAI1源= RCC_PLLSOURCE_MSI；
PeriphClkInit.PLLSAI1.PLLSAI1M = 1；
PeriphClkInit.PLLSAI1.PLLSAI1N = 16；
PeriphClkInit.PLLSAI1.PLLSAI1P = RCC_PLLP_DIV7；
PeriphClkInit.PLLSAI1.PLLSAI1Q = RCC_PLLQ_DIV2；
PeriphClkInit.PLLSAI1.PLLSAI1R = RCC_PLLR_DIV2；
PeriphClkInit.PLLSAI1.PLLSAI1ClockOut = RCC_PLLSAI1_ADC1CLK；
if (HAL_RCCEx_PeriphCLKConfig (&PeriphClkInit)！= HAL_OK)
｛
ERROR_Handler()；
｝
/**配置主内部稳压器输出电压
*
if (HAL_PWREx_ControlVoltageScaling (PWR_Regulator _VOLTAGE_SCALE1)！= HAL_OK)
｛
ERROR_Handler()；
｝
/**启用 MSI 自动校准
*
HAL_RCCEx_EnableMSIPLLMode()；
｝

/**
*@简要 ADC1初始化函数
*@param 无
*@Retval 无
*
静态空 MX_ADC1_Init (空)
｛

/*用户代码 begin ADC1_Init 0 */

/*用户代码 END ADC1_Init 0 */

ADC_ChannelConfTypeDef sconfig =｛0｝；

/*用户代码 begin ADC1_Init 1 */

/*用户代码 end ADC1_Init 1 */
/**通用配置
*
hadc1.instance = adc1；
hadc1.Init.ClockPrescaler = adc_clock_ASYNC_DIV1；
hadc1.Init.resolution = adc_resolution_12b；
hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT；
hadc1.Init.ScanConvMode = adc_scan_disable；
hadc1.Init.EOCSelSelection = ADC_EPC_Single_CONV；
hadc1.Init.LowPowerAutoWait =禁用；
hadc1.Init.ContinuousConvMode = disable;
hadc1.Init.NbrOfConversion = 1；
hadc1.Init.DiscontinuousConvMode =禁用；
hadc1.Init.NbrOfDiscConversion = 1；
hadc1.Init.ExternalTrigConv = adc_software_start；
hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE；
hadc1.Init.DMAContinuousRequests = disable;
hadc1.Init.Overl溢出= ADC_OVR_DATA_Preserved；
hadc1.Init.OversamplingMode = disable;
if (HAL_ADC_Init（&hadc1)！= HAL_OK)
｛
ERROR_Handler()；
｝
/**配置常规信道
*
sconfig.Channel = ADC_CHANNEL；9；
sconfig.Rank = ADC_Regal_Rank_1；
sconfig.SamplingTime = ADC_SAMPLETIME_2CYCLES_5；
sconfig.SingleDiff = ADC_SINGLE_END_FUST；
sconfig.OffsetNumber = ADC_OFFSET_NONE；
sconfig.Offset = 0；
if (HAL_ADC_ConfigChannel (&hadc1、&sconfig)！= HAL_OK)
｛
ERROR_Handler()；
｝
/*用户代码 begin ADC1_Init 2 */

/*用户代码 end ADC1_Init 2 */

｝

/**
*@SPI1初始化函数简介
*@param 无
*@Retval 无
*
静态空 MX_SPI1_Init (空)
｛

/*用户代码 begin SPI1_Init 0 */

/*用户代码结束 SPI1_Init 0 */

/*用户代码 begin SPI1_Init 1 */

/*用户代码结束 SPI1_Init 1 */
/* SPI1参数配置*/
hspi1.instance = SPI1；
hspi1.Init.Mode = SPI_MODE_MASTER；
hspi1.Init.direction = SPI_DIRECT_2LINES；
hspi1.Init.DataSize = SPI_DATASIZE_4BIT；
hspi1.Init.CLKPolarity = SPI_POLICY_LOW；
hspi1.Init.CLKPhase = SPI_PHASE_1EDGE；
hspi1.Init.nss = SPI_NSS_soft；
hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2；
hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB；
hspi1.Init.TIMode = SPI_TIMDE_DISABLE；
hspi1.Init.CRCCalcirc= SPI_CRCCALCULATION_DISABLE；
hspi1.Init.CRCPolynomial = 7；
hspi1.Init.CRCLength = SPI_CRC_LENGTH_DATAIZE；
hspi1.Init.NSSPMode = SPI_NSS_PULSE_ENABLE；
if (HAL_SPI_Init (&hspi1)！= HAL_OK)
｛
ERROR_Handler()；
｝
/*用户代码 begin SPI1_Init 2 */

/*用户代码结束 SPI1_Init 2 */

｝

/**
*@TIM1初始化函数简介
*@param 无
*@Retval 无
*
静态空 MX_TIM1_Init (空)
｛

/*用户代码 begin TIM1_Init 0 */

/*用户代码结束 TIM1_Init 0 */

TIM_ClockConfigTypeDef sClockSourceConfig =｛0｝；
TIM_MasterConfigTypeDef sMasterConfig =｛0｝；

/*用户代码 begin TIM1_Init 1 */

/*用户代码结束 TIM1_Init 1 */
hdim1.instance = TIM1；
Htim1.Init.Prescaler = 16-1；
Htim1.Init.CounterMode = TIM_COUNTERMODE_UP；
Htim1.Init.period = 0xFFF-1；
Htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1；
hdim1.Init.RefetitionCounter = 0；
htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE；
if (HAL_TIM_Base_Init (&htim1)！= HAL_OK)
｛
ERROR_Handler()；
｝
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL；
if (HAL_TIM_ConfigClockSource (&htim1、&sClockSourceConfig)！= HAL_OK)
｛
ERROR_Handler()；
｝
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET；
sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET；
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE；
if (HAL_Timex_MasterConfigSynchronization (&htim1、&sMasterConfig)！= HAL_OK)
｛
ERROR_Handler()；
｝
/*用户代码 begin TIM1_Init 2 */

/*用户代码结束 TIM1_Init 2 */

｝

/**
*@简要 USART2初始化函数
*@param 无
*@Retval 无
*
静态空 MX_USART2_UART_Init (空)
｛

/*用户代码 begin USART2_Init 0 */

/*用户代码结束 USART2_Init 0 */

/*用户代码 begin USART2_Init 1 */

/*用户代码结束 USART2_Init 1 */
huart2.instance = USART2；
huart2.Init.budrate = 115200；
huart2.Init.WordLength = UART_WORDLENGTH_8B；
huart2.Init.stopbits = UART_stopbits_1；
huart2.Init.Parity = UART_parity；
huart2.Init.Mode = UART_MODE_TX_RX；
huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE；
huart2.Init.overs采样= UART_oversing_16；
huart2.Init.OneBitSampling = UART_one_bit_sample_disable；
huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT；
if (HAL_UART_Init (&huart2)！= HAL_OK)
｛
ERROR_Handler()；
｝
/*用户代码 begin USART2_Init 2 */

/*用户代码结束 USART2_Init 2 */

｝

/**
*@简单 GPIO 初始化函数
*@param 无
*@Retval 无
*
静态空 MX_GPIO_Init (空)
｛
GPIO_InitTypeDef GPIO_InitStruct=｛0｝；

/* GPIO 端口时钟启用*/
_HAL_RCC_GPIOC_CLK_ENABLE()；
_HAL_RCC_GPIOA_CLK_ENABLE ()；
_HAL_RCC_GPIOB_CLK_ENABLE ()；

/*配置 GPIO 引脚输出电平*/
HAL_GPIO_WritePin (CS_GPIO_Port、CS_Pin、GPIO_PIN_RESET)；

/*配置 GPIO 引脚输出电平*/
HAL_GPIO_WritePin (GPIOB、GPIO_PIN_5、GPIO_PIN_RESET)；

/*配置 GPIO 引脚：CS_Pin */
GPIO_InitStruct.Pin = CS_Pin；
GPIO_InitStruct.Mode = GPIO_MODE_OUTPSI_PP；
GPIO_InitStruct.Pull = GPIO_NOPULL；
GPIO_InitStruct.Speed = GPIO_SPED_FREQ_LOW；
HAL_GPIO_Init (CS_GPIO_Port、&GPIO_InitStructt)；

/*配置 GPIO 引脚：GDO0_Pin */
GPIO_InitStruct.Pin = GDO0_Pin；
GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING；
GPIO_InitStruct.Pull = GPIO_NOPULL；
HAL_GPIO_Init (GDO0_GPIO_Port、&GPIO_InitStructt)；

/*配置 GPIO 引脚：PA8 PA9 PA10 */
GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10；
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL；
HAL_GPIO_Init (GPIOA、&GPIO_InitStructt)；

/*配置 GPIO 引脚：PB5 */
GPIO_InitStruct.Pin = GPIO_PIN_5；
GPIO_InitStruct.Mode = GPIO_MODE_OUTPSI_PP；
GPIO_InitStruct.Pull = GPIO_NOPULL；
GPIO_InitStruct.Speed = GPIO_SPED_FREQ_LOW；
HAL_GPIO_Init (GPIOB、&GPIO_InitStructt)；

/*配置 GPIO 引脚：PB7 */
GPIO_InitStruct.Pin = GPIO_PIN_7；
GPIO_InitStruct.Mode = GPIO_MODE_ANALOG；
GPIO_InitStruct.Pull = GPIO_NOPULL；
HAL_GPIO_Init (GPIOB、&GPIO_InitStructt)；

/* EXTI 中断 init*/
HAL_NVIC_setPriority (EXTI0_IRQn、0、0)；
HAL_NVIC_EnableIRQ (EXTI0_IRQn)；

｝

/*用户代码 begin 4 */
void transmit 演示(uint8_t*大小)｛
/*uint8_t data[size]；
int i；
静态 int 计数器= 0；
//data[0]=大小和0xFF；
DATA[0]=大小；
//data[1]=(size>>8)和0xFF；
Data[1]=(size>>8)；
for (i=2；<size; i++){
数据[i]=(i)%256；
}*/

//while (1)｛
if (send_frame (size、sizeof (size))！=frame_OK) printf ("error\n"r)；
//data[size-1]= counter++；

//｝
｝
/*用户代码结束4 */

/**
*@简述如果发生错误、则执行此函数。
*@Retval 无
*
空 Error_Handler (空)
｛
/*用户代码 begin Error_Handler_debug */
/*用户可以添加自己的实现以报告 HAL 错误返回状态*/

/*用户代码 End Error_Handler_debug */
｝

#ifdef use_full_assert
/**
*@brief 会报告源文件的名称和源行号
*发生了 assert_param 错误的位置。
*@param 文件：指向源文件名的指针
*@param 行：assert_param 错误行源代码
*@Retval 无
*
void assert_failed (char *文件、uint32_t 行)
｛
/*用户代码 begin 6 */
/*用户可以添加自己的实施以报告文件名和行号，
TEX：printf ("错误的参数值：第%d\r\n"行上的文件%s、文件、行)*/
/*用户代码结束6 */
｝
#endif /* use_full_assert */

/******** (c)版权所有 STMicroelectronics ***** 文件末尾****/

我在提示我的代码

e2e.ti.com/.../0572.test.zip