#include "sx127x.h"
#include "ddl.h"
#include "Debug.h"
#include "spi.h"
#include "bsp.h"


#define LORAChannel 8
#define LORARegPreamble 10

#if (LORA_MODULE == SX1278W1)
Sx1276Type_t LoRaPara = {
	.ucChannel = LORAChannel, //4 or 12
	.dwFreqHz = FREQ_CENT,
	.ucPower = 20, 
	.SignalBw = SX1276_BW_250K,
	.SpreadFactor = SX1276_SF_512,
	.ErrorCoding = SX1276_EC_4_6,
	.RegPreamble = LORARegPreamble,//10 or 16
	.ucOpModePrev = RFLR_OPMODE_STANDBY, 
	.bAntSwPrev = RF_ANT_RECEIVER,
	.RegBuff = 0,
	.State = SX1276_IDLE,
	.ucRxPacketSize = 0,
	.ucTxPacketSize = 0,
	.RxCallBack = NULL,
};

void LoraReset(void)
{
	LORA_RESET_CLR();
	delay_ms(1);
	LORA_RESET_SET();
}

/////////////////////////////////////////////////
void SX1276SetAntSw(Sx1276AntStatus_m Status)
{
	switch(Status){
		case RF_ANT_TRANSMITTER:
			LORA_ANTTXEN();
			break;
		case RF_ANT_RECEIVER:
			LORA_ANTRXEN();
			break;
		case RF_ANT_CLOSE:
			LORA_ANTCLOSE();
			break;
	}
}

void SX1276ReadBuffer(uint8_t ucAddr, uint8_t *pucBuff, uint8_t ucLen)
{
	uint8_t ucCnt;
	LORA_SPI_NSS_CLR();
	LORA_SPI_READ_WRITE(ucAddr & 0x7F);
	for( ucCnt = 0; ucCnt < ucLen; ucCnt++ ){
		pucBuff[ucCnt] = LORA_SPI_READ_WRITE(0);
	}
	LORA_SPI_NSS_SET();
}

void SX1276WriteBuffer(uint8_t ucAddr, uint8_t *pucBuff, uint8_t ucLen)
{
	uint8_t ucCnt;
	LORA_SPI_NSS_CLR();
	LORA_SPI_READ_WRITE(ucAddr | 0x80);
	for( ucCnt = 0; ucCnt < ucLen; ucCnt++ ){
		LORA_SPI_READ_WRITE(pucBuff[ucCnt]);
	}
	LORA_SPI_NSS_SET();
}
void SX1276Write(uint8_t ucAddr, uint8_t ucData)
{
    SX1276WriteBuffer(ucAddr, &ucData, 1);
}

void SX1276Read(uint8_t ucAddr, uint8_t * pucData)
{
    SX1276ReadBuffer(ucAddr, pucData, 1);
}

void SX1276WriteFifo(uint8_t *pucBuff, uint8_t ucLen)
{
    SX1276WriteBuffer(0, pucBuff, ucLen);
}

void SX1276ReadFifo(uint8_t *pucBuff,	uint8_t ucLen)
{
    SX1276ReadBuffer(0, pucBuff, ucLen);
}

/////////////////////////////////////////////////
void SX1276LoRaSetNbTrigPeaks(uint8_t ucValue)
{
	SX1276Read(0x31, &(LoRaPara.RegBuff.RegTestReserved31));
	LoRaPara.RegBuff.RegTestReserved31 = (LoRaPara.RegBuff.RegTestReserved31 & 0xF8) | ucValue;
	SX1276Write(0x31, LoRaPara.RegBuff.RegTestReserved31 );
}

void SX1276LoRaSetSignalBandwidth(Sx1276BwType Bw)
{
	SX1276Read(REG_LR_MODEMCONFIG1, &(LoRaPara.RegBuff.RegModemConfig1));
	LoRaPara.RegBuff.RegModemConfig1 = (LoRaPara.RegBuff.RegModemConfig1 & RFLR_MODEMCONFIG1_BW_MASK) | Bw;
	SX1276Write(REG_LR_MODEMCONFIG1, LoRaPara.RegBuff.RegModemConfig1);
	LoRaPara.SignalBw = Bw;
}

void SX1276LoRaSetSpreadingFactor(Sx1276SpreadFactorType Factor)
{
	if (Factor > SX1276_SF_4096){
		Factor = SX1276_SF_4096;
	}
	else if (Factor < SX1276_SF_64){
		Factor = SX1276_SF_64;
	}
	if (Factor == SX1276_SF_64){
		SX1276LoRaSetNbTrigPeaks(5);
	}
	else{
		SX1276LoRaSetNbTrigPeaks(3);
	}
	SX1276Read(REG_LR_MODEMCONFIG2, &(LoRaPara.RegBuff.RegModemConfig2));
	LoRaPara.RegBuff.RegModemConfig2 = (LoRaPara.RegBuff.RegModemConfig2 & RFLR_MODEMCONFIG2_SF_MASK ) | Factor;
	SX1276Write(REG_LR_MODEMCONFIG2, LoRaPara.RegBuff.RegModemConfig2);
	LoRaPara.SpreadFactor = Factor;
}

void SX1276LoRaSetErrorCoding(Sx1276ErrorCodingType Value){
	SX1276Read(REG_LR_MODEMCONFIG1, &(LoRaPara.RegBuff.RegModemConfig1));
	LoRaPara.RegBuff.RegModemConfig1 = (LoRaPara.RegBuff.RegModemConfig1 & RFLR_MODEMCONFIG1_CODINGRATE_MASK ) | Value;
	SX1276Write(REG_LR_MODEMCONFIG1, LoRaPara.RegBuff.RegModemConfig1 );
	LoRaPara.ErrorCoding = Value;
}

void SX1276LoRaSetFreqHz(uint32_t dwFreqHz)
{
	LoRaPara.dwFreqHz = dwFreqHz;
	dwFreqHz = ( uint32_t )( ( double )dwFreqHz / ( double )FREQ_STEP );
	LoRaPara.RegBuff.RegFrfMsb = ( uint8_t )( ( dwFreqHz >> 16 ) & 0xFF );
	LoRaPara.RegBuff.RegFrfMid = ( uint8_t )( ( dwFreqHz >> 8 ) & 0xFF );
	LoRaPara.RegBuff.RegFrfLsb = ( uint8_t )( dwFreqHz & 0xFF );
	SX1276WriteBuffer(REG_LR_FRFMSB, &(LoRaPara.RegBuff.RegFrfMsb), 3);
}

void SX1276LoRaSetSymbTimeout(uint16_t ucValue)
{
	SX1276ReadBuffer(REG_LR_MODEMCONFIG2, &(LoRaPara.RegBuff.RegModemConfig2), 2);
	LoRaPara.RegBuff.RegModemConfig2 = (LoRaPara.RegBuff.RegModemConfig2 & RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB_MASK) | (( ucValue >> 8) & ~RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB_MASK );
	LoRaPara.RegBuff.RegSymbTimeoutLsb = ucValue & 0xFF;
	SX1276WriteBuffer(REG_LR_MODEMCONFIG2, &(LoRaPara.RegBuff.RegModemConfig2), 2);
}

void SX1276LoRaSetLowDatarateOptimize(boolean_t bEnable)
{
	SX1276Read(REG_LR_MODEMCONFIG3, &(LoRaPara.RegBuff.RegModemConfig3));
	LoRaPara.RegBuff.RegModemConfig3 = (LoRaPara.RegBuff.RegModemConfig3 & RFLR_MODEMCONFIG3_LOWDATARATEOPTIMIZE_MASK ) | ( bEnable << 3 );
	SX1276Write(REG_LR_MODEMCONFIG3, LoRaPara.RegBuff.RegModemConfig3);
}

void SX1276LoRaSetPAOutput(uint8_t ucOutputPin)
{
	SX1276Read(REG_LR_PACONFIG, &(LoRaPara.RegBuff.RegPaConfig));
	LoRaPara.RegBuff.RegPaConfig = (LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_PASELECT_MASK ) | ucOutputPin;
	SX1276Write(REG_LR_PACONFIG, LoRaPara.RegBuff.RegPaConfig );
}

void SX1276LoRaSetPa20dBm(boolean_t bEnable)
{
	SX1276Read(REG_LR_PADAC, &(LoRaPara.RegBuff.RegPaDac));
	SX1276Read(REG_LR_PACONFIG, &(LoRaPara.RegBuff.RegPaConfig));
	if ((LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_PASELECT_PABOOST ) ==	RFLR_PACONFIG_PASELECT_PABOOST ) {
		if( bEnable == TRUE ){
			LoRaPara.RegBuff.RegPaDac = 0x87;
		}
	}
	else{
		LoRaPara.RegBuff.RegPaDac = 0x84;
	}
	SX1276Write(REG_LR_PADAC, LoRaPara.RegBuff.RegPaDac );
}

void SX1276LoRaSetRfPower(int8_t sbPower)
{
	SX1276Read(REG_LR_PACONFIG, &(LoRaPara.RegBuff.RegPaConfig));
	SX1276Read(REG_LR_PADAC, &(LoRaPara.RegBuff.RegPaDac));
	if ((LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_PASELECT_PABOOST ) ==	RFLR_PACONFIG_PASELECT_PABOOST ) {
		if ((LoRaPara.RegBuff.RegPaDac & 0x87) == 0x87){
			if( sbPower < 5 ){
				sbPower = 5;
			}
			if( sbPower > 20){
				sbPower = 20;
			}
			LoRaPara.RegBuff.RegPaConfig = (LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_MAX_POWER_MASK ) | 0x70;
			LoRaPara.RegBuff.RegPaConfig = (LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_OUTPUTPOWER_MASK ) |
				( uint8_t )( ( uint16_t )( sbPower - 5 ) & 0x0F );
		}
		else{
			if( sbPower < 2){
				sbPower = 2;
			}
			if( sbPower > 17){
				sbPower = 17;
			}
			LoRaPara.RegBuff.RegPaConfig = (LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_MAX_POWER_MASK ) | 0x70;
			LoRaPara.RegBuff.RegPaConfig = (LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_OUTPUTPOWER_MASK ) |
				( uint8_t )( ( uint16_t )( sbPower - 2 ) & 0x0F );
		}
	}
	else{
		if( sbPower < -1){
			sbPower = -1;
		}
		if( sbPower > 14){
			sbPower = 14;
		}
		LoRaPara.RegBuff.RegPaConfig = (LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_MAX_POWER_MASK ) | 0x70;
		LoRaPara.RegBuff.RegPaConfig = (LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_OUTPUTPOWER_MASK ) |
			( uint8_t )( ( uint16_t )( sbPower + 1 ) & 0x0F );
	}
	SX1276Write(REG_LR_PACONFIG, LoRaPara.RegBuff.RegPaConfig);
	LoRaPara.ucPower = sbPower;
}

void SX1276LoRaSetOpMode(Sx1276OpModeType ucOpMode)
{
	Sx1276AntStatus_m bAntSwStatus = RF_ANT_RECEIVER;
	LoRaPara.ucOpModePrev = LoRaPara.RegBuff.RegOpMode & ~RFLR_OPMODE_MASK;
	if( ucOpMode != LoRaPara.ucOpModePrev){
		if(ucOpMode == RFLR_OPMODE_TRANSMITTER){
			
			//CLR_LORA_RXEN();
			//SET_LORA_TXEN();
			
			
			bAntSwStatus = RF_ANT_TRANSMITTER;
		}
		else if(ucOpMode == RFLR_OPMODE_RECEIVER){
			bAntSwStatus = RF_ANT_RECEIVER;
			
			//CLR_LORA_TXEN();
			//SET_LORA_RXEN();
		}
		else {
			bAntSwStatus = RF_ANT_CLOSE;
		}
		if( bAntSwStatus != LoRaPara.bAntSwPrev ){
			LoRaPara.bAntSwPrev = bAntSwStatus;
			SX1276SetAntSw(bAntSwStatus);
		}
		LoRaPara.RegBuff.RegOpMode = (LoRaPara.RegBuff.RegOpMode & RFLR_OPMODE_MASK ) | ucOpMode;
		SX1276Write( REG_LR_OPMODE, LoRaPara.RegBuff.RegOpMode);
	}
}
////////////////////////////////////////////////////////////////

void Sx1276LoRaEnterRx(void)
{
	uint8_t ucCnt;
	SX1276LoRaSetOpMode(RFLR_OPMODE_STANDBY);
	LoRaPara.RegBuff.RegIrqFlagsMask = RFLR_IRQFLAGS_RXTIMEOUT | RFLR_IRQFLAGS_VALIDHEADER | RFLR_IRQFLAGS_TXDONE;
	SX1276Write(REG_LR_IRQFLAGSMASK, LoRaPara.RegBuff.RegIrqFlagsMask);
	LoRaPara.RegBuff.RegHopPeriod = 255;
	SX1276Write(REG_LR_HOPPERIOD, LoRaPara.RegBuff.RegHopPeriod );
	                            					// RxDone					RxTimeout					FhssChangeChannel			ValidHeader
	LoRaPara.RegBuff.RegDioMapping1 =	RFLR_DIOMAPPING1_DIO0_00 | 	RFLR_DIOMAPPING1_DIO1_00 | 	RFLR_DIOMAPPING1_DIO2_01 | 	RFLR_DIOMAPPING1_DIO3_01;
	                            					// CadDetected				ModeReady
	LoRaPara.RegBuff.RegDioMapping2 = RFLR_DIOMAPPING2_DIO4_00 | 	RFLR_DIOMAPPING2_DIO5_00;
	SX1276WriteBuffer(REG_LR_DIOMAPPING1, &(LoRaPara.RegBuff.RegDioMapping1), 2);
	LoRaPara.RegBuff.RegFifoAddrPtr = LoRaPara.RegBuff.RegFifoRxBaseAddr;
	SX1276Write(REG_LR_FIFOADDRPTR, LoRaPara.RegBuff.RegFifoAddrPtr);
	SX1276LoRaSetOpMode(RFLR_OPMODE_RECEIVER);
	for (ucCnt=0; ucCnt< LORA_BUFF_SIZE; ucCnt++){
		LoRaPara.RxTxBuff[ucCnt] = 0;
	}
	LoRaPara.State = SX1276_IDLE;//COMST_RX
	uint8_t temp;
	SX1276Read(REG_LR_IRQFLAGS, &temp);
	
	//设置接收模式
	LORA_ANTRXEN();
}

/////////////////////////////////////////////////
void Sx1276LoRaInit(void (*RxCallBack)(uint8_t *rBuff, uint8_t rlen))
{
	if(RxCallBack != NULL) {
		LoRaPara.RxCallBack = RxCallBack;
	}
	LoraReset();
	SX1276LoRaSetOpMode(RFLR_OPMODE_SLEEP);
	LoRaPara.RegBuff.RegOpMode = (LoRaPara.RegBuff.RegOpMode & RFLR_OPMODE_LONGRANGEMODE_MASK ) | RFLR_OPMODE_LONGRANGEMODE_ON;
	SX1276Write(REG_LR_OPMODE, LoRaPara.RegBuff.RegOpMode );
	SX1276LoRaSetOpMode(RFLR_OPMODE_STANDBY);
	// 																						RxDone								RxTimeout								FhssChangeChannel						ValidHeader
	LoRaPara.RegBuff.RegDioMapping1 =	RFLR_DIOMAPPING1_DIO0_00 |	RFLR_DIOMAPPING1_DIO1_00 |	RFLR_DIOMAPPING1_DIO2_00 | RFLR_DIOMAPPING1_DIO3_01;
	// 																						CadDetected						ModeReady
	LoRaPara.RegBuff.RegDioMapping2 =	RFLR_DIOMAPPING2_DIO4_00 |	RFLR_DIOMAPPING2_DIO5_00;
	SX1276WriteBuffer(REG_LR_DIOMAPPING1, &(LoRaPara.RegBuff.RegDioMapping1), 2 );
	SX1276ReadBuffer(REG_LR_OPMODE, (uint8_t*)&(LoRaPara.RegBuff) + 1, SIZE_OF_REGISTERS);
	LoRaPara.State = SX1276_BUSY;
	SX1276Read(REG_LR_VERSION, &(LoRaPara.RegBuff.RegVersion));
	SX1276ReadBuffer(REG_LR_OPMODE, (uint8_t*)&(LoRaPara.RegBuff) + 1, SIZE_OF_REGISTERS);
	LoRaPara.RegBuff.RegLna = RFLR_LNA_GAIN_G1;
	SX1276WriteBuffer(REG_LR_OPMODE, (uint8_t*)&(LoRaPara.RegBuff) + 1, SIZE_OF_REGISTERS);
	//set the RF settings
	SX1276LoRaWriteChannel(LoRaPara.ucChannel);
	//SX1276LoRaSetFreqHz(LoRaPara.dwFreqHz);
	//REG_LR_MODEMCONFIG1
	SX1276Read(REG_LR_MODEMCONFIG1, &(LoRaPara.RegBuff.RegModemConfig1));
	//SignalBandwidth
	LoRaPara.RegBuff.RegModemConfig1 = (LoRaPara.RegBuff.RegModemConfig1 & RFLR_MODEMCONFIG1_BW_MASK ) | LoRaPara.SignalBw;
	//ErrorCoding
	LoRaPara.RegBuff.RegModemConfig1 = (LoRaPara.RegBuff.RegModemConfig1 & RFLR_MODEMCONFIG1_CODINGRATE_MASK ) | LoRaPara.ErrorCoding;
	//IMPLICITHEADER
	LoRaPara.RegBuff.RegModemConfig1 = LoRaPara.RegBuff.RegModemConfig1 | RFLR_MODEMCONFIG1_IMPLICITHEADER_ON;
	SX1276Write(REG_LR_MODEMCONFIG1, LoRaPara.RegBuff.RegModemConfig1);
	//REG_LR_MODEMCONFIG2
	SX1276Read(REG_LR_MODEMCONFIG2, &(LoRaPara.RegBuff.RegModemConfig2));
	//SpreadingFactor
	if( LoRaPara.SpreadFactor == SX1276_SF_64){
		SX1276LoRaSetNbTrigPeaks(5);
		SX1276LoRaSetLowDatarateOptimize(TRUE);		//低数据速率设置
	}
	else{
		SX1276LoRaSetNbTrigPeaks(3);
		SX1276LoRaSetLowDatarateOptimize(FALSE);		//低数据速率设置
	}
	LoRaPara.RegBuff.RegModemConfig2 = (LoRaPara.RegBuff.RegModemConfig2 & RFLR_MODEMCONFIG2_SF_MASK ) | LoRaPara.SpreadFactor;
	//PacketCrcOn
	LoRaPara.RegBuff.RegModemConfig2 = (LoRaPara.RegBuff.RegModemConfig2 & RFLR_MODEMCONFIG2_RXPAYLOADCRC_MASK ) | SX1276_CRC_ON;	//SX1276_CRC_OFF
	
	//验证寄存器操作是否成功
	SX1276Write(REG_LR_MODEMCONFIG2, LoRaPara.RegBuff.RegModemConfig2);
	 LoRaPara.RegBuff.RegModemConfig2 = 0;
	SX1276Read(REG_LR_MODEMCONFIG2, &(LoRaPara.RegBuff.RegModemConfig2));
	
	SX1276LoRaSetSymbTimeout(0x3FF);	
	LoRaPara.RegBuff.RegPreambleMsb= (LoRaPara.RegPreamble >> 8) & 0x00ff;
	LoRaPara.RegBuff.RegPreambleLsb= LoRaPara.RegPreamble & 0x00ff;
	SX1276Write(REG_LR_PREAMBLEMSB, LoRaPara.RegBuff.RegPreambleMsb);
	SX1276Write(REG_LR_PREAMBLELSB, LoRaPara.RegBuff.RegPreambleLsb);	
	SX1276Write(REG_LR_PAYLOADLENGTH, LORA_BUFF_SIZE);
	SX1276Write(REG_LR_PAYLOADMAXLENGTH, LORA_BUFF_SIZE);
	LoRaPara.RegBuff.RegPayloadLength = LORA_BUFF_SIZE;
	
	#ifndef USE_LORA_860_PA
	if(LoRaPara.dwFreqHz > 860000000 ){
		SX1276LoRaSetPAOutput(RFLR_PACONFIG_PASELECT_RFO);
		SX1276LoRaSetPa20dBm(FALSE);
		LoRaPara.ucPower = 14;
	}
	else
	#endif
	{
		SX1276LoRaSetPAOutput(RFLR_PACONFIG_PASELECT_PABOOST);
		SX1276LoRaSetPa20dBm(TRUE);
		LoRaPara.ucPower = 20;
	}
	SX1276LoRaSetRfPower(LoRaPara.ucPower);
	SX1276LoRaSetOpMode(RFLR_OPMODE_STANDBY);
	Sx1276LoRaEnterRx();	
}

void IsrSx1276LoRaTxRx(void){
	switch (LoRaPara.State){
		case SX1276_IDLE:
		case SX1276_RX:
			// Clear Irq
			//SET_LORA_RX_LED();
			do {
				SX1276Write(REG_LR_IRQFLAGS, RFLR_IRQFLAGS_RXDONE);
				SX1276Read(REG_LR_IRQFLAGS, &(LoRaPara.RegBuff.RegIrqFlags));
				if((LoRaPara.RegBuff.RegIrqFlags & RFLR_IRQFLAGS_RXDONE) !=  RFLR_IRQFLAGS_RXDONE)
					break;
			}while(1);
			if((LoRaPara.RegBuff.RegIrqFlags & RFLR_IRQFLAGS_PAYLOADCRCERROR ) == RFLR_IRQFLAGS_PAYLOADCRCERROR) {
				// Clear Irq
				SX1276Write(REG_LR_IRQFLAGS, RFLR_IRQFLAGS_PAYLOADCRCERROR);
				LoRaPara.State = SX1276_IDLE;
				break;
			}
			SX1276Read(REG_LR_PKTSNRVALUE, &(LoRaPara.RegBuff.RegPktSnrValue));
			SX1276Read(REG_LR_RSSIVALUE, &(LoRaPara.RegBuff.RegRssiValue));
			SX1276Read(REG_LR_PKTRSSIVALUE, &(LoRaPara.RegBuff.RegPktRssiValue));
			SX1276Read(REG_LR_FIFORXCURRENTADDR, &(LoRaPara.RegBuff.RegFifoRxCurrentAddr));
			SX1276Read(REG_LR_NBRXBYTES, &(LoRaPara.RegBuff.RegNbRxBytes));
			LoRaPara.ucRxPacketSize = LoRaPara.RegBuff.RegNbRxBytes;
			LoRaPara.RegBuff.RegFifoAddrPtr = LoRaPara.RegBuff.RegFifoRxCurrentAddr;
			SX1276Write(REG_LR_FIFOADDRPTR, LoRaPara.RegBuff.RegFifoAddrPtr);
			SX1276ReadFifo(LoRaPara.RxTxBuff, (LoRaPara.ucRxPacketSize > LORA_BUFF_SIZE) ? LORA_BUFF_SIZE : LoRaPara.ucRxPacketSize);
			uint8_t ucLen;		
			if(LoRaPara.ucRxPacketSize < LORA_BUFF_SIZE) {
				ucLen= LoRaPara.ucRxPacketSize;
			}
			else {
				ucLen= LORA_BUFF_SIZE;
			}
			LoRaPara.RxTxBuff[ucLen] = 0;
			if(LoRaPara.RxCallBack != NULL)
				LoRaPara.RxCallBack(LoRaPara.RxTxBuff, ucLen);

			LoRaPara.ucRxPacketSize = 0;
			LoRaPara.State = SX1276_IDLE;
			//CLR_LORA_RX_LED();
			break;
		case SX1276_TX:
			// Clear Irq
			SX1276Write(REG_LR_IRQFLAGS, RFLR_IRQFLAGS_TXDONE);
			//LORA_TXLED_OFF();
			Sx1276LoRaEnterRx();
			break;
		default:
			break;
	}
}

void Sx1276LoRaLoopHandler(void)
{
	if(LORA_GETDIO0() > 0){ // RxDone or TxDone
		IsrSx1276LoRaTxRx();
	}
}
void Sx1276LoRaSendBuffer(uint8_t* pucBuff, uint8_t ucLen)
{
	
	//设置发送模式
	LORA_ANTTXEN();
	
	LoRaPara.State = SX1276_BUSY;
	if (ucLen > LORA_BUFF_SIZE){
		ucLen = LORA_BUFF_SIZE;
	}
	LoRaPara.ucTxPacketSize = ucLen;
	while(ucLen--){
		LoRaPara.RxTxBuff[ucLen] = pucBuff[ucLen];
	};
	SX1276LoRaSetOpMode(RFLR_OPMODE_STANDBY);
	LoRaPara.RegBuff.RegIrqFlagsMask = RFLR_IRQFLAGS_RXTIMEOUT | RFLR_IRQFLAGS_RXDONE | RFLR_IRQFLAGS_PAYLOADCRCERROR | RFLR_IRQFLAGS_VALIDHEADER;
	//LoRaPara.RegBuff.RegHopPeriod = 0;
	//SX1276Write(REG_LR_HOPPERIOD, LoRaPara.RegBuff.RegHopPeriod);
	SX1276Write(REG_LR_IRQFLAGSMASK, LoRaPara.RegBuff.RegIrqFlagsMask);
	// Initializes the payload size
	LoRaPara.RegBuff.RegPayloadLength = LoRaPara.ucTxPacketSize;
	SX1276Write(REG_LR_PAYLOADLENGTH, LoRaPara.RegBuff.RegPayloadLength);
	LoRaPara.RegBuff.RegFifoTxBaseAddr = 0x00; // Full buffer used for Tx
	SX1276Write(REG_LR_FIFOTXBASEADDR, LoRaPara.RegBuff.RegFifoTxBaseAddr);
	LoRaPara.RegBuff.RegFifoAddrPtr = LoRaPara.RegBuff.RegFifoTxBaseAddr;
	SX1276Write(REG_LR_FIFOADDRPTR, LoRaPara.RegBuff.RegFifoAddrPtr);
	// Write payload buffer to LORA modem
	SX1276WriteFifo(LoRaPara.RxTxBuff, LoRaPara.RegBuff.RegPayloadLength);
	// 																					TxDone								RxTimeout									FhssChangeChannel						ValidHeader
	LoRaPara.RegBuff.RegDioMapping1 =	RFLR_DIOMAPPING1_DIO0_01 | RFLR_DIOMAPPING1_DIO1_00 |	RFLR_DIOMAPPING1_DIO2_00 | RFLR_DIOMAPPING1_DIO3_01;
	//																					PllLock								Mode Ready
	LoRaPara.RegBuff.RegDioMapping2 =	RFLR_DIOMAPPING2_DIO4_01 |	RFLR_DIOMAPPING2_DIO5_00;
	SX1276WriteBuffer(REG_LR_DIOMAPPING1, &(LoRaPara.RegBuff.RegDioMapping1), 2);
	SX1276LoRaSetOpMode(RFLR_OPMODE_TRANSMITTER);
	uint8_t temp;
	SX1276Read(REG_LR_IRQFLAGS, &temp);
	//LORA_TXLED_ON();
	LoRaPara.State = SX1276_TX;
}

void Sx1276LoRaSleep(void)
{
	SX1276LoRaSetOpMode(RFLR_OPMODE_SLEEP);//RFLR_OPMODE_STANDBY
}

void Sx1276LoRaWakeup(void)
{
	Sx1276LoRaEnterRx();
}

////////////////////////////////////////
//配置本层参数的函数
//频道表
const uint32_t gdwSx1276ChannelTbl[SX1276_CHANNEL_MAX]={
	FREQ_CENT-FREQ_DEV*8, FREQ_CENT-FREQ_DEV*7, FREQ_CENT-FREQ_DEV*6, FREQ_CENT-FREQ_DEV*5,
	FREQ_CENT-FREQ_DEV*4, FREQ_CENT-FREQ_DEV*3, FREQ_CENT-FREQ_DEV*2, FREQ_CENT-FREQ_DEV*1,
	FREQ_CENT+FREQ_DEV*0, FREQ_CENT+FREQ_DEV*1, FREQ_CENT+FREQ_DEV*2, FREQ_CENT+FREQ_DEV*3,
	FREQ_CENT+FREQ_DEV*4, FREQ_CENT+FREQ_DEV*5, FREQ_CENT+FREQ_DEV*6, FREQ_CENT+FREQ_DEV*7,
	FREQ_CENT+FREQ_DEV*8
};

//LORAPT_CHANNEL
uint8_t SX1276LoRaReadChannel(void)
{
	return LoRaPara.ucChannel;
}

boolean_t SX1276LoRaWriteChannel(uint8_t Channel)
{
	if(Channel > SX1276_CHANNEL_MAX) {
		return FALSE;
	}
	
	LoRaPara.dwFreqHz = gdwSx1276ChannelTbl[Channel];
	SX1276LoRaSetFreqHz(LoRaPara.dwFreqHz);
	
	return TRUE;
}

//LORAPT_FREQ,
uint32_t SX1276LoRaReadFreq(void)
{
	return LoRaPara.dwFreqHz;
}

void SX1276LoRaWriteFreq(uint32_t Freq)
{
	SX1276LoRaSetFreqHz(Freq);
}

//LORAPT_BW,
uint32_t SX1276LoRaReadBw(void)
{
	return LoRaPara.SignalBw;
}

void SX1276LoRaWriteBw(Sx1276BwType SignalBw)
{
	LoRaPara.SignalBw = SignalBw;
	SX1276LoRaSetSignalBandwidth(SignalBw);
}

//LORAPT_SF,
uint8_t SX1276LoRaReadSf(void)
{
	return LoRaPara.SpreadFactor;
}

void SX1276LoRaWriteSf(Sx1276SpreadFactorType SpreadFactor)
{
	LoRaPara.SpreadFactor = SpreadFactor;
	SX1276LoRaSetSpreadingFactor(LoRaPara.SpreadFactor);
}

//LORAPT_EC,
uint8_t SX1276LoRaReadEc(void)
{
	return LoRaPara.ErrorCoding;
}

void SX1276LoRaWriteEc(Sx1276ErrorCodingType ErrorCoding)
{
	LoRaPara.ErrorCoding = ErrorCoding;
	SX1276LoRaSetErrorCoding(ErrorCoding);
}

//LORAPT_RSSI,
uint32_t SX1276LoRaParaReadRssi(void)
{
	uint32_t rssi;

	SX1276Read(REG_LR_PKTRSSIVALUE, &(LoRaPara.RegBuff.RegPktRssiValue));
	SX1276Read(REG_LR_RSSIVALUE, &(LoRaPara.RegBuff.RegRssiValue));	
	rssi = (uint16_t)(LoRaPara.RegBuff.RegPktSnrValue)<<16;
	rssi |= (uint16_t)(LoRaPara.RegBuff.RegRssiValue)<<8;
	rssi |= LoRaPara.RegBuff.RegPktRssiValue;
	return rssi;
}

uint8_t SX1276LoRaReadRssiPkt(void)
{
	uint8_t RssiPkt;

	SX1276Read(REG_LR_PKTRSSIVALUE, &LoRaPara.RegBuff.RegPktRssiValue);
	RssiPkt = LoRaPara.RegBuff.RegPktRssiValue;
	return RssiPkt;
}

//LORAPT_POWER,
void SX1276LoRaWritePwr(int8_t Pwr)
{
	SX1276LoRaSetRfPower(Pwr);
}

//LORAPT_SET_RX,
void SX1276LoRaWriteRx(void)
{
	Sx1276LoRaEnterRx();
}

//LORAPT_SET_SLEEP,true-Sleep, false-Wakeup
void SX1276LoRaWriteSleep(boolean_t Sleep)
{
	if(Sleep){
		Sx1276LoRaSleep();
	}
	else {
		Sx1276LoRaWakeup();
	}
}

Sx1276StateType_t SX1276LoRaReadStatus(void)
{
	return LoRaPara.State;
}

///////////////RSSI Calc///////////////
void SX1276LoCalcRssiSnr(int8_t *pswRssi, int8_t *psbSnr)
{
	int8_t sbSnr= LoRaPara.RegBuff.RegPktSnrValue & 0x80 ? (-1)*((int8_t)(((~LoRaPara.RegBuff.RegPktSnrValue+ 1)& 0xFF)/4)): (~LoRaPara.RegBuff.RegPktSnrValue& 0xFF)/4;
	if (sbSnr > 0) {
		*pswRssi= RSSI_OFFSET_LF+ LoRaPara.RegBuff.RegPktRssiValue;
	}
	else {
		*pswRssi= NOISE_ABSOLUTE_ZERO + 10 + SIGNAL_BW_LOG_125KHZ + NOISE_FIGURE_LF + sbSnr;
	}
	*psbSnr= sbSnr;
}
#endif