0301_BOOT/SX127x/sx1276-LoRa.c

/*
 * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND
 * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
 * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
 * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
 * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
 * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
 *
 * Copyright (C) SEMTECH S.A.
 */
/*!
 * \file       sx1276-LoRa.c
 * \brief      SX1276 RF chip driver mode LoRa
 *
 * \version    2.0.B2
 * \date       May 6 2013
 * \author     Gregory Cristian
 *
 * Last modified by Miguel Luis on Jun 19 2013
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "timer.h"


#if defined( USE_SX1276_RADIO )

#include "radio.h"

#include "sx1276-Hal.h"
#include "sx1276.h"

#include "sx1276-LoRaMisc.h"
#include "sx1276-LoRa.h"
//#include "debug.h"
//#include "process.h"
//#include "led.h"
#include "usart.h"
//#include "LoraComm.h"
/*!
 * Constant values need to compute the RSSI value
 */
#define RSSI_OFFSET_LF                              -155.0
#define RSSI_OFFSET_HF                              -150.0

#define NOISE_ABSOLUTE_ZERO                         -174.0

#define NOISE_FIGURE_LF                                4.0
#define NOISE_FIGURE_HF                                6.0


/*!
 * Precomputed signal bandwidth log values
 * Used to compute the Packet RSSI value.
 */
const double SignalBwLog[] =
{
    3.8927900303521316335038277369285,  // 7.8 kHz
    4.0177301567005500940384239336392,  // 10.4 kHz
    4.193820026016112828717566631653,   // 15.6 kHz
    4.31875866931372901183597627752391, // 20.8 kHz
    4.4948500216800940239313055263775,  // 31.2 kHz
    4.6197891057238405255051280399961,  // 41.6 kHz
    4.795880017344075219145044421102,   // 62.5 kHz
    5.0969100130080564143587833158265,  // 125 kHz
    5.397940008672037609572522210551,   // 250 kHz
    5.6989700043360188047862611052755   // 500 kHz
};

const double RssiOffsetLF[] =
{   // These values need to be specify in the Lab
    -155.0,
    -155.0,
    -155.0,
    -155.0,
    -155.0,
    -155.0,
    -155.0,
    -155.0,
    -155.0,
    -155.0,
};

const double RssiOffsetHF[] =
{   // These values need to be specify in the Lab
    -150.0,
    -150.0,
    -150.0,
    -150.0,
    -150.0,
    -150.0,
    -150.0,
    -150.0,
    -150.0,
    -150.0,
};

/*!
 * Frequency hopping frequencies table
 */
const int32_t HoppingFrequencies[] =
{
    916500000,
    923500000,
    906500000,
    917500000,
    917500000,
    909000000,
    903000000,
    916000000,
    912500000,
    926000000,
    925000000,
    909500000,
    913000000,
    918500000,
    918500000,
    902500000,
    911500000,
    926500000,
    902500000,
    922000000,
    924000000,
    903500000,
    913000000,
    922000000,
    926000000,
    910000000,
    920000000,
    922500000,
    911000000,
    922000000,
    909500000,
    926000000,
    922000000,
    918000000,
    925500000,
    908000000,
    917500000,
    926500000,
    908500000,
    916000000,
    905500000,
    916000000,
    903000000,
    905000000,
    915000000,
    913000000,
    907000000,
    910000000,
    926500000,
    925500000,
    911000000,
};

// Default settings
tLoRaSettings LoRaSettings =
{
    433920000,        // 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]
    7,               // SpreadingFactor [6: 64, 7: 128, 8: 256, 9: 512, 10: 1024, 11: 2048, 12: 4096  chips]
    1,                // ErrorCoding [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
    true,             // CrcOn [0: OFF, 1: ON]
    false,            // ImplicitHeaderOn [0: OFF, 1: ON]//0为显示报头模式，1为隐式，显示报头模式下可以读取任意长度数据，数据长度包含在虚头中，隐式只能读取指定长度，且收发必须一致
											//在负载长度以知道的情况下调用隐式可缩短发送时间
    0,                // RxSingleOn [0: Continuous, 1 Single]
    0,                // FreqHopOn [0: OFF, 1: ON]
    4,                // HopPeriod Hops every frequency hopping period symbols
    100,              // TxPacketTimeout
    100,              // RxPacketTimeout
    128,              // PayloadLength (used for implicit header mode)
};

/*!
 * SX1276 LoRa registers variable
 */
tSX1276LR* SX1276LR;

/*!
 * Local RF buffer for communication support
 */
//static uint8_t RFBuffer[RF_BUFFER_SIZE];
uint8_t RFBuffer[RF_BUFFER_SIZE];

/*!
 * RF state machine variable
 */
static uint8_t RFLRState = RFLR_STATE_IDLE;

/*!
 * Rx management support variables
 */
static uint16_t RxPacketSize = 0;
static int8_t RxPacketSnrEstimate;
static double RxPacketRssiValue;
static uint8_t RxGain = 1;
static uint32_t RxTimeoutTimer = 0;
static uint32_t TxTimeoutTimer = 0;
/*!
 * PacketTimeout Stores the Rx window time value for packet reception
 */
static uint32_t PacketTimeout;

/*!
 * Tx management support variables
 */
static uint16_t TxPacketSize = 0;

/************************************************
函数名称 ： SX1276LoRaInit
功    能 ： Lora初始化
参    数 ： 无
返 回 值 ： 无
作    者 ： sun
*************************************************/
void SX1276LoRaInit( void )
{
   RFLRState = RFLR_STATE_IDLE;

    SX1276LoRaSetDefaults( );

    SX1276ReadBuffer( REG_LR_OPMODE, SX1276Regs + 1, 0x70 - 1 );

    SX1276LR->RegLna = RFLR_LNA_GAIN_G1;

    SX1276WriteBuffer( REG_LR_OPMODE, SX1276Regs + 1, 0x70 - 1 );

    // set the RF settings
    SX1276LoRaSetRFFrequency( LoRaSettings.RFFrequency );
    SX1276LoRaSetPa20dBm( true );
    SX1276LoRaSetRFPower( LoRaSettings.Power );
    SX1276LoRaSetSpreadingFactor( LoRaSettings.SpreadingFactor ); // SF6 only operates in implicit header mode.
    SX1276LoRaSetErrorCoding( LoRaSettings.ErrorCoding );
    SX1276LoRaSetPacketCrcOn( LoRaSettings.CrcOn );
    SX1276LoRaSetSignalBandwidth( LoRaSettings.SignalBw );

    SX1276LoRaSetImplicitHeaderOn( LoRaSettings.ImplicitHeaderOn );
    SX1276LoRaSetSymbTimeout( 0x3FF );
    SX1276LoRaSetPayloadLength( LoRaSettings.PayloadLength );
    SX1276LoRaSetLowDatarateOptimize( true );

    SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
}


/************************************************
函数名称 ： SX1276LoraConfigCheck
功    能 ： Lora 初始化信息检查，防止配置信息出错
参    数 ： 无
返 回 值 ： bool 成功为1  失败为0
作    者 ： sun
*************************************************/

bool SX1276LoraConfigCheck(void)
{
		if((LoRaSettings.RFFrequency <137000000)||(LoRaSettings.RFFrequency >525000000))
        return false;
		if(LoRaSettings.SignalBw > 9)
			return false;
		if((LoRaSettings.SpreadingFactor < 6)||(LoRaSettings.SpreadingFactor >12))
        return false;
		if((LoRaSettings.ErrorCoding < 1)||(LoRaSettings.ErrorCoding >4))
        return false;	
		if(LoRaSettings.PayloadLength  > 128)
			return false;
		return true ;
}


/************************************************
函数名称 ： SX1276LoRaSetDefaults
功    能 ： 读取芯片版本号
参    数 ： 无
返 回 值 ： 无
作    者 ： sun
*************************************************/
void SX1276LoRaSetDefaults( void )
{
    // REMARK: See SX1276 datasheet for modified default values.

    SX1276Read( REG_LR_VERSION, &SX1276LR->RegVersion );
}
/************************************************
函数名称 ： SX1276LoRaReset
功    能 ： Lora芯片重启
参    数 ： 无
返 回 值 ： 无
作    者 ： sun
*************************************************/
void SX1276LoRaReset( 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 ) );
}

/************************************************
函数名称 ： SX1276LoRaSetOpMode
功    能 ： 设置Lora工作模式
参    数 ： opMode  运行模式
						
返 回 值 ： 无
作    者 ： sun
*************************************************/

void SX1276LoRaSetOpMode( uint8_t opMode )
{
    static uint8_t opModePrev = RFLR_OPMODE_STANDBY;
    static bool antennaSwitchTxOnPrev = true;
    bool antennaSwitchTxOn = false;

    opModePrev = SX1276LR->RegOpMode & ~RFLR_OPMODE_MASK;

    if( opMode != opModePrev )
    {
        if( opMode == RFLR_OPMODE_TRANSMITTER )
        {
            antennaSwitchTxOn = true;
        }
        else
        {
            antennaSwitchTxOn = false;
        }
        if( antennaSwitchTxOn != antennaSwitchTxOnPrev )
        {
            antennaSwitchTxOnPrev = antennaSwitchTxOn;
            RXTX( antennaSwitchTxOn ); // Antenna switch control
        }
        SX1276LR->RegOpMode = ( SX1276LR->RegOpMode & RFLR_OPMODE_MASK ) | opMode;

		SX1276Write( REG_LR_OPMODE, SX1276LR->RegOpMode );
    }
}


/************************************************
函数名称 ： SX1276LoRaGetOpMode
功    能 ： 读取当前Lora工作模式
参    数 ： 无					
返 回 值 ： 当前工作模式
作    者 ： sun
*************************************************/
uint8_t SX1276LoRaGetOpMode( void )
{
    SX1276Read( REG_LR_OPMODE, &SX1276LR->RegOpMode );

    return SX1276LR->RegOpMode & ~RFLR_OPMODE_MASK;
}

uint8_t SX1276LoRaReadRxGain( void )
{
    SX1276Read( REG_LR_LNA, &SX1276LR->RegLna );
    return( SX1276LR->RegLna >> 5 ) & 0x07;
}

/************************************************
函数名称 ： SX1276LoRaReadRssi
功    能 ： 读取计算Lora信号强度
参    数 ： 无
						
返 回 值 ： 返回值 为信号强度
作    者 ： sun
*************************************************/
double SX1276LoRaReadRssi( void )
{
    // Reads the RSSI value
    SX1276Read( REG_LR_RSSIVALUE, &SX1276LR->RegRssiValue );

    if( LoRaSettings.RFFrequency < 860000000 )  // LF
    {
        return RssiOffsetLF[LoRaSettings.SignalBw] + ( double )SX1276LR->RegRssiValue;
    }
    else
    {
        return RssiOffsetHF[LoRaSettings.SignalBw] + ( double )SX1276LR->RegRssiValue;
    }
}
/************************************************
函数名称 ： SX1276LoRaGetPacketSnr
功    能 ： 获取Lora信噪比
参    数 ： 无
						
返 回 值 ： 返回值 信噪比
作    者 ： sun
*************************************************/
uint8_t SX1276LoRaGetPacketRxGain( void )
{
    return RxGain;
}

int8_t SX1276LoRaGetPacketSnr( void )
{
    return RxPacketSnrEstimate;
}
/************************************************
函数名称 ： SX1276LoRaGetPacketRssi
功    能 ： 读Lora信号强度
参    数 ： 无
						
返 回 值 ： 返回值 为信号强度
作    者 ： sun
*************************************************/
double SX1276LoRaGetPacketRssi( void )
{
    return RxPacketRssiValue;
}
/************************************************
函数名称 ： SX1276LoRaStartRx
功    能 ： Lora开始接收
参    数 ： 无
						
返 回 值 ： 无
作    者 ： sun
*************************************************/
void SX1276LoRaStartRx( void )
{
    SX1276LoRaSetRFState( RFLR_STATE_RX_INIT );
}
/************************************************
函数名称 ： SX1276LoRaGetRxPacket
功    能 ： Lora获取接收数据
参    数 ： buffer 接收缓存器
						接收到的数据长度
返 回 值 ： 无
作    者 ： sun
*************************************************/
void SX1276LoRaGetRxPacket( void *buffer, uint16_t *size )
{
    *size = RxPacketSize;
    RxPacketSize = 0;
    memcpy( ( void * )buffer, ( void * )RFBuffer, ( size_t )*size );
}
/************************************************
函数名称 ： SX1276LoRaSetTxPacket
功    能 ： Lora开始发送
参    数 ： buffer 发送缓存器
						size   发送的数据长度
返 回 值 ： 无
作    者 ： sun
*************************************************/
void SX1276LoRaSetTxPacket( const void *buffer, uint16_t size )
{
    if( LoRaSettings.FreqHopOn == false )
    {
        TxPacketSize = size;
    }
    else
    {
        TxPacketSize = 255;
    }
    memcpy( ( void * )RFBuffer, buffer, ( size_t )TxPacketSize );

    RFLRState = RFLR_STATE_TX_INIT;
}

/************************************************
函数名称 ： SX1276LoRaGetRFState
功    能 ： 读取工作状态
参    数 ： 无
						
返 回 值 ： 工作状态
						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
作    者 ： sun
*************************************************/

uint8_t SX1276LoRaGetRFState( void )
{
    return RFLRState;
}

/************************************************
函数名称 ： SX1276LoRaSetRFState
功    能 ： 设置工作状态
参    数 ： 工作状态
						
返 回 值 ： 无
作    者 ： sun
*************************************************/
void SX1276LoRaSetRFState( uint8_t state )
{
    RFLRState = state;
}


/*!
 * \brief Process the LoRa modem Rx and Tx state machines depending on the
 *        SX1276 operating mode.
 *
 * \retval rfState Current RF state [RF_IDLE, RF_BUSY,
 *                                   RF_RX_DONE, RF_RX_TIMEOUT,
 *                                   RF_TX_DONE, RF_TX_TIMEOUT]
 */
  /************************************************
函数名称 ： SX1276LoRaProcess
功    能 ： Lora运行
参    数 ： 无					
返 回 值 ： Lora的工作模式
						RF_IDLE,
						RF_BUSY,
						RF_RX_DONE,
						RF_RX_TIMEOUT,
						RF_RX_ID_ERROR,
						RF_TX_DONE,
						RF_TX_TIMEOUT,
						RF_LEN_ERROR,
						RF_CHANNEL_EMPTY,
						RF_CHANNEL_ACTIVITY_DETECTED
作    者 ： sun
*************************************************/
uint32_t SX1276LoRaProcess( void )
{
    uint32_t result = RF_BUSY;
//    uint32_t i = 0;
//		uint8_t test = 0;
		
		//printf("RSSI=%f\r\n",SX1276LoRaReadRssi());
    switch( RFLRState )
    {
    case RFLR_STATE_IDLE:
        break;
    case RFLR_STATE_RX_INIT:
        
        SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );

        SX1276LR->RegIrqFlagsMask = RFLR_IRQFLAGS_RXTIMEOUT |
                                    //RFLR_IRQFLAGS_RXDONE |
                                    //RFLR_IRQFLAGS_PAYLOADCRCERROR |
                                   // RFLR_IRQFLAGS_VALIDHEADER |
                                    RFLR_IRQFLAGS_TXDONE |
                                    RFLR_IRQFLAGS_CADDONE |
                                    //RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL |
                                    RFLR_IRQFLAGS_CADDETECTED;
        SX1276Write( REG_LR_IRQFLAGSMASK, SX1276LR->RegIrqFlagsMask );

        if( LoRaSettings.FreqHopOn == true )
        {
            SX1276LR->RegHopPeriod = LoRaSettings.HopPeriod;

            SX1276Read( REG_LR_HOPCHANNEL, &SX1276LR->RegHopChannel );
            SX1276LoRaSetRFFrequency( HoppingFrequencies[SX1276LR->RegHopChannel & RFLR_HOPCHANNEL_CHANNEL_MASK] );
        }
        else
        {
            SX1276LR->RegHopPeriod = 255;
        }
        
        SX1276Write( REG_LR_HOPPERIOD, SX1276LR->RegHopPeriod );
                
                                    // RxDone                    RxTimeout                   FhssChangeChannel           CadDone
        SX1276LR->RegDioMapping1 = RFLR_DIOMAPPING1_DIO0_00 | RFLR_DIOMAPPING1_DIO1_00 | RFLR_DIOMAPPING1_DIO2_00 | RFLR_DIOMAPPING1_DIO3_00;
                                    // CadDetected               ModeReady
        SX1276LR->RegDioMapping2 = RFLR_DIOMAPPING2_DIO4_00 | RFLR_DIOMAPPING2_DIO5_00;
		
        SX1276WriteBuffer( REG_LR_DIOMAPPING1, &SX1276LR->RegDioMapping1, 2 );
    
        if( LoRaSettings.RxSingleOn == true ) // Rx single mode
        {

            SX1276LoRaSetOpMode( RFLR_OPMODE_RECEIVER_SINGLE );
        }
        else // Rx continuous mode
        {
            SX1276LR->RegFifoAddrPtr = SX1276LR->RegFifoRxBaseAddr;
            SX1276Write( REG_LR_FIFOADDRPTR, SX1276LR->RegFifoAddrPtr );
            
            SX1276LoRaSetOpMode( RFLR_OPMODE_RECEIVER );
        }
        
        memset( RFBuffer, 0, ( size_t )RF_BUFFER_SIZE );  //清空RFBuffer

        PacketTimeout = LoRaSettings.RxPacketTimeout;
        RxTimeoutTimer = GET_TICK_COUNT( );
        RFLRState = RFLR_STATE_RX_RUNNING;
				
        break;
    case RFLR_STATE_RX_RUNNING:
				SX1276Read( REG_LR_IRQFLAGS, &SX1276LR->RegIrqFlags );//信道检测
				if( SX1276LR->RegIrqFlags & RFLR_IRQFLAGS_VALIDHEADER_MASK ) 
				{
					SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_VALIDHEADER );
					result = RF_CHANNEL_BUSY;							
				}
        SX1276Read( REG_LR_IRQFLAGS, &SX1276LR->RegIrqFlags );
				if( SX1276LR->RegIrqFlags & RFLR_IRQFLAGS_RXDONE_MASK )
        {
            RxTimeoutTimer = GET_TICK_COUNT( );
            if( LoRaSettings.FreqHopOn == true )    //false
            {
                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;
        }
        	SX1276Read( REG_LR_IRQFLAGS, &SX1276LR->RegIrqFlags );
				if( SX1276LR->RegIrqFlags & RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL_MASK )// 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;
    case RFLR_STATE_RX_DONE:
        SX1276Read( REG_LR_IRQFLAGS, &SX1276LR->RegIrqFlags );
        if( ( SX1276LR->RegIrqFlags & RFLR_IRQFLAGS_PAYLOADCRCERROR ) == RFLR_IRQFLAGS_PAYLOADCRCERROR )     //CRC校验
        {
            // Clear Irq
            SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_PAYLOADCRCERROR  );
            
            if( LoRaSettings.RxSingleOn == true ) // Rx single mode
            {
                RFLRState = RFLR_STATE_RX_INIT;
            }
            else
            {
                RFLRState = RFLR_STATE_RX_RUNNING;
            }
            break;
				}
				
				// If CRC off, then give up the packet.
				// This means it receives wrong header.
				SX1276Read( REG_LR_HOPCHANNEL, &SX1276LR->RegHopChannel );
        if( !( SX1276LR->RegHopChannel & RFLR_HOPCHANNEL_PAYLOAD_CRC16_ON ) )
        {
            if( LoRaSettings.RxSingleOn == true ) // Rx single mode
            {
                RFLRState = RFLR_STATE_RX_INIT;
            }
            else
            {
                RFLRState = RFLR_STATE_RX_RUNNING;
            }
            break;
        }
        
        {
            uint8_t rxSnrEstimate;
            SX1276Read( REG_LR_PKTSNRVALUE, &rxSnrEstimate );
            if( rxSnrEstimate & 0x80 ) // The SNR sign bit is 1
            {
                // Invert and divide by 4
                RxPacketSnrEstimate = ( ( ~rxSnrEstimate + 1 ) & 0xFF ) >> 2;
                RxPacketSnrEstimate = -RxPacketSnrEstimate;
            }
            else
            {
                // Divide by 4
                RxPacketSnrEstimate = ( rxSnrEstimate & 0xFF ) >> 2;
            }
        }
  /**********************************官网源代码
        if( LoRaSettings.RFFrequency < 860000000 )  // LF
        {    
            if( RxPacketSnrEstimate < 0 )
            {
                RxPacketRssiValue = NOISE_ABSOLUTE_ZERO + 10.0 * SignalBwLog[LoRaSettings.SignalBw] + NOISE_FIGURE_LF + ( double )RxPacketSnrEstimate;
            }
            else
            {    
                SX1276Read( REG_LR_PKTRSSIVALUE, &SX1276LR->RegPktRssiValue );
                RxPacketRssiValue = RssiOffsetLF[LoRaSettings.SignalBw] + ( double )SX1276LR->RegPktRssiValue;
            }
        }
        else                                        // HF
        {    
            if( RxPacketSnrEstimate < 0 )
            {
                RxPacketRssiValue = NOISE_ABSOLUTE_ZERO + 10.0 * SignalBwLog[LoRaSettings.SignalBw] + NOISE_FIGURE_HF + ( double )RxPacketSnrEstimate;
            }
            else
            {    
                SX1276Read( REG_LR_PKTRSSIVALUE, &SX1276LR->RegPktRssiValue );
                RxPacketRssiValue = RssiOffsetHF[LoRaSettings.SignalBw] + ( double )SX1276LR->RegPktRssiValue;
            }
        }
**********************************************/
/***************************重新计算值************************/
				if( LoRaSettings.RFFrequency < 860000000 )  // LF
				{
							SX1276Read( REG_LR_PKTRSSIVALUE, &SX1276LR->RegPktRssiValue );
							RxPacketRssiValue = -161.0 + ( double )SX1276LR->RegPktRssiValue;
							if( RxPacketSnrEstimate < 0 && RxPacketRssiValue < -117 )
							{
									RxPacketRssiValue = -119 + RxPacketSnrEstimate;
							}
				}
				else                                        // HF
				{
							SX1276Read( REG_LR_PKTRSSIVALUE, &SX1276LR->RegPktRssiValue );
							RxPacketRssiValue = -161.0 + ( double )SX1276LR->RegPktRssiValue;
							if( RxPacketSnrEstimate < 0 && RxPacketRssiValue < -117 )
							{
									RxPacketRssiValue = -119 + RxPacketSnrEstimate;
							}
				}

        if( LoRaSettings.RxSingleOn == true ) // Rx single mode
        {
            SX1276LR->RegFifoAddrPtr = SX1276LR->RegFifoRxBaseAddr;       
            SX1276Write( REG_LR_FIFOADDRPTR, SX1276LR->RegFifoAddrPtr );    //读取接收数据

            if( LoRaSettings.ImplicitHeaderOn == true )
            {
                RxPacketSize = SX1276LR->RegPayloadLength;
                SX1276ReadFifo( RFBuffer, SX1276LR->RegPayloadLength );
            }
            else
            {
                SX1276Read( REG_LR_NBRXBYTES, &SX1276LR->RegNbRxBytes );
                RxPacketSize = SX1276LR->RegNbRxBytes;
                SX1276ReadFifo( RFBuffer, SX1276LR->RegNbRxBytes );
            }
        }
        else // Rx continuous mode
        {
            SX1276Read( REG_LR_FIFORXCURRENTADDR, &SX1276LR->RegFifoRxCurrentAddr );

            if( LoRaSettings.ImplicitHeaderOn == true )
            {
                RxPacketSize = SX1276LR->RegPayloadLength;
                SX1276LR->RegFifoAddrPtr = SX1276LR->RegFifoRxCurrentAddr;
                SX1276Write( REG_LR_FIFOADDRPTR, SX1276LR->RegFifoAddrPtr );
                SX1276ReadFifo( RFBuffer, SX1276LR->RegPayloadLength );
            }
            else
            {
                SX1276Read( REG_LR_NBRXBYTES, &SX1276LR->RegNbRxBytes );
                RxPacketSize = SX1276LR->RegNbRxBytes;
                SX1276LR->RegFifoAddrPtr = SX1276LR->RegFifoRxCurrentAddr;
                SX1276Write( REG_LR_FIFOADDRPTR, SX1276LR->RegFifoAddrPtr );
                SX1276ReadFifo( RFBuffer, SX1276LR->RegNbRxBytes );
            }
        }
        
        if( LoRaSettings.RxSingleOn == true ) // Rx single mode
        {
            RFLRState = RFLR_STATE_RX_INIT;
        }
        else // Rx continuous mode
        {
            RFLRState = RFLR_STATE_RX_RUNNING;
        }
        result = RF_RX_DONE;
        break;
    case RFLR_STATE_RX_TIMEOUT:
        RFLRState = RFLR_STATE_RX_INIT;
        result = RF_RX_TIMEOUT;
        break;
    case RFLR_STATE_TX_INIT:

        SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );

        if( LoRaSettings.FreqHopOn == true )
        {
            SX1276LR->RegIrqFlagsMask = RFLR_IRQFLAGS_RXTIMEOUT |
                                        RFLR_IRQFLAGS_RXDONE |
                                        RFLR_IRQFLAGS_PAYLOADCRCERROR |
                                        RFLR_IRQFLAGS_VALIDHEADER |
                                        //RFLR_IRQFLAGS_TXDONE |
                                        RFLR_IRQFLAGS_CADDONE |
                                        //RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL |
                                        RFLR_IRQFLAGS_CADDETECTED;
            SX1276LR->RegHopPeriod = LoRaSettings.HopPeriod;

            SX1276Read( REG_LR_HOPCHANNEL, &SX1276LR->RegHopChannel );
            SX1276LoRaSetRFFrequency( HoppingFrequencies[SX1276LR->RegHopChannel & RFLR_HOPCHANNEL_CHANNEL_MASK] );
        }
        else
        {
            SX1276LR->RegIrqFlagsMask = RFLR_IRQFLAGS_RXTIMEOUT |
                                        RFLR_IRQFLAGS_RXDONE |
                                        RFLR_IRQFLAGS_PAYLOADCRCERROR |
                                        RFLR_IRQFLAGS_VALIDHEADER |
                                        //RFLR_IRQFLAGS_TXDONE |
                                        RFLR_IRQFLAGS_CADDONE |
                                        RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL |
                                        RFLR_IRQFLAGS_CADDETECTED;
            SX1276LR->RegHopPeriod = 0;
        }
        SX1276Write( REG_LR_HOPPERIOD, SX1276LR->RegHopPeriod );
        SX1276Write( REG_LR_IRQFLAGSMASK, SX1276LR->RegIrqFlagsMask );

        // Initializes the payload size
        SX1276LR->RegPayloadLength = TxPacketSize;
        SX1276Write( REG_LR_PAYLOADLENGTH, SX1276LR->RegPayloadLength );
        
        SX1276LR->RegFifoTxBaseAddr = 0x00; // Full buffer used for Tx
        SX1276Write( REG_LR_FIFOTXBASEADDR, SX1276LR->RegFifoTxBaseAddr );

        SX1276LR->RegFifoAddrPtr = SX1276LR->RegFifoTxBaseAddr;
        SX1276Write( REG_LR_FIFOADDRPTR, SX1276LR->RegFifoAddrPtr );
        
        // Write payload buffer to LORA modem
        SX1276WriteFifo( RFBuffer, SX1276LR->RegPayloadLength );
		
                                        // TxDone               RxTimeout                   FhssChangeChannel          ValidHeader         
        SX1276LR->RegDioMapping1 = RFLR_DIOMAPPING1_DIO0_01 | RFLR_DIOMAPPING1_DIO1_00 | RFLR_DIOMAPPING1_DIO2_00 | RFLR_DIOMAPPING1_DIO3_01;
                                        // PllLock              Mode Ready
        SX1276LR->RegDioMapping2 = RFLR_DIOMAPPING2_DIO4_01 | RFLR_DIOMAPPING2_DIO5_00;
		
        SX1276WriteBuffer( REG_LR_DIOMAPPING1, &SX1276LR->RegDioMapping1, 2 );

        SX1276LoRaSetOpMode( RFLR_OPMODE_TRANSMITTER );

				PacketTimeout = LoRaSettings.TxPacketTimeout;
        TxTimeoutTimer = GET_TICK_COUNT( );


        RFLRState = RFLR_STATE_TX_RUNNING;
				
        break;
    case RFLR_STATE_TX_RUNNING:
		{
			SX1276Read( REG_LR_IRQFLAGS, &SX1276LR->RegIrqFlags );
			
			if( SX1276LR->RegIrqFlags & RFLR_IRQFLAGS_TXDONE_MASK )
      {
            // Clear Irq
            SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_TXDONE  );
            RFLRState = RFLR_STATE_TX_DONE;   
      }
			else
			{
				//	if( ( GET_TICK_COUNT( ) - TxTimeoutTimer ) > PacketTimeout )   //发送超时
				if( (TxTimeoutTimer + PacketTimeout ) < GET_TICK_COUNT( ))   //发送超时
					{
							 result = RF_TX_TIMEOUT;
							 SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
							 RFLRState = RFLR_STATE_IDLE;
					}
			
			}
      SX1276Read( REG_LR_IRQFLAGS, &SX1276LR->RegIrqFlags );
			if( SX1276LR->RegIrqFlags & RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL_MASK )// 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;
    case RFLR_STATE_TX_DONE:
        // optimize the power consumption by switching off the transmitter as soon as the packet has been sent
        SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );

        RFLRState = RFLR_STATE_IDLE;
        result = RF_TX_DONE;
        break;
    case RFLR_STATE_CAD_INIT:    
        SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
    
        SX1276LR->RegIrqFlagsMask = RFLR_IRQFLAGS_RXTIMEOUT |
                                    RFLR_IRQFLAGS_RXDONE |
                                    RFLR_IRQFLAGS_PAYLOADCRCERROR |
                                    RFLR_IRQFLAGS_VALIDHEADER |
                                    RFLR_IRQFLAGS_TXDONE |
                                    //RFLR_IRQFLAGS_CADDONE |
                                    RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL; // |
                                    //RFLR_IRQFLAGS_CADDETECTED;
        SX1276Write( REG_LR_IRQFLAGSMASK, SX1276LR->RegIrqFlagsMask );
           
                                    // RxDone                   RxTimeout                   FhssChangeChannel           CadDone
        SX1276LR->RegDioMapping1 = RFLR_DIOMAPPING1_DIO0_00 | RFLR_DIOMAPPING1_DIO1_00 | RFLR_DIOMAPPING1_DIO2_00 | RFLR_DIOMAPPING1_DIO3_00;
                                    // CAD Detected              ModeReady
        SX1276LR->RegDioMapping2 = RFLR_DIOMAPPING2_DIO4_00 | RFLR_DIOMAPPING2_DIO5_00;
        SX1276WriteBuffer( REG_LR_DIOMAPPING1, &SX1276LR->RegDioMapping1, 2 );
            
        SX1276LoRaSetOpMode( RFLR_OPMODE_CAD );
        RFLRState = RFLR_STATE_CAD_RUNNING;
        break;
    case RFLR_STATE_CAD_RUNNING:
        SX1276Read( REG_LR_IRQFLAGS, &SX1276LR->RegIrqFlags );
        //		if( DIO3 == 1 ) // CAD Done interrupt
        if( SX1276LR->RegIrqFlags & RFLR_IRQFLAGS_CADDONE_MASK )
        { 
            // Clear Irq
           // SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_CADDONE  );
            if( SX1276LR->RegIrqFlags & RFLR_IRQFLAGS_CADDETECTED_MASK )
            {
                // Clear Irq
                SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_CADDETECTED  );
                // CAD detected, we have a LoRa preamble
                RFLRState = RFLR_STATE_RX_INIT;
                result = RF_CHANNEL_ACTIVITY_DETECTED;
            } 
            else
            {    
                // The device goes in Standby Mode automatically    
                RFLRState = RFLR_STATE_IDLE;
                result = RF_CHANNEL_EMPTY;
            }
        }   
        break;
    
    default:
        break;
    } 
    return result;
}

/************************************************
函数名称 ： SX1276GetLoraTimeOnAir
功    能 ： 获取空中时间
参    数 ： pktLen		有效负载长度			
返 回 值 ： 无
作    者 ： sun
*************************************************/
uint32_t SX1276GetLoraTimeOnAir(uint8_t pktLen )
{
    uint32_t airTime = 0;
		double tPreamble;
    double rs;
		double ts;
		double tmp ;
		double nPayload ;
		double tPayload;
		double tOnAir;
		double bw = 0.0;
		// REMARK: When using LoRa modem only bandwidths 125, 250 and 500 kHz are supported
		switch( LoRaSettings.SignalBw )
		{
			//case 0: // 7.8 kHz
			//    bw = 7800;
			//    break;
			//case 1: // 10.4 kHz
			//    bw = 10400;
			//    break;
			//case 2: // 15.6 kHz
			//    bw = 15600;
			//    break;
			//case 3: // 20.8 kHz
			//    bw = 20800;
			//    break;
			//case 4: // 31.2 kHz
			//    bw = 31200;
			//    break;
			//case 5: // 41.4 kHz
			//    bw = 41400;
			//    break;
			//case 6: // 62.5 kHz
			//    bw = 62500;
			//    break;
			case 7: // 125 kHz
				bw = 125000;
			break;
			case 8: // 250 kHz
				bw = 250000;
			break;
			case 9: // 500 kHz
				bw = 500000;
			break;
		}

		// Symbol rate : time for one symbol (secs)
		 rs = bw / ( 1<< LoRaSettings.SpreadingFactor );
		//	 rs = bw / (pow(2, LoRaSettings.SpreadingFactor));
		 ts = 1 / rs;
		// time of preamble
		 tPreamble = ( SX1276LoRaGetPreambleLength() + 4.25 ) * ts;
		// Symbol length of payload and time
		 tmp = ceil( ( 8 * pktLen - 4 * LoRaSettings.SpreadingFactor +28 + 16 - ( LoRaSettings.ImplicitHeaderOn ? 20 : 0 ) ) /
		( double )( 4 * ( LoRaSettings.SpreadingFactor -( ( SX1276LoRaGetLowDatarateOptimize() > 0 ) ? 1 : 0 ) ) ) ) *( LoRaSettings.ErrorCoding + 4 );
		 nPayload = 8 + ( ( tmp > 0 ) ? tmp : 0 );
		 tPayload = nPayload * ts;
		// Time on air
		 tOnAir = tPreamble + tPayload;
		// return ms secs
		airTime = floor( tOnAir * 933 + 0.999 );
		return airTime;
}

uint32_t SX1276GetLoraDataRate(void)
{
		double bw = 0.0;
		double rs;
		double ts;
		double bps;
		// REMARK: When using LoRa modem only bandwidths 125, 250 and 500 kHz are supported
		switch( LoRaSettings.SignalBw )
		{
			//case 0: // 7.8 kHz
			//    bw = 7800;
			//    break;
			//case 1: // 10.4 kHz
			//    bw = 10400;
			//    break;
			//case 2: // 15.6 kHz
			//    bw = 15600;
			//    break;
			//case 3: // 20.8 kHz
			//    bw = 20800;
			//    break;
			//case 4: // 31.2 kHz
			//    bw = 31200;
			//    break;
			//case 5: // 41.4 kHz
			//    bw = 41400;
			//    break;
			//case 6: // 62.5 kHz
			//    bw = 62500;
			//    break;
			case 7: // 125 kHz
				bw = 125000;
			break;
			case 8: // 250 kHz
				bw = 250000;
			break;
			case 9: // 500 kHz
				bw = 500000;
			break;
		}
		
		// Symbol rate : time for one symbol (secs)
		 rs = bw / ( 1<< LoRaSettings.SpreadingFactor );
		//	 rs = bw / (pow(2, LoRaSettings.SpreadingFactor));
		// ts = 1 / rs;
		
		ts = (double)((4 * LoRaSettings.SpreadingFactor )/( LoRaSettings.ErrorCoding + 4 ));
		bps = rs * ts ;
		return (uint32_t)bps;
}


uint32_t getRadom(void){
  uint8_t i=0;
  uint8_t temp=0;
  uint32_t radom=0;
  for( i = 0; i < 32; i++ )
    {
        TIMDelay_Nms( 1 );
        // Unfiltered RSSI value reading. Only takes the LSB value
        SX1276Read( REG_LR_RSSIVALUE, &temp );
        radom |= ( temp & 0x01 ) << i;
    }
  
  return radom;
}

/*
bool SX1276IsLoraChannelFree( int16_t rssiThresh )
{
	return rssiThresh > SX1276LoRaReadRssi() ? 1:0;

}
*/
#endif // USE_SX1276_RADIO