1. 首页
  2. 文章中心
  3. 学习开发

LoRa SX1278通信代码开发学习前言

119 阅读 0 评论
我是靠谱客的博主 欢喜乌龟，这篇文章主要介绍LoRa SX1278通信代码开发学习前言，现在分享给大家，希望可以做个参考。

前言

最近在学习和摸索LoRa SX1278无线发射模块，其中学到了很多新知识和对SX1278也有了深一点的认识，现在将学习开发中遇到的问题、解决方法、调试完成和低功耗等内容分享出来，也是一种学习记录，方便日后有迹可循，再次学习。
本篇文章可能会比较粗暴一点，直接把需要注意的地方重点介绍一下，可能没有其他文章把每一个小知识点，专用名字都说的那么详尽，怕最后你看完了也不知道哪个是重点了；话不多说，直接来。

准备工具

1、SX1278芯片或者模块
2、主控EFM32（STM32、STM8均可，因为我使用模拟SPI，所以对芯片没要求，有GPIO口就可以）

专有名词

FHSS： 跳频扩频技术 ；
FIFO： 先进先出队列，这里代表队列寄存器

PA ：功率放大器 ；
LNA ：低噪声放大器；
SNR ：信噪比 ；
SF ：扩频因子 ；
PLL ：锁相环 ；
CAD ： 信道活动检测；
CR ：编码率 ；
BW ： 带宽 ；
RS ：符号速率 ；
Preamble ：序头；
其中SF 扩频因子是重点
因为扩频因子越大，传播时间越长。带宽低于62.5K时用TCXO做参考时钟源。在睡眠模式下通过配置寄存器RegOpMode 将FSK调制解调器切换成LoRa调制解调器。
在SX1276_LoRa.c文件中有相关参数的配置

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
tLoRaSettings LoRaSettings =
{
    470000000,        //434000000,        // RFFrequency                                                          //中心频率
    20,               // Power                                                                                    //发射功率
    9,                // SignalBw [0: 7.8kHz, 1: 10.4 kHz, 2: 15.6 kHz, 3: 20.8 kHz, 4: 31.2 kHz,                 //信号带宽
                      // 5: 41.6 kHz, 6: 62.5 kHz, 7: 125 kHz, 8: 250 kHz, 9: 500 kHz, other: Reserved]
    12,                // SpreadingFactor [6: 64, 7: 128, 8: 256, 9: 512, 10: 1024, 11: 2048, 12: 4096  chips]    //扩频因子
    2,                // ErrorCoding [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]                                             //编码率
    true,             // CrcOn [0: OFF, 1: ON]                                                                    //CRC校验开始
    false,            // ImplicitHeaderOn [0: OFF, 1: ON]                                                        //设置隐式报文包
    1,                // RxSingleOn [0: Continuous, 1 Single]                                                    //设置连续接收模式还是单一接收模式
    0,                // FreqHopOn [0: OFF, 1: ON]                                                               //关闭调频模式
    4,                // HopPeriod Hops every frequency hopping period symbols
    1000,              // TxPacketTimeout                                                                        //发送超时时间
    1000,              // RxPacketTimeout                                                                        //接收超时时间
    128,              // PayloadLength (used for implicit header mode)                                           //设置负载长度
};

注意：LoRaSettings结构体里面的配置根据你的需要修改，一般修改扩频因子，频率和发射功率等。

移植代码流程

1、首先我们需要有一个整体思路:
主机发送“PING”字符给从机，从机接收到来自主机的“PING”会回复主机一个“PONG”，如果主机没有收到从机的“PONG”，会进入发送超时，然后主机重新发送“PING”，整个流程就是这样循环下去。

通信的准备：

1、SPI初始化（重中之重）

1.1、可以使用硬件SPI，也可以使用软件SPI；示例代码就是提供硬件SPI，移植性很差，换了芯片就需要更改读写函数，比较麻烦，所以我使用了软件SPI，容易移植。
1.2、网上下载一份SX1278的芯片说明文档、找到关于SPI通信的部分的时序图，如下图：
在这里插入图片描述
如果你不知道模块的SPI通信是什么极性，可以参考一下下面这篇文章的介绍。
https://blog.csdn.net/zwj695535100/article/details/107303648/
1.3、修改SPI读写函数
SX1278是四线的SPI，但是我读写整合成一个函数：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
uint8_t SOFT_SPI_RW_MODE0( uint8_t write_dat )
{
    uint8_t i,temp = 0;
//    SPI_SCK_LOW;     //先将时钟线拉低
    for(i=0;i<8;i++)
    {   
        SCLK_L;     //先将时钟线拉低
        if((write_dat&0x80)== 0x80)  //从高位发送
        {
            MOSI_H;
        }
        else
        {
            MOSI_L;
        }
        
        SCLK_H;  //将时钟线拉高，在时钟上升沿，数据发送到从设备
        
        write_dat<<=1;
        temp<<=1;
        
        if(MISO_R)   //读取从设备发射的数据
        {
            //write_dat|=0x01; 
            temp++;
        }
        SCLK_L;     //在下降沿数据被读取到主机
    }

    return temp;         //返回读取到的数据
}

1.4、修改sx1276_Hal.c文件的读写buffer函数：
写函数

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
void SX1276WriteBuffer( uint8_t addr, uint8_t *buffer, uint8_t size )
{
  addr = addr | 0x80;
  CS_L;//NSS = 0;
  SOFT_SPI_RW_MODE0(addr);
//  spiNByteSend(buffer,size);
   for (uint8_t i = 0; i < size; i++) 
   {
      SOFT_SPI_RW_MODE0(buffer[i]);
   }
  CS_H; //NSS = 1;
}

读函数

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
void SX1276ReadBuffer( uint8_t addr, uint8_t *buffer, uint8_t size )
{
   addr = addr & 0x7F;
   CS_L;//NSS = 0;
   SOFT_SPI_RW_MODE0(addr);
   for (uint8_t i = 0; i < size; i++) 
   {
          buffer[i] = SOFT_SPI_RW_MODE0(0xff);
   }
//   spiNByteSend(buffer,size);
   
   CS_H; //NSS = 1;
}

注意：
1、CS片选管脚记得修改成你自己选择的GPIO口。
2、SPI初始化管脚这些太基础的就不说了，但是要注意配置输入和输出的关系。
这样我们的SPI初始化算完成了，这一步是最基础的，如果这一步出错后面就玩不下去了。

2、SX1278的初始化
复制代码
1
2
3
   Radio = RadioDriverInit();
   Radio->Init();

2.1、RadioDriverInit();
此函数是用来芯片选型的，在官方例程或者网上其他地方下载的例程中，SX1278、SX1276、SX1272、SX1232都是通过此函数对选好的芯片类型进行初始化。
SX1278和SX1276是使用同一个配置！
2.2、Radio->Init();
此函数是对SX1278所有的配置参数进行配置，会调用SX1276Init（）函数，如下：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
void SX1276Init( void )
{
// static uint8_t spi_test=0;
// Initialize FSK and LoRa registers structure
   SX1276 = ( tSX1276* )SX1276Regs;
   SX1276LR = ( tSX1276LR* )SX1276Regs;
//    memset(SX1276,(int)0,sizeof(tSX1276));
//    memset(SX1276LR,(int)0,sizeof(tSX1276LR));
   SX1276Reset( );
   SX1276LoRaSetOpMode(RFLR_OPMODE_STANDBY);
// GetOpMode_test = SX1276LoRaGetOpMode();
// REMARK: After radio reset the default modem is FSK
#if ( LORA == 0 ) 
    LoRaOn = false;
    SX1276SetLoRaOn( LoRaOn );
    // Initialize FSK modem
    SX1276FskInit( );
#else
    LoRaOn = true;
    LoRaOnState = false;
    SX1276SetLoRaOn( LoRaOn );
    // Initialize LoRa modem
    SX1276LoRaInit( );
#endif
   // SX1276LoRaSetPreambleLength(100);
}

2.2.1、SX1276LR = ( tSX1276LR* )SX1276Regs;
这个SX1276Regs是SX1278初始化正常接收返回参数存放的数组，SPI通信正常，它里面存放的码流应该如下：
在这里插入图片描述
2.2.2、复位函数：SX1276Reset( );

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void SX1276Reset( void )
{
    uint32_t startTick;
    SX1276SetReset( RADIO_RESET_ON );
    
    // Wait 1ms
    startTick = GET_TICK_COUNT( );
    while( ( GET_TICK_COUNT( ) - startTick ) < TICK_RATE_MS(1) );    
    SX1276SetReset( RADIO_RESET_OFF );
    
    // Wait 6ms
    startTick = GET_TICK_COUNT( );
    while( ( GET_TICK_COUNT( ) - startTick ) < TICK_RATE_MS(6) );  
}

//嘀嗒定时器修改成你当前使用芯片的
#define GET_TICK_COUNT( )                           ( TickCounter )
void SysTick_Handler(void)
{
    TickCounter++;
    msTicks++;
}

注意：复位管脚需要修改和你对应的管脚，不然程序会在SX1276Reset跑死了。
2.2.3、映射函数
SX1276SetLoRaOn( LoRaOn )和SX1276LoRaInit( )函数
这两个函数一般不需要改动，里面都是Lora的一些基础参数的配置初始化，但是需要说一下IO口映射函数
在SX1276SetLoRaOn和sx1276_LoRa.c文件中的SX1276LoRaProcess函数都有映射函数。

复制代码
1
2
3
4
5
6
                            // RxDone                    RxTimeout                   FhssChangeChannel           CadDone
SX1276LR->RegDioMapping1 = RFLR_DIOMAPPING1_DIO0_00 | RFLR_DIOMAPPING1_DIO1_00 | RFLR_DIOMAPPING1_DIO2_00 | RFLR_DIOMAPPING1_DIO3_00;
                                   // PllLock              ModeReady
SX1276LR->RegDioMapping2 = RFLR_DIOMAPPING2_DIO4_01 | RFLR_DIOMAPPING2_DIO5_00;
SX1276WriteBuffer( REG_LR_DIOMAPPING1, &SX1276LR->RegDioMapping1, 2 );                 //映射到对应的IO口，检测相应的IO口是否收发完成。

映射到IO口主要的作用是在SX1276LoRaProcess（）函数中，当状态 RFLRState = RFLR_STATE_RX_RUNNING的时候，需要读取IO口是否有收到数据，才可以进入下一步，否则进入超时接收，会进入再次发送的流程，循环往复。
DIO可以设置不同的状态，在SX1278上有说明：
在这里插入图片描述

初始化的大致流程就这样差不多了，还有一些细节的问题就需要去需要再摸索一下，后续有更多更深的理解我会再写文章总结。

3、主函数
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
int main(void)
{
   HW_Int();//MCU初始化
   Radio = RadioDriverInit();
   Radio->Init();
   
   if(EnableMaster == true)
   {
     TXBuffer[0] = 'P';
     TXBuffer[1] = 'I';
     TXBuffer[2] = 'N';
     TXBuffer[3] = 'G';
     crc_value=RadioComputeCRC(TXBuffer,4,CRC_TYPE_IBM);//计算得出要发送数据包CRC值
     TXBuffer[4]=crc_value>>8;
     TXBuffer[5]=crc_value;
     Radio->SetTxPacket(TXBuffer,6);//打包要发送的数据包
    }
   else
   {
       Radio->StartRx();
   }
   
  while(1)
  { 
     if(EnableMaster == true)
      {  
        OnMaster();
      }    
      else
      {
        OnSlave();
      }
  }
}

主函数开始就是把你用到的初始化好了，然后根据你是选择主机还是从机进入对应的函数，定义主机或者从机函数在文件头部；

复制代码
1
2
bool  EnableMaster = true;//主从选择 true为主 false 为从

主机函数

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
/*
 * Manages the master operation
 */
void OnMaster( void )
{  
    switch(Radio->Process())
    {
      case RF_TX_DONE:
           
	       Radio->StartRx( ); 
      break;
		
      case RF_RX_DONE:
        Radio->GetRxPacket( RXBuffer, ( uint16_t* )&num_rx );
        
        if(num_rx > 0)
        {
           crc_value=RXBuffer[num_rx-2];
           crc_value<<=8;
           crc_value|=RXBuffer[num_rx-1];
           if(crc_value==RadioComputeCRC(RXBuffer,num_rx-2,CRC_TYPE_IBM))//CRC check
           {
            if(strncmp(( const char* )RXBuffer, ( const char* )PongMsg,4)==0)
            {
                  LedToggle();//LED闪烁
                 
                 // Send the next PING frame            
		  TXBuffer[0] = 'P';
                  TXBuffer[1] = 'I';
                  TXBuffer[2] = 'N';
                  TXBuffer[3] = 'G';
                  crc_value=RadioComputeCRC(TXBuffer,4,CRC_TYPE_IBM);//计算得出要发送数据包CRC值
                  TXBuffer[4]=crc_value>>8;
                  TXBuffer[5]=crc_value;
			      
                  Radio->SetTxPacket( TXBuffer, 6);	
            }
           }
        }            
        break;
        
        case RF_RX_TIMEOUT:
        // Send the next PING frame
        TXBuffer[0] = 'P';
        TXBuffer[1] = 'I';
        TXBuffer[2] = 'N';
        TXBuffer[3] = 'G';
        crc_value = RadioComputeCRC(TXBuffer,4,CRC_TYPE_IBM);//计算得出要发送数据包CRC值
        TXBuffer[4] = crc_value>>8;
        TXBuffer[5] = crc_value;
			      		 
        Radio->SetTxPacket( TXBuffer, 6);
        break;
				
        
     default:break;
    }
}

运行主机函数，他会跑进去sx1276_LoRa.c文件中的SX1276LoRaProcess函数读取SX1278的状态机，根据当前的状态来进行对应的操作；它的包含的状态都在下面的结构体中：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
typedef enum
{
    RFLR_STATE_IDLE,
    RFLR_STATE_RX_INIT,
    RFLR_STATE_RX_RUNNING,
    RFLR_STATE_RX_DONE,
    RFLR_STATE_RX_TIMEOUT,
    RFLR_STATE_TX_INIT,
    RFLR_STATE_TX_RUNNING,
    RFLR_STATE_TX_DONE,
    RFLR_STATE_TX_TIMEOUT,
    RFLR_STATE_CAD_INIT,
    RFLR_STATE_CAD_RUNNING,
}tRFLRStates;

在SX1276LoRaProcess函数中，一般都不需要修改，只需要注意一个地方，就是下面两个：
如果你是主机需要注意

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 case RFLR_STATE_TX_RUNNING:
   if( DIO0 == 1 ) // TxDone
   {
       // Clear Irq
       SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_TXDONE  );
       RFLRState = RFLR_STATE_TX_DONE;   
   }
   if( DIO2 == 1 ) // FHSS Changed Channel 
   {
       if( LoRaSettings.FreqHopOn == true )
       {
           SX1276Read( REG_LR_HOPCHANNEL, &SX1276LR->RegHopChannel );
           SX1276LoRaSetRFFrequency( HoppingFrequencies[SX1276LR->RegHopChannel & RFLR_HOPCHANNEL_CHANNEL_MASK] );
       }
       // Clear Irq
       SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL );
   }
   break;

如果你是从机需要注意

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 case RFLR_STATE_RX_RUNNING:
     if( DIO0 == 1 ) // RxDone
     {
         RxTimeoutTimer = GET_TICK_COUNT( );
         if( LoRaSettings.FreqHopOn == true )
         {
             SX1276Read( REG_LR_HOPCHANNEL, &SX1276LR->RegHopChannel );
             SX1276LoRaSetRFFrequency( HoppingFrequencies[SX1276LR->RegHopChannel & RFLR_HOPCHANNEL_CHANNEL_MASK] );
         }
         // Clear Irq
         SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_RXDONE  );
         RFLRState = RFLR_STATE_RX_DONE;
     }
     if( DIO2 == 1 ) // FHSS Changed Channel
     {
         RxTimeoutTimer = GET_TICK_COUNT( );
         if( LoRaSettings.FreqHopOn == true )
         {
             SX1276Read( REG_LR_HOPCHANNEL, &SX1276LR->RegHopChannel );
             SX1276LoRaSetRFFrequency( HoppingFrequencies[SX1276LR->RegHopChannel & RFLR_HOPCHANNEL_CHANNEL_MASK] );
         }
         // Clear Irq
         SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL );
         // Debug
         RxGain = SX1276LoRaReadRxGain( );
     }

     if( LoRaSettings.RxSingleOn == true ) // Rx single mode
     {
         if( ( GET_TICK_COUNT( ) - RxTimeoutTimer ) > PacketTimeout )
         {
             RFLRState = RFLR_STATE_RX_TIMEOUT;
         }
     }
     break;

需要注意的就是Io1、Io2这些映射口的状态，如果你没有像上面的正确配置映射口，可能函数会一直在那里进行死循环操作，就无法进入下一步，最后通信失败；我的板子因为没有接Io1和Io2的引脚，所以我不能直接读取管脚状态进行下一步，但是SX1278手册里面有说到可以读取寄存器RegIrqFlags（0x12）也可以获取到是否可以正常发送或者接收
在这里插入图片描述所以我把发射和接收的函数改造了一下，如下：

复制代码
1
2
3
4
5
6
7
8
9
10
11
//主机
uint8_t flag = 0;
case RFLR_STATE_TX_RUNNING: 
    SX1276Read( REG_LR_IRQFLAGS, &flag);                        //读取发送完成标志位
     if(flag & RFLR_IRQFLAGS_TXDONE)                            //判断发送完成标志位    
    {   // Clear Irq
        SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_TXDONE);
        RFLRState = RFLR_STATE_TX_DONE;
    }
    break;

注意：IO2是FHSS Changed Channel，我没用到，所以我去改写，如果需要改写也是一样的，只需要修改 if(flag & RFLR_IRQFLAGS_TXDONE) ，与上对应的寄存器就好了。

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//从机
uint8_t flag = 0;
case RFLR_STATE_RX_RUNNING:
    SX1276Read( REG_LR_IRQFLAGS, &flag);                        //读取发送完成标志位
     if(flag & RFLR_IRQFLAGS_RXDONE)                            //判断发送完成标志位  
    {
        RxTimeoutTimer = GET_TICK_COUNT( );
        if( LoRaSettings.FreqHopOn == true )
        {
            SX1276Read( REG_LR_HOPCHANNEL, &SX1276LR->RegHopChannel );
            SX1276LoRaSetRFFrequency( HoppingFrequencies[SX1276LR->RegHopChannel & RFLR_HOPCHANNEL_CHANNEL_MASK] );
        }
        // Clear Irq
        SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_RXDONE  );
        RFLRState = RFLR_STATE_RX_DONE;
    }
    if( LoRaSettings.RxSingleOn == true ) // Rx single mode
    {
        uint32_t TimeCount = GET_TICK_COUNT( ) - RxTimeoutTimer;
        if( ( GET_TICK_COUNT( ) - RxTimeoutTimer ) > PacketTimeout )
        {
            RFLRState = RFLR_STATE_RX_TIMEOUT;               
        }
    }
    break;

从机的原理也是一样的，我就不罗嗦了，还有相关的宏定义是在头文件sx1276_LoRa.h

复制代码
1
2
3
4
5
6
7
8
9
#define RFLR_IRQFLAGS_RXTIMEOUT                     0x80 
#define RFLR_IRQFLAGS_RXDONE                        0x40 
#define RFLR_IRQFLAGS_PAYLOADCRCERROR               0x20 
#define RFLR_IRQFLAGS_VALIDHEADER                   0x10 
#define RFLR_IRQFLAGS_TXDONE                        0x08 
#define RFLR_IRQFLAGS_CADDONE                       0x04 
#define RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL            0x02 
#define RFLR_IRQFLAGS_CADDETECTED                   0x01

上面的修改完之后，通信配置就基本完成，就应该能正常通信上了，如果没有通信上，就需要检查一下其他细节的问题，或者在底下评论一起探讨。
我将通信的buffer在串口上打印出来，因为我只用一台电脑，所以我只能切换不同串口来看打印信息：
在这里插入图片描述

总结

好了，以上就是我最近学习SX1278的学习心得和总结，分享出来主要是对自己学习过程中遇到的问题的一个梳理，还有就是让一些刚开始接触LoRa通信的同学提供一下帮助，更重要是方便以后再用到的时候，也可以有迹可循；如果文章有什么错误的地方或者有不明白的地方，欢迎评论区留言，我们一起探讨。

代码

源代码我晚一点分享链接，我自己移植的代码涉及到公司机密问题就不贴出来了。
源代码百度网盘：
链接：https://pan.baidu.com/s/1DZEGECa2WiUH4YsNbMp4yQ
提取码：gy3u

最后

以上就是欢喜乌龟最近收集整理的关于LoRa SX1278通信代码开发学习前言的全部内容，更多相关LoRa内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(79)

相关文章

新科LoRa网关和LoRa节点
新科LoRa网关和LoRa节点
LoRa扩频无线传输穿墙测试
LoRa扩频无线传输穿墙测试
Contiki开发2：工具和环境
Contiki开发2：工具和环境
STM8L151C8单片机学习例程（15）——Contiki_OS_LED
STM8L151C8单片机学习例程（15）——Contiki_OS_LED
LoRa SX1278通信代码开发学习前言
LoRa SX1278通信代码开发学习前言
LORA 射频自组网 两级中继
LORA 射频自组网 两级中继
跨湘江 LoRa 拉距测试 6 公里                        跨湘江 LoRaWAN 拉距测试 6 公里
跨湘江 LoRa 拉距测试 6 公里                        跨湘江 LoRaWAN 拉距测试 6 公里
lora发射和接收原理_LoRa 的扩频技术LoRa 的扩频技术扩频概念及原理传输速率和距离 为什么使用扩频
lora发射和接收原理_LoRa 的扩频技术LoRa 的扩频技术扩频概念及原理传输速率和距离 为什么使用扩频

评论列表共有 0 条评论

立即
投稿
返回
顶部