睿迪接线图

 

main()
{   
    u8 xdata b[5];

  SysTime       = 0;
    mode          = 0x01;//lora mode
    Freq_Sel      = 0x00;//433M
    Power_Sel     = 0x00;//20dB
    Lora_Rate_Sel = 0x06;//扩频因子为12
    BandWide_Sel  = 0x07;//125KHZ
    Fsk_Rate_Sel  = 0x00;//FSK模式下的扩频因子
    
    sx1276_7_8_Config();//设置频率，增益，扩频因子，纠错编码率4/5，前导码12字节
    //扩频模式初始化      //关闭过流保护，打开低噪声放大器，打开CRC，显式报头，超时，增益自动校正
                        //preambleDetect到DIO映射 DIO0 TxDone
    while(1)
    {
        sx1276_7_8_LoRaEntryTx();     //Entry Tx mode
        sx1276_7_8_LoRaTxPacket();  //Send data in LoRa mode
        delay_ms(5000);
        sx1276_7_8_LoRaEntryRx();     //进入LORa RX模式
        if(sx1276_7_8_LoRaRxPacket()) //Receive data in LoRa mode
        {
        b[0]=RxData[0];
        RxData[0]=0x00;
           if(b[0]=="1")
           {
           b[0]=0x00;
           sx1276_7_8_Sleep();
           delay_ms(100);
           rx_yes;
           delay_ms(100);
           rx_no;
        }
        }    
    }    
}

 

 

main 定义
u8   mode;//lora--1/FSK--0
u8   Freq_Sel;
u8   Power_Sel;
u8   Lora_Rate_Sel;
u8   BandWide_Sel;
u8   Fsk_Rate_Sel;
u16  SysTime;
1278.h 使用
extern u8   mode;       //提示编译器遇到此变量或函数时，在其它模块中寻找其定义    
extern u8   Freq_Sel;
extern u8   Power_Sel;
extern u8   Lora_Rate_Sel;
extern u8   BandWide_Sel;
extern u8   Fsk_Rate_Sel;
extern u16  SysTime;   
 

 

 

sbit RF_RST            = P1^4;
sbit SCK                = P1^3;
sbit MISO               = P1^2;
sbit MOSI               = P1^1;
sbit nCS                   = P1^0;
sbit RF_IRQ_DIO0    = P3^2;
sbit Get_NIRQ       = P3^2;

 

/************************************************************************

///

///

///

///

///

;*******************************MAIN****************************************
;                                             --------------------
;                                   P1.0  |1                 40|  VCC
;                                   P1.1  |2                 39|  P0.0     ----  LCD_DATA0
;        RF_SCK  ----      P1.2  |3                 38|  P0.1     ----  LCD_DATA1
;        RF_SDIO ----      P1.3  |4                 37|  P0.2     ----  LCD_DATA2
;                                   P1.4  |5                 36|  P0.3     ----  LCD_DATA3
;        RF_SCS  ----      P1.5  |6                 35|  P0.4     ----  LCD_DATA4
;                                   P1.6  |7                 34|  P0.5     ----  LCD_DATA5
;                                   P1.7  |8                 33|  P0.6     ----  LCD_DATA6
;                            RST/Vpd  |9                 32|  P0.7     ----  LCD_DATA7
;                           RXD/P3.0  |10                31|  /EA/Vpp
;                           TXD/P3.1  |11                30|  ALE/PROG
;  RF_GPIO2 --- /INT0/P3.2  |12                29|  /PSEN
;  RF_GPIO1 --- /INT1/P3.3  |13                28|  P2.7     ----  KEY4
;                              T0/P3.4  |14                27|  P2.6     ----  KEY3
;        RX\TX   ---     T1/P3.5  |15                26|  P2.5     ----  KEY2
;                            /WR/P3.6  |16                25|  P2.4     ----  KEY1
;                             /RD/P3.7  |17                24|  P2.3
;                                XTAL2  |18                23|  P2.2     ----  LCD_RW
;                                XTAL1  |19                22|  P2.1     ----  LCD_RS
;                                    VSS  |20                21|  P2.0     ----  LCD_EN
;                                               --------------------
;                                                W78E52B
;***********************************************************************/

#include "..\header\main.h"
#include "..\header\maindef.h"

bit Wait_Ack = 0;                    // 等待RF应答
bit Clr_Screen = 0;                    // 刷新屏幕
bit F_Dispose_Rf_Data = 0;

U8 Timer0_Cnt = 0;                    // 定时器0计数器

U8 System_Mode = NORMAL_MODE;        // rf 工作模式

enum Rf_Status Rf_Mode_Cnt; 
        
//U8 Rf_Rec_Channel = 0;                // default frequency 2.400GHZ

//U8 Rf_Rec_Buf[RF_DATA_PACKET_SIZE] = {0};
//U8 Rf_Send_Buf[RF_DATA_PACKET_SIZE] = {0};

U8 const code HexDispArray[16] = "0123456789ABCDEF";

uint8 Flg_RxFinish;
U8 Sx1276VerNO;

// 主程序入口
void main(void)
{
    EA = 0;
    delay_2us(5000);
    ini_mcu();
    delay_2us(5000);

    //ini_lcd();
    delay_2us(5000);

    //lcd_printf_string("COOLWAVE", ROW(0x00)|LEN(0x08)|COL(0x00));
    //lcd_printf_string(" A7125  ", ROW(0x01)|LEN(0x08)|COL(0x00));

    //ini_rf();
    Freq_Sel = 0x00;//433M
    Power_Sel = 0x00;//
    Lora_Rate_Sel = 0x06;//
    BandWide_Sel = 0x07;
    Fsk_Rate_Sel = 0x00;
  sx1276_7_8_Config();//
    sx1276_7_8_LoRaEntryRx();
    
    GLED = 1 ;
    RLED = 1;
#if 1    //1:master    0:slaver   
    while(1)
    {
        if(!KEY4)
        {
            GLED = 1 ;
        RLED = 0;
              
                  while(!KEY4);
                
              sx1276_7_8_LoRaEntryTx();
                    sx1276_7_8_LoRaTxPacket();
            
                    
                    sx1276_7_8_LoRaEntryRx();
                delay_2us(5000);
                delay_2us(5000);
                delay_2us(5000);
                delay_2us(50000);
                if(sx1276_7_8_LoRaRxPacket())
                    {
                         GLED = 0 ;
               RLED = 1;
                          
                    }
                else
                    {
                         GLED = 1 ;
               RLED = 1;
                    }
                
                
            
        }
    }
#else    
    while(1)
    {
        
        
        if(sx1276_7_8_LoRaRxPacket())
        {
                    GLED = 0 ;
              RLED = 0;            
              delay_2us(5000);
              GLED = 1 ;
              RLED = 1;            
              //delay_2us(5000);
                //sx1276_7_8_LoRaEntryRx();
            Wait_Ack = 1;        
        }
        if(Wait_Ack)
        {
             Wait_Ack = 0;
       sx1276_7_8_LoRaEntryTx();
             sx1276_7_8_LoRaTxPacket();
                    
            
             sx1276_7_8_LoRaEntryRx();             
        }
        
    }
    
#endif    
}

/***********************************************************
name:        ini_mcu
input:        none
output:        none
describe:    初始化MCU
notice:
************************************************************/
void ini_mcu(void)
{
    PSW = 0x00;
     PCON = 0x00;
     IP = 0x00;             // 设置中断优先级
    IE = 0x00;             //  EA   -    ET2  ES   ET1  EX1  ET0  EX0 , disable all interrupt

    ini_int1();
    ini_timer0();
}

/**********************************************************
name:        ini_int1
input:        none
output:        none
describe:    设置 int1中断方式
notice:
**********************************************************/
void ini_int1(void)
{
    IT1 = 1;                // 下降沿中断
    IE1 = 0;
    EX1 = 0;                //disable int1 中断
}

/***********************************************************
name:        ini_timer0
input:        none
output:        none
describe:    初始化定时器0
notice:
************************************************************/
void ini_timer0(void)
{
    TF0 = 0;
    TH0 = 0x94;
     TL0 = 0x00;                    // 定时10ms

    TMOD = 0x01;                // timer0 工作在方式1
//    ET0 = 0x01;                    // 允许timer0中断
//    TR0 = 1;                    // enable timer0
}

/**********************************************************
name:        dispose_timer0
input:        none
output:        none
describe:    处理定时器0
notice:    
creat date:    2008-7-24
creator:    dengyihong
**********************************************************/
void dispose_timer0(void)
{
    if(TF0)                        
    {
        TF0 = 0;
        TH0 = 0x94;
        TL0 = 0x00;                // 定时10ms

        
    }
}

/**********************************************************
name:        delay_2us
input:        delay_cnt
output:        none
describe:    delay x*2us
notice:
creat date:    2008-7-24
creator:    dengyihong
**********************************************************/
void delay_2us(U16 delay_cnt)
{
    while(delay_cnt--);
}

///

///

///

///

///

 

/************************************************************************
;copyright        :
;filename        :lcd.c
;lcd            :TC802B-01
;control mcu    :w78e52b
;writeby        :
;describe        :LCD control
;notice            :
;***********************************************************************/

#include "..\header\lcd.h"

/***********************************************************
name:        ini_lcd        
input:        none
output:        none
describe:    初始化LCD    
notice:
creat date: 2008-7-25
creator:    dengyihong
************************************************************/
void ini_lcd(void)
{
    lcd_write_reg(0x38);
    lcd_write_reg(0x38);
    lcd_write_reg(0x38);
    lcd_write_reg(0x08);
    lcd_wait();
    lcd_write_reg(0x01);
    lcd_wait();
    delay_2us(50000);
    
    lcd_write_reg(0x14);
    lcd_wait();
    lcd_write_reg(0x06);
    lcd_wait();
    lcd_write_reg(0x80);
    lcd_wait();
    lcd_write_reg(0x0c);
    lcd_wait();    
}

/***********************************************************
name:        lcd_printf_string    
input:        *disp_str  ---  存放显示字符的头指针
            row_len_col  ---  显示坐标参数及显示字符数
            row_len_col:
                bit[7:6]: 显示行坐标
                bit[5:3]: 显示字符长度
                bit[2:0]: 显示字符的起始列坐标
output:        none
describe:    在屏幕上显示多个字符        
notice:
creat date: 2008-7-25
creator:    dengyihong
************************************************************/
void lcd_printf_string(U8 *disp_str, U8 row_len_col)
{
    U8 i = 0;
    U8 len = 0;
    
    len = (row_len_col & LEN_MASK) >> 0x03;
    
    lcd_write_reg(row_len_col & ROW_COL);
    lcd_wait();
    
    for(i=0; i<=len; i++)
    {
        lcd_write_data(*disp_str++);
        lcd_wait();    
    }
}

/***********************************************************
name:        lcd_printf_char        
input:        disp_char  ---  要显示的字符
            row_col    ---  显示坐标
output:        none
describe:    在屏幕上显示一个字符        
notice:
creat date: 2008-7-25
creator:    dengyihong
************************************************************/
/*
void lcd_printf_char(U8 disp_char, U8 row_col)
{
    lcd_write_reg(row_col & ROW_COL);
    lcd_wait();
    lcd_write_data(disp_char);
    lcd_wait();    
}
*/

/***********************************************************
name:        lcd_write_reg        
input:        command  ---  要写入的命令
output:        none
describe:    写控制命令到LCD    
notice:
creat date: 2008-7-25
creator:    dengyihong
************************************************************/
void lcd_write_reg(U8 command)
{
    LCD_DATA = command;        // 写控制命令
    LCD_RS = 0;
    LCD_RW = 0;
    LCD_EN = 1;
    delay_2us(100);
    LCD_EN = 0;
}

/***********************************************************
name:        lcd_write_data        
input:        value  ---  要写入的数据
output:        none
describe:    写数据到LCD    
notice:
creat date: 2008-7-25
creator:    dengyihong
************************************************************/
void lcd_write_data(U8 value)
{
   LCD_DATA =  value;        //写数据
   LCD_RS = 1;
   LCD_RW = 0;
   LCD_EN = 1;
   delay_2us(100);
   LCD_EN = 0;     
}

/***********************************************************
name:        lcd_wait    
input:        none
output:        none
describe:    等待LCD内部操作完成    
notice:
creat date: 2008-7-25
creator:    dengyihong
************************************************************/
void lcd_wait(void)
{
    U8 value = 0;
       
    do
    {
        LCD_RS = 0;
        LCD_RW = 1;
        LCD_EN = 1;
        value = LCD_DATA;    
        LCD_EN = 0;
    }while(value & 0x80);        // 等待内部操作完成    
}

///

///

///

///

///

 

 

/**********************************************************
;copyright        :
;filename        :key.c
;writeb            :
;describe        :按键扫描
;notice            :
;*********************************************************/

#include "..\header\key.h"

enum Key_Info Key_Value;        // 按键值

U8  Key_Old_Buf = MASK_KEY;

bit Key_Msg = 0;                // 处理按键消息标志
bit Have_Key_Push = 0;            // 按键按下标志

/**********************************************************
name:        key_scan
input:       none
output:         none
describe:    按键扫描
notice:
creat date:  2008-6-10
creator:     dengyihong
**********************************************************/
void key_scan(void)
{
    U8 i = 0;
    U8 key_buf = 0;
    U8 temp_buf = 0;
    
    KEY_PIN_INPUT();
    delay_2us(1);
    key_buf = GET_KEY_VALUE();
    for(i=0; i<3; i++)
    {   
        delay_2us(500);        
        temp_buf = GET_KEY_VALUE();
        if(key_buf != temp_buf)
        {
            return;    
        }
    }
            
    if(key_buf != Key_Old_Buf)
    {
        if(key_buf != MASK_KEY)                    // 新键按下
        {
            switch(key_buf)
            {
                case 0x70: 
                     Key_Value = COMMUN_KEY;        // send key
                break;
                       
                case 0xb0:  
                     Key_Value = ADD_KEY;        // + key
                break;
                    
                case 0xd0:  
                     Key_Value = DEC_KEY;        // - key
                break; 
                    
                case 0xe0:  
                     Key_Value = SEND_STATUS_KEY;        // mode key
                break;                 
                                                                                  
                default:    
                     Key_Value = NONE_KEY;    
                break;
            }
            if(Key_Value != NONE_KEY)        // 是否有按键按下
            {
                Have_Key_Push = 1;
                Key_Old_Buf = key_buf;    
            }
        }
        else if(Have_Key_Push)                // 按键释放
        {
            Have_Key_Push = 0;
            Key_Old_Buf = MASK_KEY;
            switch(Key_Value)
            {
                case 0x04:
                case 0x03:
                case 0x02:
                case 0x01:
                     Key_Msg = 1 ;
                break; 
                        
                default:
                    Key_Msg = 0;  
                break;                 
            }
        }       
    }        
}

///

///

///

///

///

#include "..\header\rf.h"

extern u8 mode;
extern u8 Freq_Sel;
extern u8 Power_Sel;
extern u8 Lora_Rate_Sel;
extern u8 BandWide_Sel;
extern u8 Fsk_Rate_Sel;
extern u16 SysTime;

u8 gb_SF;
u8  gb_BW;
//u8  CR;          //LR_RegModemConfig1 
  
#define CRC   0x01  //CRC Enable

#define datlen 11

u8 gtmp;
/**********************************************************
**Parameter table define
**********************************************************/

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

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

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

u8 const code 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
};

u8 const code  sx1276_7_8Data[] = {"HR_WT Lora sx1276_7_8"};

/ FSK mode //
u16 const code sx1276_7_8FSKRateTbl[4][2] = 
{
  {0x68, 0x2B},         //BR=1.2Kbps
  {0x34, 0x15},         //BR=2.4Kbps
  {0x1A, 0x0B},         //BR=4.8Kbps
  {0x0D, 0x05},         //BR=9.6Kbps
};

/ Test mode //
u8 const code TxTestFiFoData[57] = {
                        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
                        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
                        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
                        0xff, 0xff, 
                        0xff, 0xff, 0xff, 0xff, 
                        0xff, 
                        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
                        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
                        0xff, 0xff, 
                        0xff, 0xff, 0xff, 0xff, 0xff
                        };

u8 RxData[64];

void delayms(unsigned int t)
{
    unsigned int i;
    unsigned char j; 
    for(i=0;i<t;i++)
    for(j=0;j<120;j++);
}

/**********************************************************
**Name:     SPICmd8bit
**Function: SPI Write one byte
**Input:    WrPara
**Output:   none
**note:     use for burst mode
**********************************************************/
void SPICmd8bit(u8 WrPara)
{
  u8 bitcnt;  
  nCS=0;
  SCK=0;
  
  for(bitcnt=8; bitcnt!=0; bitcnt--)
  {
    SCK=0;
    if(WrPara&0x80)
      MOSI=1;
    else
      MOSI=0;
       ;;    
    SCK=1;
    ;
    WrPara <<= 1;
  }
  SCK=0;
  MOSI=1;
}

/**********************************************************
**Name:     SPIRead8bit
**Function: SPI Read one byte
**Input:    None
**Output:   result byte
**Note:     use for burst mode
**********************************************************/
u8 SPIRead8bit(void)
{
 u8 RdPara = 0;
 u8 bitcnt;
 
  nCS=0;
  MOSI=1;                                                 //Read one byte data from FIFO, MOSI hold to High
  for(bitcnt=8; bitcnt!=0; bitcnt--)
  {
    SCK=0;
    ;;
    RdPara <<= 1;
    SCK=1;
    if(MISO)
      RdPara |= 0x01;
    else
      RdPara |= 0x00;
  }
  SCK=0;
  return(RdPara);
}

/**********************************************************
**Name:     SPIRead
**Function: SPI Read CMD
**Input:    adr -> address for read
**Output:   None
**********************************************************/
u8 SPIRead(u8 adr)
{
  u8 tmp; 
  SPICmd8bit(adr);                                         //Send address first
  tmp = SPIRead8bit();  
  nCS=1;
  return(tmp);
}
/**********************************************************
**Name:     SPIWrite
**Function: SPI Write CMD
**Input:    WrPara -> address & data
**Output:   None
**********************************************************/
void SPIWrite(u8 adr, u8 WrPara)                
{                                                       
  //u8 bitcnt;    
  
  //SCK=0;
  nCS=0;
  
  SPICmd8bit(adr|0x80);         //???? 
    SPICmd8bit(WrPara);//????
    
  SCK=0;
  MOSI=1;
  nCS=1;
}

/**********************************************************
**Name:     SPIBurstRead
**Function: SPI burst read mode
**Input:    adr-----address for read
**          ptr-----data buffer point for read
**          length--how many bytes for read
**Output:   None
**********************************************************/
void SPIBurstRead(u8 adr, u8 *ptr, u8 length)
{
  u8 i;
  if(length<=1)                                            //length must more than one
    return;
  else
  {
    SCK=0; 
    nCS=0;
    SPICmd8bit(adr); 
    for(i=0;i<length;i++)
    ptr[i] = SPIRead8bit();
    nCS=1;  
  }
}
/**********************************************************
**Name:     SPIBurstWrite
**Function: SPI burst write mode
**Input:    adr-----address for write
**          ptr-----data buffer point for write
**          length--how many bytes for write
**Output:   none
**********************************************************/
void BurstWrite(u8 adr, u8 *ptr, u8 length)
{ 
  u8 i;

  if(length<=1)                                            //length must more than one
    return;
  else  
  {   
    SCK=0;
    nCS=0;        
    SPICmd8bit(adr|0x80);
    for(i=0;i<length;i++)
    SPICmd8bit(ptr[i]);
    nCS=1;  
  }
}

/**********************************************************
**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_Config
**Function: sx1276_7_8 base config
**Input:    mode
**Output:   None
**********************************************************/
void sx1276_7_8_Config(u8 mode)
{
  u8 i; 
    
  sx1276_7_8_Sleep();                                      //Change modem mode Must in Sleep mode 
  for(i=250;i!=0;i--)                                      //Delay
    ;
    delayms(15);

  if(mode == 0x01)//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[Freq_Sel],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
    {
      u8 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
    
    SPIWrite(REG_LR_DIOMAPPING2,0x01);                     //RegDioMapping2 DIO5=00, DIO4=01
  
  }
  else
  {
        sx1276_7_8_Sleep();                                      //Change modem mode Must in Sleep mode 
        BurstWrite(LR_RegFrMsb,sx1276_7_8FreqTbl[Freq_Sel],3);  //setting frequency parameter
        
    SPIWrite(LR_RegPaConfig,sx1276_7_8PowerTbl[Power_Sel]);             //Setting output power parameter
    
    SPIWrite(RegFdevMsb,0x02);
        SPIWrite(RegFdevMsb,0x3d);//Fdev 35k
        
        SPIWrite(RegOcp,0x0b);//Close Ocp
        SPIWrite(RegLna,0x23);//High & LNA Enable
        
        SPIWrite(RegRxBw,0x12);//83KHz
        
        SPIWrite(RegPreambleDetect,0xa0);//Enable 2Byte 
        SPIWrite(RegPreambleMsb,0x00);
        SPIWrite(RegPreambleLsb,0x06);//6Byte Preamble
        
        SPIWrite(RegSyncConfig,0x92);//Sync 2+1=3bytes
        SPIWrite(RegSyncValue1,0xaa);
        SPIWrite(RegSyncValue2,0x2d);
        SPIWrite(RegSyncValue3,0xd4);//SyncWord = aa2dd4
        
        SPIWrite(RegPacketConfig1,0x00);//Disable CRC,NRZ
        SPIWrite(RegPacketConfig2,0x40);//Packet Mode
        
        SPIWrite(RegPayloadLength,0x15);//21bytes Fixed
        SPIWrite(RegFifoThresh,0x95);//FiFoThresh   21bytes 
  }
  sx1276_7_8_Standby();                                         //Entry standby mode
}

/**********************************************************
**Name:     sx1276_7_8_LoRaEntryRx
**Function: Entry Rx mode
**Input:    None
**Output:   None
**********************************************************/
u8 sx1276_7_8_LoRaEntryRx(void)
{
  u8 addr; 
        
  sx1276_7_8_Config(1);                                         //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;
    //delayms(15);
    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
**********************************************************/
u8 sx1276_7_8_LoRaReadRSSI(void)
{
  u16 temp=10;
  temp=SPIRead(LR_RegRssiValue);                  //Read RegRssiValue,Rssi value
  temp=temp+127-137;                                       //127:Max RSSI, 137:RSSI offset
  return (u8)temp;
}

/**********************************************************
**Name:     sx1276_7_8_LoRaRxPacket
**Function: Receive data in LoRa mode
**Input:    None
**Output:   1- Success
            0- Fail
**********************************************************/
bit sx1276_7_8_LoRaRxPacket(void)
{
  u8 i; 
  u8 addr;
  u8 packet_size;
 
  if(Get_NIRQ)
  {
    for(i=0;i<32;i++) 
      RxData[i] = 0x00;
    
    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();
        if(RxData[3]==0x03)
        return(1);
        else
    return(0);
/*        
    for(i=0;i<17;i++)
    {
      if(RxData[i]!=sx1276_7_8Data[i])
            
        break;  
    }    
    if(i>=13)                                              //Rx success
      return(1);
    else
      return(0);
*/        
        
  }
  else
    return(0);
}
/**********************************************************
**Name:     sx1276_7_8_LoRaEntryTx
**Function: Entry Tx mode
**Input:    None
**Output:   None
**********************************************************/
u8 sx1276_7_8_LoRaEntryTx(void)
{
  u8 addr,temp;
    
  sx1276_7_8_Config(1);                                         //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;
    //delayms(15);
    while(1)
    {
        temp=SPIRead(LR_RegPayloadLength);
        if(temp==21)
        {
            break; 
        }
        if(SysTime>=3)    
            return 0;
    }
}
/**********************************************************
**Name:     sx1276_7_8_LoRaTxPacket
**Function: Send data in LoRa mode
**Input:    None
**Output:   1- Send over
**********************************************************/
u8 sx1276_7_8_LoRaTxPacket(void)
{ 
    u8 i;
  u8 TxFlag=0;
  u8 addr;
    
  for(i=0;i<32;i++) 
      RxData[i] = i;
    //BurstWrite(0x00, (u8 *)sx1276_7_8Data, 21);
    BurstWrite(0x00, RxData, 21);
    SPIWrite(LR_RegOpMode,0x8b);                    //Tx Mode           
    while(1)
    {
        if(Get_NIRQ)                      //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
**********************************************************/
u8 sx1276_7_8_ReadRSSI(void)
{
  u8 temp=0xff;
    
  temp=SPIRead(0x11);
  temp>>=1;
  temp=127-temp;                                           //127:Max RSSI
  return temp;
}

/**********************************************************
**Name:     sx1276_7_8_FskClearFIFO
**Function: Change to RxMode from StandbyMode, can clear FIFO buffer
**Input:    None
**Output:   None
**********************************************************/
void sx1276_7_8_FskClearFIFO(void)
{
  SPIWrite(RegOpMode,0x01);                                        //Standby
  SPIWrite(RegOpMode,0x0d);                                               //entry RxMode
}

/**********************************************************
**Name:     sx1276_7_8_FskEntryRx
**Function: Set RFM69 entry FSK Rx_mode
**Input:    None
**Output:   "0" for Error Status
**********************************************************/
u8 sx1276_7_8_FskEntryRx(void)
{
  //u8 i;
    
  sx1276_7_8_Config(0);  
  
    SPIWrite(RegBitRateMsb,sx1276_7_8FSKRateTbl[Fsk_Rate_Sel][0]);
    SPIWrite(RegBitRateLsb,sx1276_7_8FSKRateTbl[Fsk_Rate_Sel][1]);         //setting rf rate parameter 

    SPIWrite(RegPaConfig,0x0f);//RFIO Pin
    SPIWrite(RegDioMapping1,0x0c);
    SPIWrite(RegDioMapping2,0x00);//DIO0 Mapping for IRQ / DIO2 for RxData
    SPIWrite(RegPaDac,0x84);//Normal and Rx 
      
  SPIWrite(RegOpMode,0x0d);                                   //entry RxMode
    
    SysTime = 0;
    while(1)
    {
        if((SPIRead(0x3e)&0xC0)==0xC0)                          //Status OK?
            break;
        if(SysTime>=3)    
            return 0;                                              //over time for error
    }
    
}
/**********************************************************
**Name:     sx1276_7_8_FskRxPacket
**Function: Check for receive one packet
**Input:    none
**Output:   "!0"-----Receive one packet
**          "0"------Nothing for receive
**********************************************************/
u8 sx1276_7_8_FskRxPacket(void)
{
  u8 i; 
 
  if(Get_NIRQ)
  { 
    for(i=0;i<32;i++) 
      RxData[i] = 0x00;  
    
    SPIBurstRead(0x00, RxData, 21);  
    sx1276_7_8_FskClearFIFO();
    for(i=0;i<17;i++)
    {
      if(RxData[i]!=sx1276_7_8Data[i])
        break;  
    }
    if(i>=17) 
      return(1);                                           //Rx success
    else
      return(0);
  }
  else
    return(0);  
}

/**********************************************************
**Name:     sx1276_7_8_FskEntryTx
**Function: Set sx1276_7_8 entry FSK Tx_mode
**Input:    None
**Output:   "0" for Error Status
**********************************************************/
u8 sx1276_7_8_FskEntryTx(void)
{
  //u8 i;
  
  sx1276_7_8_Config(0);
    
    SPIWrite(RegBitRateMsb,sx1276_7_8FSKRateTbl[Fsk_Rate_Sel][0]);
    SPIWrite(RegBitRateLsb,sx1276_7_8FSKRateTbl[Fsk_Rate_Sel][1]);         //setting rf rate parameter 
    
    SPIWrite(RegDioMapping1,0x00);
    SPIWrite(RegDioMapping2,0x00);//DIO0 Mapping for IRQ / DIO2 for RxData
    SPIWrite(RegPaDac,0x87);//20dBm Tx     
    
  SPIWrite(RegOpMode,0x0b);
    
    SysTime = 0;
    while(1)
    {
        if((SPIRead(0x3e)&0xA0)==0xA0)                          //Status OK?
            break;
        if(SysTime>=3)    
            return 0;                                              //over time for error
    }
    
}

/**********************************************************
**Name:     sx1276_7_8_FskTxPacket
**Function: Check sx1276_7_8 send over & send next packet
**Input:    none
**Output:   TxFlag=1, Send success
**********************************************************/
u8 sx1276_7_8_FskTxPacket(void)
{
  u8 TxFlag=0;
    
    BurstWrite(0x00, (u8 *)sx1276_7_8Data, 21);          
  
    while(1)                      //Packet send over
    {     
        if(Get_NIRQ)
        {
            sx1276_7_8_Standby();                                     //Entry Standby mode      
            break;
        }
    }  
}

void sx1276_7_8_TestConfig(void)
{
  u8 i;
  
  for(i=200;i!=0;i--)                                      //Delay
    ; 
  for(i=200;i!=0;i--)                                      //Delay
    ;  
    delayms(15);  
  sx1276_7_8_Sleep();                                           //Change modem mode Must in Sleep mode 
    sx1276_7_8_Sleep();                                           //Change modem mode Must in Sleep mode 
    delayms(20);

  BurstWrite(LR_RegFrMsb,sx1276_7_8FreqTbl[Freq_Sel],3);  //setting frequency parameter
    
    SPIWrite(RegBitRateMsb,sx1276_7_8FSKRateTbl[Fsk_Rate_Sel][0]);
    SPIWrite(RegBitRateLsb,sx1276_7_8FSKRateTbl[Fsk_Rate_Sel][1]);         //setting rf rate parameter 
    
    SPIWrite(LR_RegPaConfig,sx1276_7_8PowerTbl[Power_Sel]);             //Setting output power parameter
    
    SPIWrite(RegFdevMsb,0x02);
    SPIWrite(RegFdevMsb,0x3d);//Fdev 35k
        
    SPIWrite(RegOcp,0x0b);//Close Ocp
    //SPIWrite(RegLna,0x23);//High & LNA Enable
    SPIWrite(RegLna,0x20);//High & LNA disable
    
    SPIWrite(RegRxBw,0x12);//83KHz
    
    SPIWrite(RegPreambleDetect,0xa0);//Enable 2Byte
    //SPIWrite(RegPreambleDetect,0x20);//disable
    
    SPIWrite(RegPreambleMsb,0x00);
    SPIWrite(RegPreambleLsb,0x00);//0Byte Preamble
    
    SPIWrite(RegPacketConfig1,0x00);//fix packet Disable CRC,NRZ
    //SPIWrite(RegPacketConfig2,0x40);//Packet Mode
    
  sx1276_7_8_Standby();  
}
///

///

///

///

///

#ifndef _IO_H
#define _IO_H

#include "..\header\maindef.h"

// rf bit define
/*
sbit     RF_SCK = P1^2;
sbit     RF_SDIO = P1^3;
sbit     RF_SCS = P1^5;
sbit     RF_GPIO2 = P3^2;
sbit     RF_GPIO1 = P3^3;
sbit     RF_TX_PA = P3^5;
*/
sbit RF_RST            = P1^4;
sbit SCK                = P1^3;
sbit MISO               = P1^2;
sbit MOSI               = P1^1;
sbit nCS                   = P1^0;
sbit RF_IRQ_DIO0    = P3^2;
sbit Get_NIRQ       = P3^2;

// lcd bit define
sbit     LCD_RW = P2^2;
sbit     LCD_RS = P2^1;
sbit     LCD_EN = P2^0;
#define  LCD_DATA P0
// sfr      LCD_DATA = 0x80; 

// key bit define
sbit     KEY1 = P2^4;       // mode key       
sbit     KEY2 = P2^5;       // - key

sbit     KEY3 = P2^6;       // + key
sbit     KEY4 = P2^7;       // send key

//led bit define
sbit     GLED = P2^4;             
sbit     RLED = P2^5; 
#endif
///

///

///

///

///

/************************************************************************************
;copyrightn   :
;filename     :key.h
;writeby      :
;*************************************************************************************/
#ifndef _KEY_H
#define    _KEY_H

#include "maindef.h"
#include "io.h"

#define  MASK_KEY     0xf0

#define  KEY_PIN_INPUT()  P2 |= MASK_KEY  
#define  GET_KEY_VALUE()  (P2 & MASK_KEY)

void key_scan(void);

extern void delay_2us(U16 delay_cnt);

#endif

///

///

///

///

///

/************************************************************************************
;copyrightn   :
;filename     :lcd.h
;writeby      :
;*************************************************************************************/

#ifndef _LCD_H
#define    _LCD_H

#include "maindef.h"
#include "io.h"

void ini_lcd(void);
void lcd_printf_char(U8 disp_char, U8 row_col);
void lcd_printf_string(U8 *disp_str, U8 row_len_col);
void lcd_write_reg(U8 command);
void lcd_write_data(U8 value);
void lcd_wait(void);

extern void delay_2us(U16 delay_cnt);

#endif

///

///

///

///

///

/************************************************************************
;copyright    :
;filename     :main.h
;writeby    :
;***********************************************************************/

#ifndef _MAIN_H
#define    _MAIN_H

#include "maindef.h"
#include "io.h"

#define cTx_Statue            0X10 //
#define cSx1276RxStatue   0x8D
#define CRX        0X01 //0--TX   1--RX  ???????  ??  ??
#define S_BW10            PA_IDR_IDR1 //INPUT
#define S_BW62            PA_IDR_IDR2 //INPUT
#define S_BW125        PB_IDR_IDR3 //INPUT
#define S_FSK            PB_IDR_IDR7 //INPUT
#define S_Tx_Rx        PC_IDR_IDR1 //INPUT
#define Sx1276_RxMode                0
#define Sx1276_TxMode              1

uint8 D_value[5];
uint8 Tx_Rx_Choice_Bak;
uint8 Tx_phase;
//uint8 Contbak;
uint8 Sx1276Statue;
uint8 SX1276_GetStatue_Cout;
uint8 ContBak=0xff;
uint8 Sx1276VerNO ;
uint8 TxTimeCout;
uint8 Trg;
uint8 Cont;

u8 mode;//lora--1/FSK--0
u8 Freq_Sel;//
u8 Power_Sel;//
u8 Lora_Rate_Sel;//
u8 BandWide_Sel;//

u8 Fsk_Rate_Sel;//

extern bit Key_Msg;
extern enum Key_Info Key_Value;

extern u8 gb_SF;
extern u8  gb_BW;
extern u8  CR;    //LR_RegModemConfig1 

extern uint8 Flg_RxFinish;

void ini_mcu(void);
void ini_int1(void);
void ini_timer0(void);

void dispose_key_info(void);
void dispose_timer0(void);
void dispose_rf_data(void);
void display_rf_channel(void);
void display_rf_rate(void);
void delay_2us(U16 delay_cnt);

void SX1276_Parameters_Select(void);

//外部函数声明 按键部分
extern void key_scan(void);

//LCD 部分

extern void ini_lcd(void);
extern void lcd_printf_char(U8 disp_char, U8 row_col);
extern void lcd_printf_string(U8 *disp_str, U8 row_len_col);

//RF 部分
extern void sx1276_7_8_Config(u8 mode);
extern u8 sx1276_7_8_LoRaEntryRx(void);

extern u8 sx1276_7_8_LoRaEntryTx(void);
extern u8 sx1276_7_8_LoRaTxPacket(void);
extern void sx1276_7_8_Standby(void);
extern sx1276_7_8_LoRaClearIrq(void);
extern bit sx1276_7_8_LoRaRxPacket(void);
#endif

///

///

///

///

///

#ifndef _MAINDEF_h
#define _MAINDEF_h

#include <REG52.H>
#include <stdlib.h>

typedef  unsigned char U8; 
typedef  unsigned int  U16; 

#define CHAE    char
#define BYTE     unsigned char
#define WORD     unsigned int
#define uint8    unsigned char
#define uint8_t    unsigned char
#define bool    unsigned char

#define u8    unsigned char

#define word   unsigned short int
#define uint16   unsigned short int
#define u16   unsigned short int
#define uint16_t   unsigned short int

#define uint32   unsigned long int
#define uint32_t   unsigned long int

#define int8     signed char
#define int8_t     signed char

#define int16    signed short int
#define int32    signed long int
#define uint64   unsigned long long int
#define int64    signed long long int

#define  RF_BUF_LEN   1
#define  UART_BUF_LEN 1

#define  RF_DATA_PACKET_SIZE  1

#define  RF_UP_CMD    0x77
#define  RF_DOWN_CMD  0x88
#define  RF_TEST_CMD  0x99

#define  NONE_KEY            0x00
#define  SEND_STATUS_KEY    0x01
#define  DEC_KEY            0x02
#define  ADD_KEY            0x03
#define  COMMUN_KEY            0x04

//enum Key_Info {none_key,mode_key,dec_key,add_key,send_key};    // 定义按键类型
enum Key_Info {none_key,send_status_key,dec_key,add_key,commun_key};    // 定义按键类型

#define    NORMAL_MODE        0
#define    TEST_MODE        1

#define    REC_STATUS        0x00
//#define    SET_RF_RATE        0x01
#define SET_RF_CHANNEL    0x01
#define    SEND_STATUS        0x02

//enum Rf_Status {rec_status,set_rf_rate,set_rf_channel,send_status};    // 定义RF模式
enum Rf_Status {rec_status,set_rf_channel,send_status};                    // 定义RF模式

#define   ROW(x)       (0x80|(x << 0x06))
#define   COL(x)       (x)
#define   LEN(x)       ((x-0x01) << 0x03)

#define   LEN_MASK     0x38
#define   COL_MASK     0x07
#define   ROW_MASK     0xC0
#define   ROW_COL      (ROW_MASK|COL_MASK)
    
#define   HexDisp(x)   HexDispArray[x]
#define   BYTE_LOW(x)  (x & 0x0F) 
#define   BYTE_HIGH(x) ((x & 0xF0)>>0x04)

#endif

///

///

///

///

///

#ifndef _RF_H
#define    _RF_H

#include   "maindef.h"
#include   "io.h"

/ LoRa mode //
//Error Coding rate (CR)setting 
#define CR_4_5    
//#define CR_4_6    0
//#define CR_4_7    0
//#define CR_4_8    0 

#ifdef   CR_4_5
  #define CR    0x01                                       // 4/5
#else
  #ifdef   CR_4_6
    #define CR    0x02                                     // 4/6
  #else 
    #ifdef   CR_4_7 
      #define CR    0x03                                   // 4/7
    #else 
      #ifdef   CR_4_8
        #define CR    0x04                                 // 4/8
      #endif
    #endif
  #endif
#endif 

//CRC Enable
#define CRC_EN    

#ifdef  CRC_EN
  #define CRC   0x01                                       //CRC Enable
#else
  #define CRC   0x00
#endif

//RFM98 Internal registers Address
/********************Lroa mode***************************/
#define LR_RegFifo                                  0x00
// Common settings
#define LR_RegOpMode                                0x01
#define LR_RegFrMsb                                 0x06
#define LR_RegFrMid                                 0x07
#define LR_RegFrLsb                                 0x08
// Tx settings
#define LR_RegPaConfig                              0x09
#define LR_RegPaRamp                                0x0A
#define LR_RegOcp                                   0x0B
// Rx settings
#define LR_RegLna                                   0x0C
// LoRa registers
#define LR_RegFifoAddrPtr                           0x0D
#define LR_RegFifoTxBaseAddr                        0x0E
#define LR_RegFifoRxBaseAddr                        0x0F
#define LR_RegFifoRxCurrentaddr                     0x10
#define LR_RegIrqFlagsMask                          0x11
#define LR_RegIrqFlags                              0x12
#define LR_RegRxNbBytes                             0x13
#define LR_RegRxHeaderCntValueMsb                   0x14
#define LR_RegRxHeaderCntValueLsb                   0x15
#define LR_RegRxPacketCntValueMsb                   0x16
#define LR_RegRxPacketCntValueLsb                   0x17
#define LR_RegModemStat                             0x18
#define LR_RegPktSnrValue                           0x19
#define LR_RegPktRssiValue                          0x1A
#define LR_RegRssiValue                             0x1B
#define LR_RegHopChannel                            0x1C
#define LR_RegModemConfig1                          0x1D
#define LR_RegModemConfig2                          0x1E
#define LR_RegSymbTimeoutLsb                        0x1F
#define LR_RegPreambleMsb                           0x20
#define LR_RegPreambleLsb                           0x21
#define LR_RegPayloadLength                         0x22
#define LR_RegMaxPayloadLength                      0x23
#define LR_RegHopPeriod                             0x24
#define LR_RegFifoRxByteAddr                        0x25

// I/O settings
#define REG_LR_DIOMAPPING1                          0x40
#define REG_LR_DIOMAPPING2                          0x41
// Version
#define REG_LR_VERSION                              0x42
// Additional settings
#define REG_LR_PLLHOP                               0x44
#define REG_LR_TCXO                                 0x4B
#define REG_LR_PADAC                                0x4D
#define REG_LR_FORMERTEMP                           0x5B

#define REG_LR_AGCREF                               0x61
#define REG_LR_AGCTHRESH1                           0x62
#define REG_LR_AGCTHRESH2                           0x63
#define REG_LR_AGCTHRESH3                           0x64

/********************FSK/ook mode***************************/
#define  RegFIFO                   0x00                //FIFO
#define  RegOpMode                  0x01                //????
#define  RegBitRateMsb         0x02                //BR ??
#define  RegBitRateLsb         0x03                //BR ??
#define  RegFdevMsb                 0x04                //FD ??
#define  RegFdevLsb                 0x05                 //FD ??
#define  RegFreqMsb                 0x06                //Freq ??
#define  RegFreqMid                 0x07                 //Freq ??
#define  RegFreqLsb           0x08                //Freq ??
#define     RegPaConfig            0x09
#define  RegPaRamp                0x0a
#define  RegOcp                        0x0b
#define  RegLna                        0x0c
#define  RegRxConfig            0x0d
#define  RegRssiConfig        0x0e
#define  RegRssiCollision 0x0f
#define  RegRssiThresh        0x10
#define  RegRssiValue            0x11
#define  RegRxBw                    0x12
#define  RegAfcBw                    0x13
#define  RegOokPeak                0x14
#define  RegOokFix                0x15
#define  RegOokAvg                0x16

#define  RegAfcFei                0x1a    
#define  RegAfcMsb                0x1b
#define  RegAfcLsb                0x1c
#define  RegFeiMsb                0x1d
#define  RegFeiLsb                0x1e
#define  RegPreambleDetect    0x1f
#define  RegRxTimeout1        0x20
#define  RegRxTimeout2        0x21
#define  RegRxTimeout3        0x22
#define  RegRxDelay                0x23
#define  RegOsc                       0x24                //OSC??
#define  RegPreambleMsb        0x25
#define  RegPreambleLsb        0x26
#define  RegSyncConfig        0x27
#define  RegSyncValue1        0x28
#define  RegSyncValue2        0x29
#define  RegSyncValue3        0x2a
#define  RegSyncValue4        0x2b
#define  RegSyncValue5        0x2c
#define  RegSyncValue6        0x2d
#define  RegSyncValue7        0x2e
#define  RegSyncValue8        0x2f
#define  RegPacketConfig1        0x30
#define  RegPacketConfig2        0x31
#define  RegPayloadLength        0x32
#define  RegNodeAdrs            0x33
#define  RegBroadcastAdrs        0x34
#define  RegFifoThresh        0x35
#define  RegSeqConfig1        0x36
#define  RegSeqConfig2        0x37
#define  RegTimerResol        0x38
#define  RegTimer1Coef        0x39
#define  RegTimer2Coef        0x3a
#define  RegImageCal            0x3b
#define  RegTemp                    0x3c
#define  RegLowBat                0x3d
#define  RegIrqFlags1            0x3e
#define  RegIrqFlags2            0x3f
#define  RegDioMapping1        0x40
#define  RegDioMapping2        0x41
#define  RegVersion                0x42

#define     RegPllHop                0x44
#define  RegPaDac                    0x4d
#define     RegBitRateFrac        0x5d 

u8 SPIRead(u8 adr);
void sx1276_7_8_Standby(void);
void sx1276_7_8_Sleep(void);
void sx1276_7_8_EntryLoRa(void);
void sx1276_7_8_LoRaClearIrq(void);
void sx1276_7_8_Config(u8 mode);
u8 sx1276_7_8_LoRaEntryRx(void);
u8 sx1276_7_8_LoRaReadRSSI(void);
bit sx1276_7_8_LoRaRxPacket(void);
u8 sx1276_7_8_LoRaEntryTx(void);
u8 sx1276_7_8_LoRaTxPacket(void);
u8 sx1276_7_8_ReadRSSI(void);
void sx1276_7_8_FskClearFIFO(void);
u8 sx1276_7_8_FskEntryRx(void);
u8 sx1276_7_8_FskRxPacket(void);
u8 sx1276_7_8_FskEntryTx(void);
u8 sx1276_7_8_FskTxPacket(void);
void sx1276_7_8_TestConfig(void);

extern void delay_2us(U16 delay_cnt);

#endif