SI4432射频芯片的内部状态机以及各个状态下的（SI4432最重要的一张图）：
各个状态下系统细节：
SI4432的射频参数设置比较复杂了，需要比较专业的知识才能很好的设置各种参数寄存器，好在Silicon Labs提供了一个计算器，我们只需要提供想要的参数就能给我们计算好射频参数对应的寄存器的值了，这个计算器是一个Excel文件（这操作不错）：
打开之后灰色的栏都是可以自己选择修改的，看到这里我将调频方式设置为FSK（ 移频键控），TX/RX Carrier Frequency设置为868Mhz，数据波特率40Kbps，频偏（FSK调制模式下的一个重要参数）设置为30Khz，下面就是相关寄存器的值了：
再来看SI4432的帧结构：
1、Preamble为前导码，射频芯片通过检测前导码来识别是不是有一帧数据到来，不要太短。
2、Sync Word为同步字，收到前导码之后芯片会检测同步字，没有找到同步字的话则该帧接收失败。该字段可以作为网络地址。
3、TX Header为头码，发射数据的头码和接收端的接收验证头码相同才会产生一帧数据。该字段可以作为节点设备地址。
4、Packet Length为有效数据长度。
5、Data为有效数据。
6、CRC为校验字段。
上诉的所有字段（除了CRC字段）的长度根据配置不同，长度也不同。在 Packet Handler 模式没开启和开启的情况下，帧格式如下：
不使用 Packet Handler 模式的话可以自己在软件上进行地址过滤等操作，但是这些完全可以交给SI4432来做，我使用Packet Handler模式，同时使用非固定帧长度模式、单帧模式 （rx_multi_pk_en = 0），所以发送数据的有效长度范围为 1 ~ 64 Bytes，发送数据的时候（可以先清空Tx FIFO），写入实际需要发送的数据长度 n 到“Register 3Eh. Packet Length”，然后向Tx FIFO中写入 n 字节的数据即可。接收到数据帧长度存放在 “Register 4Bh. Received Packet Length” 中。
设计了一个基于SI4432的USB Dongle：
焊接了两个设备，相距20CM，正常状态下，两个设备都是处于接收状态，不向外发射信号：
软件上（433Mhz Carrier & 9.6Kbps & 30KHz Deviation）以100Hz的速度读取RSSI寄存器的值并显示波形：
这时候无线芯片收到的RSSI值在60到70左右，比较平稳，这可能是环境中存在的已经来自大自然（宇宙）的杂波。SI4432的数据手册对RSSI值的解释：
The RSSI (Received Signal Strength Indicator) signal is an estimate of the signal strength in the channel to which
the receiver is tuned. The RSSI value can be read from an 8-bit register with 0.5 dB resolution per bit. Figure 31
demonstrates the relationship between input power level and RSSI value. The RSSI may be read at anytime, but
an incorrect error may rarely occur. The RSSI value may be incorrect if read during the update period. The update
period is approximately 10 ns every 4 Tb. For 10 kbps, this would result in a 1 in 40,000 probability that the RSSI
may be read incorrectly. This probability is extremely low, but to avoid this, one of the following options is
recommended: majority polling, reading the RSSI value within 1 Tb of the RSSI interrupt, or using the RSSI
threshold described in the next paragraph for Clear Channel Assessment.
再做一些小实验。用手捂住第一个设备然后放开，重复数次：
读取到的RSSI波形：
很明显用手捂住之后RSSI波形变化很大，捂住的时候RSSI值在20左右，有明显的降低，用一张纸遮盖起来没有影响，但是手算是导体，屏蔽效果比较好，如果使用封闭金属容器封盖的话，屏蔽效果会更好。但是手盖住不能完全盖住模块，因为模块下面没有被盖住，我在高楼层，楼下的干扰也会传上来。手持模块在各个角度进行旋转移动，RSSI的值也会有明显的变化。
拿一个手机在模块旁边，RSSI波形几乎没有变化，拨打一个骚扰电话，RSSI波形如下：
手机信号的频率一般如下：
1、中国移动：885-909（上行）、930-954Mhz（下行）；
2、中国联通：909-915（上行）、954-960Mhz（下行）；
3、中国电信：825-835（上行）、870-880Mhz（下行）。
而模块的频率设置为433Mhz，所以打电话的时候干扰不大，如果模块是868Mhz或者915Mhz的话，干扰可能会很大。
然后另一个模块发送数据，发送功率为最高功率20dB，查看RSSI波形：
波形中每产生个波峰都是因为另一个模块发送一次数据（手动触发发送），RSSI波峰值可以达到222左右，因为SI4432中的RSSI寄存器是8位的，最大值是255，所以这里的RSSI值已经很高了，可能是两个模块离得近的原因吧。另外可以会读到两个RSSI峰值，原因是射频发射总时间（测试程序中无线波特率9600bps，发送了8个字节的数据、16个Nibble占8个字节、4个字节的Sync、4个字节的头部，一共24个字节，以9600的波特率算需要大约25ms）大于RSSI的读取打印周期10ms（100Hz），所以会读到两次RSSI峰值。
那么为什么我玩RSSI玩的这么开心呢？我想要实现类似于CSMA/CA的功能，简单来说就是如果无线信道被占用（有设备正在占用信道发送数据），那么就等待一段随机的时间再发送数据。
SI4432芯片内部有一个寄存器："Register 27h. RSSI Threshold for Clear Channel Indicator ，Interrupt is set if the RSSI value is above this threshold."。这个寄存器是用于存储一个阈值，当RSSI的值高于这个阈值的时候，“If the signal strength is above the programmed threshold then a 1 will be shown in the RSSI status bit in "Register 02h. Device Status", "Register 04h. Interrupt/Status 2", or configurable GPIO (GPIOx[3:0] = 11100).”
配置RSSI Threshold的值为100，GPIO2为“11100: Clear Channel Assessment (output)”，软件上读取GPIO2并打印（放大100倍），同时另一个模块手动发送数据：
可以看到在发送数据的时候，接收模块的GPIO2引脚会变成1，表示信道忙。当然了，如果射频芯片不提供硬件“RSSI Threshold”功能，也可以通过SPI读取RSSI值，然后在单片机软件中自己设置一个阈值用于Clear Channel Assessment。接下来在发送数据的时候，先进行Clear Channel Assessment，也就是如果当前GPIO2引脚为1，则表示信道忙，执行退避算法。
附：SI4432操作示例代码（基于STM32F030）
#include "SI4432.h"
unsigned char ItStatus1, ItStatus2;
enum SI4432_FLAGS SI4432_Flags = SI4432_FLAGS_NONE;
const u16 Network_Address = 0x1234;
const u16 Device_Address = 0x0001;
//STM32F030的SPI和STM32F103的SPI不同:
//https://www.amobbs.com/thread-5614282-1-1.html?_dsign=9ffc5097
u8 SPI_RW(u8 data)
{
u16 retry=0;
while((SPI1->SR&SPI_SR_TXE)==0) //等待发送区空
{
// retry++;
// if(retry>=200)return 0; //超时退出
}
*(uint8_t*)&(SPI1->DR)=data; //发送一个byte
retry = 0;
while ((SPI1->SR&SPI_SR_BSY)) //等待接收完一个byte
{
// retry++;
// if(retry>=200)return 0; //超时退出
}
return *(uint8_t*)&(SPI1->DR); //返回收到的数据
}
u8 SI4432_WR(u8 addr,u8 TRdata)
{
u8 status;
CLR_nSEL; //打开SPI片选
SPI_RW(addr);
status = SPI_RW(TRdata);
// while((SPI1->SR&0x0002)==0);
// SPI1->DR = addr;
// while((SPI1->SR&0x0001)==0);
// status = SPI1->DR;
// while((SPI1->SR&0x0002)==0);
// SPI1->DR = TRdata;
// while((SPI1->SR&0x0001)==0);
// status = SPI1->DR;
SET_nSEL; //关闭SPI片选
return status;
}
void SI4432_WriteFIFO(u8 *buff,int plen)
{
CLR_nSEL; //打开SPI片选
SPI_RW(0x7f|0x80);
int i;
for(i=0;i<plen;i++)
SPI_RW(buff[i]);
SET_nSEL; //关闭SPI片选
}
void SI4432_READ_BUF(u8 addr,u8 lenth,u8* data)
{
u8 i;
CLR_nSEL; //打开SPI片选
SPI_RW(addr);
for(i=0;i<lenth;i++)
{
data[i] = SPI_RW(0x00);
}
SET_nSEL; //关闭SPI片选
}
void SI4432_CLR_INT(void)
{
ItStatus1 = SI4432_WR(0x03,0x00); //清掉现有的中断标志
ItStatus2 = SI4432_WR(0x04,0x00); //清掉现有的中断标志
}
void SI4432_EMPTY_BUF(void)
{
SI4432_WR(0x08|0x80, 0x03); //清发射，接收缓冲区
SI4432_WR(0x08|0x80, 0x00);
}
int SI4432_FETCH_DATA(u8 *rx_buf)
{
SI4432_CLR_INT();
int plen = SI4432_WR(0x4B,0x00); //Length Byte of the Received Packet during fixpklen = 0.
SI4432_READ_BUF(0x7f,plen,rx_buf);
SI4432_WR(0x07|0x80,SI4432_PWRSTATE_RX ); // RF 模块进入接收模式
SI4432_EMPTY_BUF();
return plen;
}
void SI4432_SEND_DATA(u8 *buff,int plen)
{
u8 i;
SI4432_EMPTY_BUF();
SI4432_WR(0x3e | 0x80, plen); // 发送帧长度
//先发送低字节
for(i=0;i<plen;i++)
SI4432_WR(0x7f|0x80,buff[i]);
}
void SI4432_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
EXTI_InitTypeDef EXTI_InitStruct;
NVIC_InitTypeDef NVIC_InitStruct;
SPI_InitTypeDef SPI_InitStruct;
/*======================================引脚及时钟初始化=============================================*/
{
/* 使能GPIOA时钟 */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
/* 配置MODULE相应引脚*/
GPIO_InitStructure.GPIO_Pin = SDN_PIN | nSEL_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_SetBits(GPIOA, SDN_PIN);
GPIO_SetBits(GPIOA, nSEL_PIN);
// while(1)
// {
// GPIO_SetBits(GPIOA, SDN_PIN);
// GPIO_SetBits(GPIOA, nSEL_PIN);
// delay_ms(500);
// GPIO_ResetBits(GPIOA, SDN_PIN);
// GPIO_ResetBits(GPIOA, nSEL_PIN);
// delay_ms(500);
// }
// while(1)
// {
// CLR_nSEL;
// delay_ms(1000);
// SET_nSEL;
// delay_ms(1000);
// }
GPIO_InitStructure.GPIO_Pin = nIRQ_PIN | GPIO2_PIN;// | GPIO1_PIN | GPIO2_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource5, GPIO_AF_0);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource6, GPIO_AF_0);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_0);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
SPI_InitStruct.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStruct.SPI_Mode = SPI_Mode_Master;
SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge;
SPI_InitStruct.SPI_NSS = SPI_NSS_Soft;
SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStruct.SPI_CRCPolynomial = 7; //CRC 校验
SPI_Init(SPI1,&SPI_InitStruct);
// SPI_NSSInternalSoftwareConfig(SPI1,SPI_NSSInternalSoft_Set);
// SPI_RxFIFOThresholdConfig(SPI1, SPI_RxFIFOThreshold_QF); //重要，把应答数据位设置为 8 位
SPI_Cmd(SPI1,ENABLE);
// SPI_RW(0xff); //启动传输
// SPI_Init(SPI1);
// SPI_SetSpeed(SPIl; I1,SPI_SPEED_16);
/*===================================================================================================*/
/*======================================接收中断初始化=============================================*/
// RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
//中断初始化
NVIC_InitStruct.NVIC_IRQChannel = EXTI0_1_IRQn;
NVIC_InitStruct.NVIC_IRQChannelPriority = 0x00;
NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStruct);
SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA, EXTI_PinSource1);
EXTI_InitStruct.EXTI_Line = EXTI_Line1;
EXTI_InitStruct.EXTI_LineCmd = ENABLE;
EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling;
EXTI_Init(&EXTI_InitStruct);
DISABLE_INT(1); // 关闭nIRQ引脚中断
/*=================================================================================================*/
}
/*======================================芯片初始化=============================================*/
SET_SDN;
delay_ms(10); // RF 模块上电复位
CLR_SDN;
delay_ms(200); // 延时200ms RF 模块进入工作状态
SI4432_CLR_INT(); // 清RF模块中断
SI4432_WR(0x05 | 0x80, 0x00); // 关闭不需要的中断
SI4432_WR(0x06 | 0x80, 0x00); // 关闭不需要的中断
SI4432_WR(0x07 | 0x80, SI4432_PWRSTATE_READY); // 进入 Ready 模式
SI4432_WR(0x09 | 0x80, 0x1f); // 负载电容= 12P
SI4432_WR(0x0a | 0x80, 0x05); // 关闭低频输出
SI4432_WR(0x0b | 0x80, 0xea); // GPIO 0 当做普通输出口
SI4432_WR(0x0c | 0x80, 0xea); // GPIO 1 当做普通输出口
SI4432_WR(0x0d | 0x80, 0x1C); // GPIO 2 Clear Channel Assessment (output)
SI4432_WR(0x27 | 0x80, 100); //RSSI Threshold for Clear Channel Indicator
{ //使用SI4432计算器《SI443x Register Settings_RevB1-v7》计算
// RX/TX Carrier Frequency Settings:868Mhz
SI4432_WR(0x75 | 0x80, 0x73);
SI4432_WR(0x76 | 0x80, 0x64);
SI4432_WR(0x77 | 0x80, 0x00);
// TX Data Rate Settings:40Kbps
SI4432_WR(0x6e | 0x80, 0x0A); // txdr[15:0] = 0x0A3D;
SI4432_WR(0x6f | 0x80, 0x3D); // DR_TX (bps) = 40Kbps;
SI4432_WR(0x70 | 0x80, 0x0c); // 清除txdtrtscale位
SI4432_WR(0x58 | 0x80, 0x80);
// TX Frequency Deviation Settings:30Khz
SI4432_WR(0x72 | 0x80, 0x30); // 频偏为 30KHz
SI4432_WR(0x71 | 0x80, 0x22); // 发射不需要 CLK，FiFo ， FSK模式
// GFSK/FSK RX Modem Settings
SI4432_WR(0x1c | 0x80, 0x05);
SI4432_WR(0x20 | 0x80, 0x64);
SI4432_WR(0x21 | 0x80, 0x01);
SI4432_WR(0x22 | 0x80, 0x47);
SI4432_WR(0x23 | 0x80, 0xAE);
SI4432_WR(0x24 | 0x80, 0x03);
SI4432_WR(0x25 | 0x80, 0x6C);
SI4432_WR(0x1d | 0x80, 0x3C);
SI4432_WR(0x1e | 0x80, 0x02);
SI4432_WR(0x2a | 0x80, 0xFF);
SI4432_WR(0x1f | 0x80, 0x03);
SI4432_WR(0x69 | 0x80, 0x60);
}
SI4432_WR(0x30 | 0x80, 0x8c); // 使能PH+ FIFO模式，高位在前面，使能CRC校验
SI4432_WR(0x32 | 0x80, 0xff); // byte 0,1,2,3 作为头码
// SI4432_WR(0x33 | 0x80, 0x42); // 4 bytes Header, 非固定帧长度模式, 2 bytes Sync Word
SI4432_WR(0x33 | 0x80, 0x22); // 2 bytes Header, 非固定帧长度模式, 2 bytes Sync Word
SI4432_WR(0x34 | 0x80, 16); // 发射16个Nibble(4 bits)的Preamble
SI4432_WR(0x35 | 0x80, 0x20); // 需要检测4个nibble的Preamble
/*****************Sync Word settings*****************/
SI4432_WR(0x36 | 0x80, (u8)(Network_Address >> 8)); // Sync Word 3
SI4432_WR(0x37 | 0x80, (u8)Network_Address); // Sync Word 2
SI4432_WR(0x38 | 0x80, 0x00); // Sync Word 1 (unused)
SI4432_WR(0x39 | 0x80, 0x00); // Sync Word 0 (unused)
/*****************TX Header settings*****************/
SI4432_WR(0x3a | 0x80, 0x00); // Transmit Header 3
SI4432_WR(0x3b | 0x80, 0x01); // Transmit Header 2
SI4432_WR(0x3c | 0x80, 0); // Transmit Header 1
SI4432_WR(0x3d | 0x80, 0); // Transmit Header 0
SI4432_WR(0x3e | 0x80, 1); // 发送帧长度
/*****************RX Header settings*****************/
SI4432_WR(0x3f | 0x80, (u8)(Device_Address >> 8)); // Check Header 3 'T'
SI4432_WR(0x40 | 0x80, (u8)Device_Address); // Check Header 2 'Q'
SI4432_WR(0x41 | 0x80, 0); // Check Header 1
SI4432_WR(0x42 | 0x80, 0); // Check Header 0
SI4432_WR(0x43 | 0x80, 0xff); // 头码1,2,3,4 的所有位都需要校验
SI4432_WR(0x44 | 0x80, 0xff); //
SI4432_WR(0x45 | 0x80, 0xff); //
SI4432_WR(0x46 | 0x80, 0xff); //
SI4432_WR(0x6d | 0x80, 0x07); // 设置为最大功率发射20dB
SI4432_WR(0x79 | 0x80, 0x0); // 不需要跳频
SI4432_WR(0x7a | 0x80, 0x0); // 不需要跳频
SI4432_WR(0x73 | 0x80, 0x0); // 没有频率偏差
SI4432_WR(0x74 | 0x80, 0x0); // 没有频率偏差
/*====================================芯 片 初 始 化===============================================*/
int i;
printf("\r\n\r\n\r\n\r\n\r\n");
for(i=0;i<=0x7F;i++)
{
u8 a = SI4432_WR(i, 0x00);
printf("%.2X:%.2X\r\n",i,a);
}
// while(1)
// {
// printf("a");
// TX1_RX0;
// delay_ms(500);
// printf("b");
// TX0_RX1;
// delay_ms(500);
// printf("c");
// TX0_RX0;
// delay_ms(500);
// }
// SI4432_EMPTY_BUF();
TX0_RX0; // 天线开关不在发射，接收状态
//默认进入接收状态RXD
// SI4432_RxState();
// SI4432_SwitchState(SI4432_STATE_IDLE_STANDBY);
SI4432_IdleState_Standby();
}
u8 SI4432_RSSI(void)
{
__disable_irq(); //关闭全局中断
u8 tmp = SI4432_WR(0x26, 0x00);
__enable_irq(); //打开全局中断
return tmp;
}
void SI4432_IdleState_Ready(void)
{
/* READY Mode is designed to give a fast transition time to TX mode with reasonable current consumption. In this
mode the Crystal oscillator remains enabled reducing the time required to switch to the TX or RX mode by
eliminating the crystal start-up time. Ready mode is entered by setting xton = 1 in "Register 07h. Operating Mode
and Function Control 1". To achieve the lowest current consumption state the crystal oscillator buffer should be
disabled. This is done by setting "Register 62h. Crystal Oscillator/Power-on-Reset Control" to a value of 02h. To
exit ready mode, bufovr (bit 1) of this register must be set back to 0.*/
SI4432_WR(0x07|0x80, SI4432_PWRSTATE_READY); // 进入 Ready 模式
}
void SI4432_IdleState_Standby(void)
{
/* STANDBY mode has the lowest current consumption possible with only the LPLDO enabled to maintain the
register values. In this mode the registers can be accessed in both read and write mode. The standby mode can be
entered by writing 0h to "Register 07h. Operating Mode and Function Control 1". If an interrupt has occurred (i.e.,
the nIRQ pin = 0) the interrupt registers must be read to achieve the minimum current consumption. Additionally,
the ADC should not be selected as an input to the GPIO in this mode as it will cause excess current consumption. */
SI4432_CLR_INT(); // 清中断
SI4432_WR(0x07|0x80, SI4432_PWRSTATE_STANDBY); // 进入 Standby 模式
}
void SI4432_RxState(void)
{
SI4432_IdleState_Ready();
TX0_RX1;
ENABLE_INT(1); // 打开nIRQ引脚中断
// delay_ms(5);
//先清除中断再设置中断允许寄存器
SI4432_CLR_INT(); // 清中断后开始发射
SI4432_WR(0x05|0x80, SI4432_VALID_PACKET_INTERRUPT); // RF模块收到整包数据后，产生中断
SI4432_WR(0x07|0x80, SI4432_PWRSTATE_RX ); // RF 模块进入接收模式
}
void SI4432_TxState(u8 *buff,int plen)
{
SI4432_IdleState_Ready();
TX1_RX0;
DISABLE_INT(1); // 关闭nIRQ引脚中断
// delay_ms(5);
SI4432_EMPTY_BUF();
SI4432_WR(0x3e|0x80, plen); //发送帧长度
SI4432_WriteFIFO(buff,plen); //写入FIFO
//先清除中断再设置中断允许寄存器
SI4432_CLR_INT(); // 清中断后开始发射
SI4432_WR(0x05|0x80, SI4432_PACKET_SENT_INTERRUPT); // 整包数据发射完后产生中断
SI4432_WR(0x07|0x80, SI4432_PWRSTATE_TX); // 进入发射模式
while(nIRQ); // 等待中断
SI4432_CLR_INT(); // 清中断
ENABLE_INT(1); // 打开nIRQ引脚中断
// printf("ST1:%d ST2:%d \n",ItStatus1,ItStatus2);
// SI4432_RxState(); //rf 发射完成，进入接收模式
SI4432_IdleState_Ready();
}
void EXTI0_1_IRQHandler(void)
{
EXTI->PR |= 1<<1;
SI4432_Flags |= SI4432_FLAGS_NEW_PACKAGE;
}