电池标签L051工程
blame | 历史 | 补丁 | 提交 | 提交对比 | 忽略空白
yincheng.zhong
2024-03-08 d67d922c6345042cb3dfaedd621a2120fe808b70 
 Src/radio/Lora.c


@@ -10,63 +10,37 @@


#include "stdio.h"


#include "delay.h"


#include "main.h"


#include <stdlib.h>


#include "dw_mbx_tag.h"


static RadioEvents_t RadioEvents;


#define USE_MODEM_LORA


//#define USE_MODEM_FSK


#define REGION_CN779


#define REGION_CN779 


void Lora47xrx_Init(void);


void Lora433_change(void);


void Lora433rx_Init(void);


void SwitchLoraSettings(uint32_t freq,uint8_t sf,uint8_t power);


uint32_t RxDutyCycle_RX_time   =128;


uint32_t RxDutyCycle_SLEEP_time=256;


#if defined( REGION_AS923 )




#define RF_FREQUENCY                                923000000 // Hz




#elif defined( REGION_AU915 )




#define RF_FREQUENCY                                915000000 // Hz




#elif defined( REGION_CN779 )


#define LORA_FREQUENCY0 470200000


#define LORA_FREQUENCY1 471200000


#define LORA_FREQUENCY2 472200000


#define LORA_FREQUENCY3 473200000


#define LORA_FREQUENCY4 474200000


uint16_t Lora_rece_error;


#define LORA_RX_433 1


#define LORA_TX_47X 2


#define LORA_RX_47X 3


uint8_t Lora_status=0;




#define RF_FREQUENCY                              433000000 // Hz


#define RF_FREQUENCY_R                              500000000 // Hz


#define RF_FREQUENCY_T                              470200000 // Hz






#elif defined( REGION_EU868 )




#define RF_FREQUENCY                                868000000 // Hz




#elif defined( REGION_KR920 )




#define RF_FREQUENCY                                920000000 // Hz




#elif defined( REGION_IN865 )




#define RF_FREQUENCY                                865000000 // Hz




#elif defined( REGION_US915 )




#define RF_FREQUENCY                                915000000 // Hz




#elif defined( REGION_US915_HYBRID )




#define RF_FREQUENCY                                915000000 // Hz




#else




    #error "Please define a frequency band in the compiler 'options."




#endif




#define TX_OUTPUT_POWER                             22        // 22 dBm




extern bool IrqFired;










//bool EnableMaster=true;//主选择


bool EnableMaster=false;//从选择




extern uint8_t lora_yingda_flag;


uint16_t lora_yingda_num;


uint16_t  crc_value;


/*!


 * Radio events function pointer


@@ -85,8 +59,8 @@


                                                              //  2: 4/6,


                                                              //  3: 4/7,


                                                              //  4: 4/8]


#define LORA_PREAMBLE_LENGTH_T                      10         // Same for Tx 


#define LORA_PREAMBLE_LENGTH_R                      64        // Same for Rx


#define LORA_PREAMBLE_LENGTH_T                      8         // Same for Tx 


#define LORA_PREAMBLE_LENGTH_R                      8        // Same for Rx


//#define LORA_PREAMBLE_LENGTH                      990         // Same for Tx and Rx


#define LORA_SYMBOL_TIMEOUT                         0         // Symbols


#define LORA_FIX_LENGTH_PAYLOAD_ON                  false


@@ -118,11 +92,8 @@


}States_t;




//#define RX_TIMEOUT_VALUE                            1000


#define RX_TIMEOUT_VALUE                            64000


#define BUFFER_SIZE                                 64 // Define the payload size here




const uint8_t PingMsg[] = "PING";


const uint8_t PongMsg[] = "PONG";


#define RX_TIMEOUT_VALUE                            0


#define BUFFER_SIZE                                 255 // Define the payload size here




uint16_t BufferSize = BUFFER_SIZE;


uint8_t TX_Buffer[BUFFER_SIZE];


@@ -138,110 +109,182 @@


void OnTxTimeout( void );


void OnRxTimeout( void );


void OnRxError( void );




uint8_t  lora_chongfuyingda_flag;


uint8_t Lora_rx_open_flag;


void LedToggle(void)


extern u32 Loratx_frequency;




{


//   HAL_GPIO_TogglePin(GPIOB, LED1_Pin);


}




void Lora_rx_open( void )


{


    if(Lora_rx_open_flag==1)


    {


    Lora_Init();


    Lora_rx_open_flag=0;


    }


}


uint8_t flag_writepara_needreset = 0;


uint32_t wg_lost_count = 10;


uint32_t lora_zhuangtai;


uint16_t current_count;


extern wg_state_enum wg_state;


void OnTxDone( void )


{   


Lora_rx_open_flag=1;


{  


    if(flag_writepara_needreset) //配置写入完成设备需要重启


    {


        printf("网关下发配置写入完成，重启");


        SCB->AIRCR = 0X05FA0000|(unsigned int)0x04; //软复位回到bootloader   


    }


    Radio.Standby();


    Radio.Rx( 50 );


    LED_TB_OFF;   


}


extern uint8_t frame_seq_nb2,rec_nearbase_num,ancidlist_num;


uint16_t RX_TIMEOUTs;


extern LPTIM_HandleTypeDef hlptim1;


uint16_t current_time,start_time,end_time;


void OnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr )


uint8_t power_and_key=0;


extern u8 battary,button;


u8 lora_seq_nb2;


extern uint8_t stationary_flag;


extern uint8_t anjian_flag;


extern uint8_t lora_tx_flag;


extern uint16_t wg_report_id,wg_report_freq;


extern uint8_t no_yingdaflag;


uint16_t Beepchixutime;


uint8_t xiafayuyin_data[200];


uint8_t yuyin_sendflag;


uint8_t yuyinzidongguan_time;


uint8_t  yuyin_no_sleep_flag,no_rx_flag;


extern uint8_t usart5_state;


extern uint8_t lora_sendbuffer[200];


void LoraSendComMap(uint8_t cmd)


{


    BufferSize = size;


    memcpy( RX_Buffer, payload, BufferSize );


    RssiValue = rssi;


    SnrValue = snr;


    


    Radio.Standby();


   uint8_t data_length = 0x28;


   uint16_t checksum = 0;


   lora_sendbuffer[MSG_TYPE_IDX] = LORA_MSGTYPE_READPARARESP;


   lora_sendbuffer[MSG_LENGTH] = data_length+9;


    memcpy(&lora_sendbuffer[SOURCE_ID_IDX],&g_com_map[DEV_ID],2);


    memcpy(&lora_sendbuffer[DEST_ID_IDX],&wg_report_id,2);


   lora_sendbuffer[RP_CMD_IDX] = cmd;


   lora_sendbuffer[RP_INDEX_IDX] = 2;


   lora_sendbuffer[RP_LEN_IDX] = data_length;


   memcpy(&lora_sendbuffer[7], &g_com_map[1], data_length);


   checksum = Checksum_u16(lora_sendbuffer,9+data_length);


   memcpy(&lora_sendbuffer[9+data_length],&checksum,2);


    Radio.Send(lora_sendbuffer,data_length+11);


  //  Delay_Ms(100);


}


void LoraRspWriteCommap(uint8_t index)


{


   uint8_t data_length = 2;


   uint16_t checksum = 0;


   lora_sendbuffer[MSG_TYPE_IDX] = LORA_MSGTYPE_READPARARESP;


   lora_sendbuffer[MSG_LENGTH] = data_length+9;


    memcpy(&lora_sendbuffer[SOURCE_ID_IDX],&g_com_map[DEV_ID],2);


    memcpy(&lora_sendbuffer[DEST_ID_IDX],&wg_report_id,2);


   lora_sendbuffer[RP_CMD_IDX] = WGRSP_RWTAG_WRITE;


   lora_sendbuffer[RP_INDEX_IDX] = index;


   lora_sendbuffer[RP_LEN_IDX] = data_length;


   memcpy(&lora_sendbuffer[7], &g_com_map[index/2], data_length);


   checksum = Checksum_u16(lora_sendbuffer,9+data_length);


   memcpy(&lora_sendbuffer[9+data_length],&checksum,2);


    Radio.Send(lora_sendbuffer,data_length+11);


  //  Delay_Ms(100);


}


extern u8 lora_jianting_flag;


static uint16_t delaytime = 1050;


static uint16_t source_id;


uint8_t rec_index;


uint16_t rec_value,rec_delaytime,rx_count;


int32_t target_count;


extern uint16_t motor_keeptime;


void OnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr )


{   


        BufferSize = size;


        memcpy( RX_Buffer, payload, BufferSize );


        RssiValue = rssi;


        SnrValue = snr;


        Radio.Standby();


        no_rx_flag = 0;


    if(RX_Buffer[MSG_TYPE_IDX]==LORA_MSGTYPE_RANGEPOLL)


    {


//        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, GPIO_PIN_SET);


//       Delay_Ms(10);


//        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, GPIO_PIN_RESET);


        uint16_t i=0;


        for(i=0;i<BufferSize;i++)


        {printf("RXD %d:\r\n",RX_Buffer[i]);}


        RX_TIMEOUTs++;


        printf("RX_num :%d\r\n",RX_TIMEOUTs);


//        start_time=HAL_LPTIM_ReadCounter(&hlptim1);


//        end_time=start_time+((32768/1000)*20);


//        if(end_time>=32768)


//       {end_time-=32768;}


//        current_time=HAL_LPTIM_ReadCounter(&hlptim1);


        HAL_GPIO_WritePin(RADIO_NSS_GPIO_Port, RADIO_NSS_Pin, GPIO_PIN_SET); 


//        while(current_time<end_time||current_time>end_time+15000)


//        {


//            current_time=HAL_LPTIM_ReadCounter(&hlptim1);


            Anchor_App();


//        }


            UWB_Wkup();


            MbxTagUwbRec();           


            HAL_GPIO_WritePin(RADIO_NSS_GPIO_Port, RADIO_NSS_Pin, GPIO_PIN_RESET); //片选lora有效


    }


    if(RX_Buffer[MSG_TYPE_IDX]==LORA_MSGTYPE_WGRESPTAG)


    {


        if(!memcmp(&dev_id,&RX_Buffer[DEST_ID_IDX],2))


        {


           memcpy(&source_id,&RX_Buffer[SOURCE_ID_IDX],2); 


            if(wg_state==WG_Lost)


            {


                wg_state = WG_Connected;


                wg_report_id = source_id;


            }


            if(!memcmp(&wg_report_id,&RX_Buffer[SOURCE_ID_IDX],2))


            {


                wg_lost_count = 0;


                switch(RX_Buffer[PWTAG_RW_FLAG_IDX])


                {


                    case WGRSP_RWTAG_NONE:


                        current_count = HAL_LPTIM_ReadCounter(&hlptim1);


                        wg_report_freq = RX_Buffer[POLL_FREQ_IDX]+400;


                        memcpy(&rec_delaytime,&RX_Buffer[NEXTPOLL_TIME_IDX],2);                  


                        target_count = current_count + rec_delaytime*3.2768 - delaytime;


                        while(target_count>=32768)


                            target_count-=32768;


                        __HAL_LPTIM_COMPARE_SET(&hlptim1, target_count);


                        rx_count = HAL_LPTIM_ReadCounter(&hlptim1);


                     //   printf("tx %d,rx %d,delay %d",current_count>>5,rx_count>>5,rec_delaytime);


                        break;


                    case WGRSP_RWTAG_READ:


                        no_rx_flag = 1;


                        LoraSendComMap(WGRSP_RWTAG_READ);


                        break;


                    case WGRSP_RWTAG_WRITE:


                        rec_index = RX_Buffer[PWTAG_WRITE_IDX_IDX];


                    switch(rec_index)


                    {


                        case 0xdd:  //语音下发


                            break;


                        case 0x20:  //蜂鸣


                            memcpy(&rec_value,&RX_Buffer[PWTAG_WRITE_VALUE_IDX],2);


                            motor_keeptime = rec_value;


                            break;


                        default :


                            memcpy(&rec_value,&RX_Buffer[PWTAG_WRITE_VALUE_IDX],2);


                            g_com_map[rec_index/2] = rec_value;


                            save_com_map_to_flash();


                            LoraRspWriteCommap(SUBMSG_WRITE_ANCPARA);


                            flag_writepara_needreset = 1;


                            no_rx_flag = 1;                           


                    }




            HAL_GPIO_WritePin(RADIO_NSS_GPIO_Port, RADIO_NSS_Pin, GPIO_PIN_RESET); 


            delay_ms(10);


            


            Radio.SetChannel( 470200000 );


            Radio.SetTxConfig( MODEM_LORA, TX_OUTPUT_POWER, 0, 0,


            7, LORA_CODINGRATE,LORA_PREAMBLE_LENGTH_T, LORA_FIX_LENGTH_PAYLOAD_ON,


            false, 0, 0, LORA_IQ_INVERSION_ON_T, 3000 );


                                   


            Radio.Send( usart_send, 12+rec_nearbase_num*4);


//              printf("RX_TIMEOUTs :%d\r\n",RX_TIMEOUTs);


//        Radio.SetRxDutyCycle(RxDutyCycle_RX_time,RxDutyCycle_SLEEP_time);


//              printf("RX_TIMEOUTs :XXXX\r\n");


//                 Radio.Rx( RX_TIMEOUT_VALUE ); 


//            printf("Slave TXD XXXX\r\n");




                        break;                                 


                }


            }


        }


    }


    if(!no_rx_flag)


    {


        if(lora_jianting_flag)


        {


            SwitchLoraSettings(UWB_CHANNEL_FRQ+g_com_map[GROUP_ID],UWB_CHANNEL_SF,0);


            Radio.Rx(0);


        }


    }


}




void OnTxTimeout( void )


{


   


    Radio.Standby();


    if(lora_jianting_flag)


    SwitchLoraSettings(UWB_CHANNEL_FRQ+g_com_map[GROUP_ID],UWB_CHANNEL_SF,0);


}




    uint8_t tm;


uint16_t Lora_rece_error;


void OnRxTimeout( void )


{


    Radio.Standby();


    if(EnableMaster)


    current_count = HAL_LPTIM_ReadCounter(&hlptim1);


    target_count-=current_count%3276;


    while(target_count<0)


        target_count+=32768;


    __HAL_LPTIM_COMPARE_SET(&hlptim1, target_count);


    if(lora_jianting_flag)


    {


//        TX_Buffer[0] = 'P';


//        TX_Buffer[1] = 'I';


//        TX_Buffer[2] = 'N';


//        TX_Buffer[3] = 'G'; 


//        


////        crc_value=RadioComputeCRC(TX_Buffer,4,CRC_TYPE_IBM);//计算得出要发送数据包CRC值


////        TX_Buffer[4]=crc_value>>8;


////        TX_Buffer[5]=crc_value;


//        //Radio.Send( TX_Buffer, 6);


//           Radio.Send( TX_Buffer, 4);


			


//           HAL_GPIO_WritePin( OUT1_GPIO_Port, OUT1_Pin,GPIO_PIN_SET);


//           HAL_Delay_nMS( 1 );


//           HAL_GPIO_WritePin( OUT1_GPIO_Port, OUT1_Pin,GPIO_PIN_RESET);	  		


           printf("Master TXD PING!\r\n");


    }


    else


    {


                 Radio.SetRxDutyCycle(RxDutyCycle_RX_time,RxDutyCycle_SLEEP_time);


//        printf("slave OnRxTimeout\r\n");	


        


//                 Radio.Rx( RX_TIMEOUT_VALUE ); 


        printf("slave OnRxTimeout\r\n");	


        SwitchLoraSettings(UWB_CHANNEL_FRQ+g_com_map[GROUP_ID],UWB_CHANNEL_SF,0);


        Radio.Rx(0);


    }


}




@@ -249,146 +292,53 @@


{




    Radio.Standby();


    if(EnableMaster)


    {


        TX_Buffer[0] = 'P';


        TX_Buffer[1] = 'I';


        TX_Buffer[2] = 'N';


        TX_Buffer[3] = 'G'; 


        


//        crc_value=RadioComputeCRC(TX_Buffer,4,CRC_TYPE_IBM);//计算得出要发送数据包CRC值


//        TX_Buffer[4]=crc_value>>8;


//        TX_Buffer[5]=crc_value;


        //Radio.Send( TX_Buffer, 6);


           Radio.Send( TX_Buffer, 4);


//           HAL_GPIO_WritePin( OUT1_GPIO_Port, OUT1_Pin,GPIO_PIN_SET);


//           HAL_Delay_nMS( 1 );


//           HAL_GPIO_WritePin( OUT1_GPIO_Port, OUT1_Pin,GPIO_PIN_RESET);	  		


           printf("Master TXD PING!\r\n");


    }


    else


    {


      Radio.SetRxDutyCycle(RxDutyCycle_RX_time,RxDutyCycle_SLEEP_time);


        printf("slave OnRxError\r\n");	


//                 Radio.Rx( RX_TIMEOUT_VALUE ); 




    }


  


    if(lora_jianting_flag)


    SwitchLoraSettings(UWB_CHANNEL_FRQ+g_com_map[GROUP_ID],UWB_CHANNEL_SF,0);


}








//void T_R_Init(uint8_t kind)


//{


uint16_t freq_test;


void SwitchLoraSettings(uint32_t freq,uint8_t sf,uint8_t power)


{


    


//    RadioEvents.TxDone = OnTxDone;


//    RadioEvents.RxDone = OnRxDone;


//    RadioEvents.TxTimeout = OnTxTimeout;


//    RadioEvents.RxTimeout = OnRxTimeout;


//    RadioEvents.RxError = OnRxError;


    //HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_SET);


//    Radio.Init( &RadioEvents );


//   if(kind==1) //1:Txd config


//      {


//         Radio.SetChannel( RF_FREQUENCY );


//         Radio.SetTxConfig( MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,


//                                   LORA_SPREADING_FACTOR, LORA_CODINGRATE,


//                                   LORA_PREAMBLE_LENGTH_T, LORA_FIX_LENGTH_PAYLOAD_ON,


//                                   false, 0, 0, LORA_IQ_INVERSION_ON_T, 1000 );


    Radio.Standby();


  //  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_RESET);


    Radio.SetChannel( freq*1000000 );	


    freq_test = freq;


    Radio.SetTxConfig( MODEM_LORA, power, 0, 2,


    sf, LORA_CODINGRATE,LORA_PREAMBLE_LENGTH_T, LORA_FIX_LENGTH_PAYLOAD_ON,


    false, 0, 0, LORA_IQ_INVERSION_ON_T, 3000 );




//      }


//      else       //0:Rxd config


//    {


//         Radio.SetChannel( RF_FREQUENCY );		


//        Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,


//                                   LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH_R,


//                                   LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,


//                                   0, false, 0, 0, LORA_IQ_INVERSION_ON_R, false );


//      }


//		


////      Radio.SetTxConfig( MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,


////                                   LORA_SPREADING_FACTOR, LORA_CODINGRATE,


////                                   LORA_PREAMBLE_LENGTH_T, LORA_FIX_LENGTH_PAYLOAD_ON,


////                                   false, 0, 0, LORA_IQ_INVERSION_ON_T, 1000 );


    Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, 


    sf,LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH_R,


    LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,


    0, false, 0, 0, LORA_IQ_INVERSION_ON_R, 0 );




////      Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,


////                                   LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH_R,


////                                   LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,


////                                   0, false, 0, 0, LORA_IQ_INVERSION_ON_R, false );


//}




void Lora_Init(void)


    


}


extern u8 active_flag;


void LoraInit(void)


{


    RadioEvents.TxDone = OnTxDone;


    RadioEvents.RxDone = OnRxDone;


    RadioEvents.TxTimeout = OnTxTimeout;


    RadioEvents.RxTimeout = OnRxTimeout;


    RadioEvents.RxError = OnRxError;


    


        Radio.Init( &RadioEvents );


      if(EnableMaster)


      {


       Radio.SetChannel( RF_FREQUENCY );


      }


      else


        {


        Radio.SetChannel( RF_FREQUENCY );		


        }


//        Radio.SetStandby( STDBY_RC );


    


//    Radio.SetTxConfig( MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,


//                                   LORA_SPREADING_FACTOR, LORA_CODINGRATE,


//                                   LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,


//                                   true, 0, 0, LORA_IQ_INVERSION_ON, 3000 );


																	 


//      Radio.SetTxConfig( MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,


//                                   LORA_SPREADING_FACTOR, LORA_CODINGRATE,


//                                   LORA_PREAMBLE_LENGTH_T, LORA_FIX_LENGTH_PAYLOAD_ON,


//                                   false, 0, 0, LORA_IQ_INVERSION_ON_T, 1000 );


    


//    Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,


//                                   LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,


//                                   LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,


//                                   0, true, 0, 0, LORA_IQ_INVERSION_ON, false );


																	 


      Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,


                                   LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH_R,


                                   LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,


                                   0, false, 0, 0, LORA_IQ_INVERSION_ON_R, 1 );


//      Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,


//                                   LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,


//                                   LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,


//                                   0, false, 0, 0, LORA_IQ_INVERSION_ON, true );


    


    if(EnableMaster)




    Radio.Init( &RadioEvents );


    SwitchLoraSettings(UWB_CHANNEL_FRQ+g_com_map[GROUP_ID],5,0); //切换lora接收频点  


    if(active_flag)


    {


			


             printf("I am Master!\r\n");


			


          TX_Buffer[0] = 'P';


          TX_Buffer[1] = 'I';


          TX_Buffer[2] = 'N';


          TX_Buffer[3] = 'G'; 


          


          crc_value=RadioComputeCRC(TX_Buffer,4,CRC_TYPE_IBM);//计算得出要发送数据包CRC值


          TX_Buffer[4]=crc_value>>8;


          TX_Buffer[5]=crc_value;


          //Radio.Send( TX_Buffer, 6);


             Radio.Send( TX_Buffer, 4);


			


//               HAL_GPIO_WritePin( OUT1_GPIO_Port, OUT1_Pin,GPIO_PIN_SET);


//             HAL_Delay_nMS( 1 );


//             HAL_GPIO_WritePin( OUT1_GPIO_Port, OUT1_Pin,GPIO_PIN_RESET);	  


			


             printf("Master TXD PING!\r\n");


    }


    else


    {


       SX126xClearIrqStatus( IRQ_RADIO_ALL );


//        SX126xSetDioIrqParams( IRQ_RX_DONE | IRQ_CRC_ERROR,


// IRQ_RX_DONE | IRQ_CRC_ERROR,


// IRQ_RADIO_NONE, IRQ_RADIO_NONE


// );


//            SX126xSetDioIrqParams( IRQ_RADIO_ALL, //IRQ_RX_DONE | IRQ_RX_TX_TIMEOUT,


//       IRQ_RADIO_ALL, //IRQ_RX_DONE | IRQ_RX_TX_TIMEOUT,


//       IRQ_RADIO_NONE,


//       IRQ_RADIO_NONE );


       Radio.SetRxDutyCycle(RxDutyCycle_RX_time,RxDutyCycle_SLEEP_time);


//        Radio.Rx( RX_TIMEOUT_VALUE ); 


//       printf("I am Slave!\r\n");        


    }


       


    Radio.Rx( 0 ); 


    }else{


        Radio.Sleep();


    }        


//        Radio.SetRxDutyCycle(RxDutyCycle_RX_time,RxDutyCycle_SLEEP_time);


                                   


}