接下来看一下几个相关项目的代码。重点看看调制部分是如何实现的。
从难易程度排序，我认为最好先看send_simplified项目，然后再看send和recv项目，最后看BTLE项目(HackRF发射)。
send_simplified项目：
btle_nrf24l01/send_simpified.ino at main · jamesshao8/btle_nrf24l01 · GitHub
这个项目十分简单，里面只有一个ino文件，没有调用RF24库，而是直接完成了编码和底层调用。
开头的几个函数btLeCrc, swapbits, btLeWhitten, btLeWhitenStart, btLePacketEncode都是用于蓝牙包编码的。其中btLePacketEncode调用了其他几个函数，实现的功能类似上一篇提到的把info bit重新编码为phy bit，以便进一步调制。
另外spi_byte, nrf_cmd, nrf_simplebyte, nrf_manybytes，这些函数都是用于底层通信的，后面几个函数都在调用spi_byte，它是最终给SPI总线发数据的接口。
运行的主要流程是先在setup里完成一次性的工作，比如设置nrf24l01硬件模式，包括广播包的标志（类似mac地址）也是setup里做的。
另一个loop函数才是后面重复循环运行的主要内容。开头都在打包，把mac地址，显示名称，数据以及它们的包头、长度都打在buf中，相当于buf先存入了info bit，然后用btLePacketEncode把buf里的内容转换为phy bit，最终再用spi_byte发到SPI总线上去，之后的工作应该是调制，但是这部分没有在代码里实现，这是因为这部分工作完全由nrf24l01芯片负责，arduino单片机不用管这部分的工作。（除此之外，还有对CSN CE引脚的操作，但是这部分代码比较简单，直接用我的代码能跑起来就行，不用深入研究。）
这样send_simplified就看完了。另外两个send/recv项目虽然代码量更多，但其实也是类似原理，arduino只负责编码或者解码，不负责调制和解调，往SPI总线写入和从SPI总线读出的都是phy bit，而不是无线电通信里的sample。
接下来看一下send项目：
btle_nrf24l01/send at main · jamesshao8/btle_nrf24l01 · GitHub
这个项目功能与前面那个项目差不多，但是结构复杂很多。send.ino是主程序，它会调用BTLE.cpp（这是收发低功耗蓝牙数据包共用的库），它又调用了RF24库，对nrf24l01的底层驱动进行了封装，有了RF24就不需要手动往SPI总线上读写数据了。
send.ino里的工作也比较简单，首先初始化了RF24的radio，定义了CSN CE的引脚，还把radio传给了BTLE类，这个很重要，接下来有趣的硬件操作都是围绕着这个radio展开的，而这两个库的类就是在这里建立了联系。
然后setup函数里，btle.begin函数设定了要发送的名字SHARF。后面loop里btle.advertise就是用于循环重复发射数据包的函数。
btle中的begin，包含了先初始化radio也就是radio.begin（往下看的话，都是在RF24.cpp里，最终都是在往SPI总线发命令设置硬件模式）。然后是setAutoAck disableCRC等，这是因为nrf和btle数据包要求不一样，所以要禁用nrf硬件里的crc计算，改用单片机里的代码实现crc，另外也要考虑到半双工通信，所以得把ack关掉，要不然没法和hackrf通信。
然后看看btle里的advertise，它会调用prepare_packet和transmit_packet。前者是在设置发送端的mac地址和名称，后者负责调用whiten和swapbuf函数做编码，最终调用radio->write函数把output里的phy bit发出去。而radio->write，而这个write是在RF24库里的，它调用startFastWrite，startFastWrite又调用write_payload，write_payload里是最终调用SPI总线上的数据发送函数。这样就把phy bit经过spi总线送给nrf24l01，并由硬件进行调制发到空中了。
recv项目：
https://github.com/jamesshao8/btle_nrf24l01/tree/main/recv
它其实和send结构很像，也是一个recv.ino，然后调用BTLE和RF24，这两个库一模一样，只是接收用到的函数可能不一样。 recv.ino一开始初始化radio后，就不停从btle.buffer.payload[i]读数据，并挑出重要部分显示出来。说明btle.buffer.payload[i]对应的是解调+解码后的info bit。还有个btle.listen也很重要，loop不停调用它，才可以不停收数据。打开BTLE.cpp，找到listen函数，它做的就是不停把radio->read读到的数据存到inbuf里，然后用swapbuf和whitten做蓝牙解码。说明inbuf里一开始是phy bit，解码后就变为info bit了，最后再检查crc没问题的话就算是最终解码出来的数据了，这个inbuf和前面说的btle.buffer是同一段内存空间，可以认为就是同一个东西。
然后，我们看看radio->read是怎样读到phy bit的。在RF24.cpp里read调用read_payload，read_payload也是在操纵SPI总线，从总线里读出的数据。说明nrf24l01已经完成了解调，直接把解调输出的phy bit送给了read函数。
这样这3个简单项目就算都看完了。都只做了编解码，没做调制解调。要看调制解调还是得看HackRF用的BTLE项目。
这个项目虽然代码量不少，但是我们感兴趣的只是btle_tx，只对应一个文件：
BTLE/btle_tx.c at master · jamesshao8/BTLE · GitHub
打开btle_tx.c后，发现代码也很长，但是其实我们关心的只是一部分，因为用到的只是其中一种类型的数据包而已。
先找到main函数，它内部调用了2个主要函数parse_input和init_board，init_board就是初始化HackRF硬件（调用API之类的，我们在别的项目里很熟悉了），它也支持另一款BladeRF，但是现在不常用了。
然后重点就是parse_input函数，它是读取命令参数用的，里面也包含根据命令参数进行编码和调制的操作。
找到parse_input函数，它内部比较重要的是calculate_pkt_info和最后的那些printf部分，printf部分就是对应我们在终端窗口里看到的编码前和编码后的bit数据，说明在calculate_pkt_info函数里，已经完成了参数读取，编码运算等操作（实际连调制操作也完成了）。
calculate_pkt_info函数里有get_next_field，在找"-"这个字符，因为这个字符的位置后面跟的就是数据包类型，比如ADV_IND，找到这个关键位置后，再用calculate_sample_from_pkt_type读取数据包，并判断它的类型。
calculate_sample_from_pkt_type中，如果类型就是ADV_IND，就会继续调用calculate_sample_for_ADV_IND函数，进行编码和调制。值得注意的是原始的参数在这几个calculate_sample开头的函数中，都是用参数pkt_str传输的，说明我在命令行里输入的那些参数，都这样一层一层得传递了下来。
然后再找到calculate_sample_for_ADV_IND函数。
它做了4个工作。
1.读取剩余的参数，比如TXADD RXADD ADVA ADVDATA
2.边读取参数，边打包，把数据存入pkt->info_bit，还把暂时的包长存入pkt->num_info_bit
3.使用fill_adv_pdu_header和crc24_and_scramble_to_gen_phy_bit，完成对info_bit的编码，得到了pkt->phy_bit，也就是phy bit。
4.最终用gen_sample_from_phy_bit函数对刚刚得到的phy bit进行调制。这也是我们最关心的部分，是这个函数完成了之前几个arduino项目里由nrf24l01硬件实现的工作。
那么现在就让我们看看gen_sample_from_phy_bit函数：
其实原作者就给这个工作做了好几种实现，我们真正要关注的实际在使用的代码是从1022～1060行的。它的参数bit就是传进去的phy bit，sample就是调制完成后算出来的采样点，num_bit是bit的数量。
要做GFSK调制，其实就分两步，先对phy bit做高斯滤波，然后就是把1010的数据做fsk调制，也就是比如某一时刻的1对应一个频率，下一时刻的0又对应另一个频率。
一开头还做了重采样，唯一要关心的是这一段：
for (i=0; i<(num_bit*SAMPLE_PER_SYMBOL); i++) {
if (i%SAMPLE_PER_SYMBOL == 0) {
tmp_phy_bit_over_sampling_int8[i+(LEN_GAUSS_FILTER*SAMPLE_PER_SYMBOL-1)] = ( bit[i/SAMPLE_PER_SYMBOL] ) * 2 - 1;
} else {
tmp_phy_bit_over_sampling_int8[i+(LEN_GAUSS_FILTER*SAMPLE_PER_SYMBOL-1)] = 0;
}
}它把原始的bit数据传到了tmp_phy_bit_over_sampling_int8数组里了，也就是说后面调制工作都是针对tmp_phy_bit_over_sampling_int8里的数据。
接下来是真正的调制算法：
int16_t tmp = 0;
sample[0] = cos_table_int8[tmp];
sample[1] = sin_table_int8[tmp];
int len_conv_result = num_sample - 1;
for (i=0; i<len_conv_result; i++) {
int16_t acc = 0;
for (j=3; j<(LEN_GAUSS_FILTER*SAMPLE_PER_SYMBOL-4); j++) {
acc = acc + gauss_coef_int8[(LEN_GAUSS_FILTER*SAMPLE_PER_SYMBOL)-j-1]*tmp_phy_bit_over_sampling_int8[i+j];
}
tmp = (tmp + acc)&1023;
sample[(i+1)*2 + 0] = cos_table_int8[tmp];
sample[(i+1)*2 + 1] = sin_table_int8[tmp];
}一开头的sample[0]和sample[1]只是在算初始值，没那么重要。从第一个for循环开始比较重要。
第一个（外部）for循环在做调制，第二个（内部）for循环只是在做高斯滤波
我对高斯滤波其实没那么关心，因为以前解调的经验是，我不管这个高斯滤波器，直接用FSK(FM)解调算法也能解到正确的数据。大概看一下就是说本来应该用下面的公式去增加acc
acc = acc + tmp_phy_bit_over_sampling_int8[i];
现在要做高斯滤波就是在phy bit前乘了一个系数，再做了个小循环而已。为了简化，我们可以令系数为1并且去掉内部的小循环。
在每次进入内部小循环之前acc都初始化为0，如果没内部小循环的话，acc的值就等于tmp_phy_bit_over_sampling_int8，也就是说acc就直接对应了phy bit的0和1。
tmp = (tmp + acc)&1023;
sample[(i+1)*2 + 0] = cos_table_int8[tmp];
sample[(i+1)*2 + 1] = sin_table_int8[tmp];再结合上面的代码看一下，基本就可以明白。
tmp实际上就是正弦波的相位，sample是最终的采样点，由于是iq数据，所以相邻两个一个是cos另一个是sin，我们只看cos，它的参数是tmp，而tmp在不停累加acc，acc就是相位差了。而这些采样点的处理都间隔固定的时间。那么acc就是单位时间的相位差也就是频率了。
如果phy bit是1的话，acc = 1，这样cos table可以输出一个高频正弦波。
而如果phy bit是0，那么acc = 0，那么cos table输出的正弦波频率就是0。如果用频域来理解这两种phy bit对应的信号，就是一个在fft的0Hz，另一个更靠右。这就是2FSK的原理了。
这样这几个项目就都看完了。如果还有更多兴趣，或者对FSK调制理解不深刻，还可以看看gnuradio对应代码。我习惯看3.7版本的gnuradio，里面有gfsk.py，如果你是3.9可能没有。
下面是它的链接：
gnuradio/gfsk.py at maint-3.7 · gnuradio/gnuradio · GitHub
点开代码，它有调制和解调部分。只看调制部分的话，也会看到它在调用gnuradio里实现的高斯滤波器filter.firdes.gaussian，以及frequency_modulator_fc，后者就是FSK的核心代码。
搜索这个函数，在gr-analog/lib/下有一个frequency_modulator_fc_impl.cc文件gnuradio/frequency_modulator_fc_impl.cc at maint-3.7 · gnuradio/gnuradio · GitHub
int frequency_modulator_fc_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
const float* in = (const float*)input_items[0];
gr_complex* out = (gr_complex*)output_items[0];
for (int i = 0; i < noutput_items; i++) {
d_phase = d_phase + d_sensitivity * in[i];
// place phase in [-pi, +pi[
#define F_PI ((float)(M_PI))
d_phase = std::fmod(d_phase + F_PI, 2.0f * F_PI) - F_PI;
float oi, oq;
int32_t angle = gr::fxpt::float_to_fixed(d_phase);
gr::fxpt::sincos(angle, &oq, &oi);
out[i] = gr_complex(oi, oq);
}
return noutput_items;
}上面是它的主要实现。in是输入，相当于是phy bit，out是输出也就是sample。它在用in里的取值决定d_phase。对应相位（变量开头的d只是数据类型double的意思，不是differential的意思），如果in是1，这个值就增长比较快，如果in是0，就不增长（相位增长快其实就是频率高的意思）。然后把相位做转换，先限制幅度为-pi ~ pi的周期内，然后再转为角度形式anlge，再用angle作为参数用sincos函数直接生成复数的正弦波即可。
实现原理和BTLE里的是差不多的，输入的phy bit是1和0，在控制相位的差分（也就是频率）。然后在把相位作为参数给正弦波查找表LUT。然后把正弦波采样值作为sample输出就行。
看完调制原理后就可以回到btle_tx.c里看看调制后的sample是怎么从hackrf的api里发出去的了。
sample在pkt->phy_sample里，而这个pkt最早其实是parse_input函数里的packets[i]传过来的，它来自命令行的参数。parse_input函数里num_repeat是r后面的数字，代表重复运行次数。num_packet代表一次运行的包数量，我一般一次都只运行1各包。
这样也就是说pkt->phy_sample和packets[i].phy_sample就是一回事。main函数里在调用完parse_input后，会调用tx_one_buf函数。
for (j=0; j<num_repeat; j++ ) {
for (i=0; i<num_packet; i++) {
time_pre_pkt = time_current_pkt;
gettimeofday(&time_current_pkt, NULL);
if ( tx_one_buf(packets[i].phy_sample, 2*packets[i].num_phy_sample, packets[i].channel_number) == -1 ){
close_board();
goto main_out;
}
就是这个tx_one_buf函数在使用packets[i].phy_sample作为参数。外面还套了两层循环，由于num_packet对我来说都是1，所以只是num_repeat循环在根据参数r后的数字在循环调用tx_one_buf。
找到tx_one_buf，其实有2个，一个用于bladerf，我们看下面那个用于hackrf的。
它会把输入的第一个参数buf，拷贝给tx_buf。也就是说pkt->phy_sample就给到了tx_buf。而这个tx_buf最终会在tx_callback回调函数里发给hackrf硬件。
inline int tx_one_buf(char *buf, int length, int channel_number) {
int result;
set_freq_by_channel_number(channel_number);
//tx_buf = tx_zeros;
//tx_len = HACKRF_USB_BUF_SIZE-NUM_PRE_SEND_DATA;
tx_buf = buf;
tx_len = length;
// open the board-----------------------------------------
if (open_board() == -1) {
printf("tx_one_buf: open_board() failed\n");
return(-1);
}
// first round TX---------------------------------
stop_tx = 0;
result = hackrf_start_tx(device, tx_callback, NULL);
if( result != HACKRF_SUCCESS ) {
printf("tx_one_buf: hackrf_start_tx() failed: %s (%d)\n", hackrf_error_name(result), result);
return(-1);
}
while( (hackrf_is_streaming(device) == HACKRF_TRUE) &&
(do_exit == false) )
{
if (stop_tx>=9) {
break;
}
}
if (do_exit)
{
printf("\ntx_one_buf: Exiting...\n");
return(-1);
}
if (close_board() == -1) {
printf("tx_one_buf: close_board() failed\n");
return(-1);
}
do_exit = false;
return(0);
}如果你继续看上面代码的下半部分，回发现它在tx_one_buf里要先开启hackrf硬件设置回调函数，然后再关闭这块硬件板子。
这种做法效率不高，因为num_repeat数量比较大，比如50次时，就要调用tx_one_buf 50次，开关硬件板子50次。这样时间会很长。完全可以一开始就初始化好板子，然后让回调函数不停发同样的采样点，等待50次回调就行了。最后发完了再关板子。
因此这个项目的发射间隔确实是有优化空间的。