NewMNFJ/source/user/sx1276_7_8.c

#include "stm32f0xx.h"
#include "sx1276_7_8.h"
#include "sx1276_7_8_spi.h"
#include "mapp_arm.h"
#include "main.h"
#include "TSC2046_spi.h"

unsigned int  SysTime = 0;
unsigned char mode = 0x01;//lora--1/FSK--0
unsigned char Freq_Sel = 0x00;//
unsigned char Power_Sel = 0x00;//
unsigned char Lora_Rate_Sel = 0x02;//速率，0最快
unsigned char BandWide_Sel = 0x07;//
unsigned char Fsk_Rate_Sel = 0x00;//


/**********************************************
函数功能；获取SX1278中断状态            
入口参数：
出口参数：
作者    ：凡达电子,www.finedar.com
QQ      ：75531552
**********************************************/
unsigned char Get_SX1278_IRQ_Status(void)
{
	unsigned char s = 0;
	
	s = SPIRead(LR_RegIrqFlags);
	return s;
}


/**********************************************************
**Parameter table define
**********************************************************/
unsigned char sx1276_7_8FreqTbl[1][3] = 
{ 
  {0x6C, 0x80, 0x00}, //434MHz
};

const unsigned char sx1276_7_8PowerTbl[4] =
{ 
  0xFF,                   //20dbm  
  0xFC,                   //17dbm
  0xF9,                   //14dbm
  0xF6,                   //11dbm 
};

const unsigned char sx1276_7_8SpreadFactorTbl[7] =
{
  6,7,8,9,10,11,12
};

const unsigned char sx1276_7_8LoRaBwTbl[10] =
{
//7.8KHz,10.4KHz,15.6KHz,20.8KHz,31.2KHz,41.7KHz,62.5KHz,125KHz,250KHz,500KHz
  0,1,2,3,4,5,6,7,8,9
};

unsigned char  sx1276_7_8Data[] = {"HR_WT Lora sx1276_7_8"};

unsigned char RxData[64] = {0};

/**********************************************************
**Variable define
**********************************************************/


/**********************************************************
**Name:     sx1276_7_8_Standby
**Function: Entry standby mode
**Input:    None
**Output:   None
**********************************************************/
void sx1276_7_8_Standby(void)
{
  SPIWrite(LR_RegOpMode,0x09);                              		//Standby//Low Frequency Mode
	//SPIWrite(LR_RegOpMode,0x01);                              	 //Standby//High Frequency Mode
}

/**********************************************************
**Name:     sx1276_7_8_Sleep
**Function: Entry sleep mode
**Input:    None
**Output:   None
**********************************************************/
void sx1276_7_8_Sleep(void)
{
  SPIWrite(LR_RegOpMode,0x08);                              		//Sleep//Low Frequency Mode
	//SPIWrite(LR_RegOpMode,0x00);                            		 //Sleep//High Frequency Mode
}

/*********************************************************/
//LoRa mode
/*********************************************************/
/**********************************************************
**Name:     sx1276_7_8_EntryLoRa
**Function: Set RFM69 entry LoRa(LongRange) mode
**Input:    None
**Output:   None
**********************************************************/
void sx1276_7_8_EntryLoRa(void)
{
  SPIWrite(LR_RegOpMode,0x88);//Low Frequency Mode
	//SPIWrite(LR_RegOpMode,0x80);//High Frequency Mode
}

/**********************************************************
**Name:     sx1276_7_8_LoRaClearIrq
**Function: Clear all irq
**Input:    None
**Output:   None
**********************************************************/
void sx1276_7_8_LoRaClearIrq(void)
{
  SPIWrite(LR_RegIrqFlags,0xFF);
}

/**********************************************************
**Name:     sx1276_7_8_LoRaEntryRx
**Function: Entry Rx mode
**Input:    None
**Output:   None
**********************************************************/
unsigned char sx1276_7_8_LoRaEntryRx(void)
{
  unsigned char addr; 
        
  sx1276_7_8_Config();                                         //setting base parameter
  
  SPIWrite(REG_LR_PADAC,0x84);                              //Normal and Rx
  SPIWrite(LR_RegHopPeriod,0xFF);                          //RegHopPeriod NO FHSS
  SPIWrite(REG_LR_DIOMAPPING1,0x01);                       //DIO0=00, DIO1=00, DIO2=00, DIO3=01
      
  SPIWrite(LR_RegIrqFlagsMask,0x3F);                       //Open RxDone interrupt & Timeout
  sx1276_7_8_LoRaClearIrq();   
  
  SPIWrite(LR_RegPayloadLength,21);                       //RegPayloadLength  21byte(this register must difine when the data long of one byte in SF is 6)
    
  addr = SPIRead(LR_RegFifoRxBaseAddr);           				//Read RxBaseAddr
  SPIWrite(LR_RegFifoAddrPtr,addr);                        //RxBaseAddr -> FiFoAddrPtr　 
  SPIWrite(LR_RegOpMode,0x8d);                        		//Continuous Rx Mode//Low Frequency Mode
	//SPIWrite(LR_RegOpMode,0x05);                        		//Continuous Rx Mode//High Frequency Mode
	SysTime = 0;
	while(1)
	{
		if((SPIRead(LR_RegModemStat)&0x04)==0x04)   //Rx-on going RegModemStat
			break;

		if(SysTime>=3)	
			return 0;                                              //over time for error
	}
}
/**********************************************************
**Name:     sx1276_7_8_LoRaReadRSSI
**Function: Read the RSSI value
**Input:    none
**Output:   temp, RSSI value
**********************************************************/
unsigned char sx1276_7_8_LoRaReadRSSI(void)
{
  uint16_t temp=10;
  temp=SPIRead(LR_RegRssiValue);                  //Read RegRssiValue，Rssi value
  temp=temp+127-137;                                       //127:Max RSSI, 137:RSSI offset
  return (unsigned char)temp;
}

/**********************************************************
**Name:     sx1276_7_8_LoRaRxPacket
**Function: Receive data in LoRa mode
**Input:    None
**Output:   1- Success
            0- Fail
**********************************************************/
unsigned char sx1276_7_8_LoRaRxPacket(void)
{
  unsigned char i; 
  unsigned char addr;
  unsigned char packet_size;
 
  if( (Get_SX1278_IRQ_Status() & 0x40) == 0x40)
  {
    for(i=0;i<32;i++) 
      RxData[i] = 0x00;
    
		gtArm.Call_Rx1276_State =1;//dwdtest
    addr = SPIRead(LR_RegFifoRxCurrentaddr);      //last packet addr
    SPIWrite(LR_RegFifoAddrPtr,addr);                      //RxBaseAddr -> FiFoAddrPtr    
    if(sx1276_7_8SpreadFactorTbl[Lora_Rate_Sel]==6)           //When SpreadFactor is six，will used Implicit Header mode(Excluding internal packet length)
      packet_size=21;
    else
      packet_size = SPIRead(LR_RegRxNbBytes);     //Number for received bytes    
    SPIBurstRead(0x00, RxData, packet_size);
    
    sx1276_7_8_LoRaClearIrq();
    for(i=0;i<17;i++)
    {
      if(RxData[i]!=sx1276_7_8Data[i])
        break;  
    }    
    if(i>=17)                                              //Rx success
      return(1);
    else
      return(0);
  }
  else
    return(0);
}

/**********************************************************
**Name:     sx1276_7_8_LoRaEntryTx
**Function: Entry Tx mode
**Input:    None
**Output:   None
**********************************************************/
unsigned char sx1276_7_8_LoRaEntryTx(void)
{
  unsigned char addr,temp;
    
  sx1276_7_8_Config();                                         //setting base parameter
    
  SPIWrite(REG_LR_PADAC,0x87);                                   //Tx for 20dBm
  SPIWrite(LR_RegHopPeriod,0x00);                               //RegHopPeriod NO FHSS
  SPIWrite(REG_LR_DIOMAPPING1,0x41);                       //DIO0=01, DIO1=00, DIO2=00, DIO3=01
  
  sx1276_7_8_LoRaClearIrq();
  SPIWrite(LR_RegIrqFlagsMask,0xF7);                       //Open TxDone interrupt
  SPIWrite(LR_RegPayloadLength,21);                       //RegPayloadLength  21byte
  
  addr = SPIRead(LR_RegFifoTxBaseAddr);           //RegFiFoTxBaseAddr
  SPIWrite(LR_RegFifoAddrPtr,addr);                        //RegFifoAddrPtr
	SysTime = 0;
	while(1)
	{
		temp=SPIRead(LR_RegPayloadLength);
		if(temp==21)
		{
			break; 
		}
		if(SysTime>=3)	
			return 0;
	}
}

 uint16_t HexToInt(uint32_t u32prm)
{
    uint16_t i=0;
    uint16_t u16cnt = 0;

    if((YKQADDER[0]>=0x30)&&(YKQADDER[0]<=0x39))
        i= YKQADDER[0]-0x30;
    else
        i= YKQADDER[0]-0x37;
    u16cnt = i<<12;

   if((YKQADDER[1]>=0x30)&&(YKQADDER[1]<=0x39))
        i= YKQADDER[1]-0x30;
    else
        i= YKQADDER[1]-0x37;
        i =i<<8;
	u16cnt |=  i;	

    if((YKQADDER[2]>=0x30)&&(YKQADDER[2]<=0x39))
        i= YKQADDER[2]-0x30;
    else
        i= YKQADDER[2]-0x37;
        i =i<<4;
	u16cnt |=  i;	

    if((YKQADDER[3]>=0x30)&&(YKQADDER[3]<=0x39))
        i= YKQADDER[3]-0x30;
    else
        i= YKQADDER[3]-0x37;
  
	u16cnt |=  i;	
   
        return u16cnt;
}

/**********************************************************
**Name:     sx1276_7_8_LoRaTxPacket
**Function: Send data in LoRa mode
**Input:    None
**Output:   1- Send over
**********************************************************/
unsigned char sx1276_7_8_LoRaTxPacket(void)
{ 
  unsigned char TxFlag=0;
  unsigned char addr;
	static unsigned char txcnt =0;
  
	sx1276_7_8Data[0] = (unsigned char)(gtArm.ykq_add>>8);
	sx1276_7_8Data[1] = (unsigned char)(gtArm.ykq_add&0xff);
	sx1276_7_8Data[2] = (gtTp.tf_X_Y_add >>16);
	sx1276_7_8Data[3] = (gtTp.tf_X_Y_add >>8);
	sx1276_7_8Data[4] = (gtTp.tf_X_Y_add >>0);
	
	BurstWrite(0x00, (unsigned char *)sx1276_7_8Data, 4);
	SPIWrite(LR_RegOpMode,0x8b);                    //Tx Mode           
	while(1)
	{
		if(Get_SX1278_IRQ_Status() == 0x08)                      //Packet send over
		{      
			SPIRead(LR_RegIrqFlags);
			sx1276_7_8_LoRaClearIrq();                                //Clear irq
				
			sx1276_7_8_Standby();                                     //Entry Standby mode      
			
			break;
		}
	} 
}

/**********************************************************
**Name:     sx1276_7_8_ReadRSSI
**Function: Read the RSSI value
**Input:    none
**Output:   temp, RSSI value
**********************************************************/
unsigned char sx1276_7_8_ReadRSSI(void)
{
  unsigned char temp=0xff;
	
  temp=SPIRead(0x11);
  temp>>=1;
  temp=127-temp;                                           //127:Max RSSI
  return temp;
}
/**********************************************************
**Name:     sx1276_7_8_Config
**Function: sx1276_7_8 base config
**Input:    mode
**Output:   None
**********************************************************/
unsigned char sx1276_7_8_Config(void)
{
  unsigned char i , s = 0; 

  sx1276_7_8_Sleep();                                      //Change modem mode Must in Sleep mode 
  
	//for(i=250;i!=0;i--)                                      //Delay
    //NOP();
	//delay_ms(15);

  //lora mode
	sx1276_7_8_EntryLoRa();  
	//SPIWrite(0x5904);   //?? Change digital regulator form 1.6V to 1.47V: see errata note
    
	BurstWrite(LR_RegFrMsb,sx1276_7_8FreqTbl[0],3);  //setting frequency parameter

	//setting base parameter 
	SPIWrite(LR_RegPaConfig,sx1276_7_8PowerTbl[Power_Sel]);             //Setting output power parameter  
    
	SPIWrite(LR_RegOcp,0x0B);                              //RegOcp,Close Ocp
	SPIWrite(LR_RegLna,0x23);                              //RegLNA,High & LNA Enable
    
	if(sx1276_7_8SpreadFactorTbl[Lora_Rate_Sel]==6)           //SFactor=6
	{
		unsigned char tmp;
		SPIWrite(LR_RegModemConfig1,((sx1276_7_8LoRaBwTbl[BandWide_Sel]<<4)+(CR<<1)+0x01));//Implicit Enable CRC Enable(0x02) & Error Coding rate 4/5(0x01), 4/6(0x02), 4/7(0x03), 4/8(0x04)
		SPIWrite(LR_RegModemConfig2,((sx1276_7_8SpreadFactorTbl[Lora_Rate_Sel]<<4)+(CRC<<2)+0x03));
      
		tmp = SPIRead(0x31);
		tmp &= 0xF8;
		tmp |= 0x05;
		SPIWrite(0x31,tmp);
		SPIWrite(0x37,0x0C);
	} 
	else
	{
		SPIWrite(LR_RegModemConfig1,((sx1276_7_8LoRaBwTbl[BandWide_Sel]<<4)+(CR<<1)+0x00));//Explicit Enable CRC Enable(0x02) & Error Coding rate 4/5(0x01), 4/6(0x02), 4/7(0x03), 4/8(0x04)
		SPIWrite(LR_RegModemConfig2,((sx1276_7_8SpreadFactorTbl[Lora_Rate_Sel]<<4)+(CRC<<2)+0x03));  //SFactor &  LNA gain set by the internal AGC loop 
	}
	SPIWrite(LR_RegSymbTimeoutLsb,0xFF);                   //RegSymbTimeoutLsb Timeout = 0x3FF(Max) 
    
	SPIWrite(LR_RegPreambleMsb,0x00);                       //RegPreambleMsb 
	SPIWrite(LR_RegPreambleLsb,12);                      //RegPreambleLsb 8+4=12byte Preamble
	
	s = SPIRead(LR_RegPreambleLsb);
    
	SPIWrite(REG_LR_DIOMAPPING2,0x01);                     //RegDioMapping2 DIO5=00, DIO4=01
	
  sx1276_7_8_Standby();                                         //Entry standby mode
	
	return s == 12;
}
unsigned int intcnt =0;
//50ms
void SX1276_TASK(void)
{
	static unsigned char u8cnt =0;

	  intcnt ++;

		switch (gtArm.Call_Sx1276_State) {
			case 0:
				#ifdef MAIN_433
				SX1278_Main_IO_Init();
				#else
				SX1278_IO_Init();
				#endif
			
				gtArm.Call_Sx1276_State ++;
				break;
			
			case 1:
				if(sx1276_7_8_Config() != 0) {
					gtArm.Call_Sx1276_State ++;
				}
				break;
			case 2:
				sx1276_7_8_LoRaEntryRx();
		  	gtArm.Call_Sx1276_State ++;
				break;
		case 3:
				#ifdef MAIN_433
					gtArm.Call_Sx1276_State =10;
				#endif
				break;
			case 4:
					sx1276_7_8_LoRaEntryTx();
					gtArm.Call_Sx1276_State ++;
				break;
			case 5:
				sx1276_7_8_LoRaTxPacket();
			gtArm.Call_Sx1276_State ++;
				break;
			case 6:
				u8cnt ++;
			  if (u8cnt >10) {
					u8cnt =0;
					gtArm.Call_Sx1276_State ++;
				}
				break;
			
				case 7:
					sx1276_7_8_LoRaEntryRx();
				gtArm.Call_Sx1276_State ++;
				break;
				case 8:
					u8cnt ++;
			  if (u8cnt >1) {
					u8cnt =0;
				//	gtArm.Call_Sx1276_State =3;
				}
				break;
					case 10:
				sx1276_7_8_LoRaRxPacket();
					break;
		}
	
}