易智联LM401模块学习（三）——PINGPANG例程

PINGPANG例程（一）

---

前言

---

一、“ping”“pang”实现了什么？

Ping-Pong例程是两块LM401-DEMO板之间的一个简单Lora收发例程。

默认情况下，LM401-DEMO评估板作为主设备，发送一个“Ping”消息然后等待回复。第一个收到“Ping”信息的设备将变为从设备，并以“Pong”信息回复主设备。当主设备收到“Pong”信息之后继续发送“Ping”信息。这样就建立了一个持续的Ping-Pong收发过程。
正常情况下两个评估板建立Ping-Pong收发关系，只有一个LED闪烁。接收到Ping消息时，LED1闪烁，接收到Pong消息时，LED2闪烁。当两个板完全同步时，即两个主板的RX窗口同步(TX窗口也是)时，无法建立Ping-Pong收发关系（两个LED长时间同时闪烁）。这时只需要重新启动其中的一块板即可（复位键即可）。

二、核心代码分析

1.Subghz_phy_app.h

代码如下（示例）：

#define USE_MODEM_LORA  1      //调制方式宏定义
#define USE_MODEM_FSK   0

#define REGION_CN470   /*声明通信频率段*/ 

#if defined( REGION_AS923 )	 /*不同信道频率段划分*/ 

#define RF_FREQUENCY                                923000000 /* Hz */
#elif defined( REGION_AU915 )

#define RF_FREQUENCY                                915000000 /* Hz */

#elif defined( REGION_CN470 )

//#define RF_FREQUENCY                                470000000 /* Hz */
#define RF_FREQUENCY                                490000000 /* Hz */

#elif defined( REGION_CN779 )

#define RF_FREQUENCY                                779000000 /* Hz */

#elif defined( REGION_EU433 )

#define RF_FREQUENCY                                433000000 /* 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_RU864 )

#define RF_FREQUENCY                                864000000 /* Hz */

#else
#error "Please define a frequency band in the compiler options."
#endif /* REGION_XXxxx */

#define TX_OUTPUT_POWER                             22    //14        /* dBm */   //发射功率
/*lora调制解调方式设置对应的属性，包含带宽，扩频因子，编码率，数据长度*/ 
#if (( USE_MODEM_LORA == 1 ) && ( USE_MODEM_FSK == 0 ))   /*普通模式lora模式*/ 
#define LORA_BANDWIDTH  /*频带宽度*/                            0         /* [0: 125 kHz, 1: 250 kHz, 2: 500 kHz, 3: Reserved] */
#define LORA_SPREADING_FACTOR    /*扩频因子*/                   10         /* [SF7..SF12] */
#define LORA_CODINGRATE      /*编码率*/                    1         /* [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8] */
#define LORA_PREAMBLE_LENGTH     /*前导码*/                  8         /* Same for Tx and Rx */
#define LORA_SYMBOL_TIMEOUT                         5         /* Symbols */
#define LORA_FIX_LENGTH_PAYLOAD_ON                  false
#define LORA_IQ_INVERSION_ON                        false

#elif (( USE_MODEM_LORA == 0 ) && ( USE_MODEM_FSK == 1 ))  /*FSK模式属性*/

#define FSK_FDEV                                    25000     /* Hz */
#define FSK_DATARATE                                50000     /* bps */
#define FSK_BANDWIDTH                               50000     /* Hz */
#define FSK_PREAMBLE_LENGTH                         5         /* Same for Tx and Rx */
#define FSK_FIX_LENGTH_PAYLOAD_ON                   false

#else
#error "Please define a modem in the compiler subghz_phy_app.h."
#endif /* USE_MODEM_LORA | USE_MODEM_FSK */

#define PAYLOAD_LEN                                 32   /*有效数据长度*/

/* USER CODE BEGIN EC */

/* USER CODE END EC */

/* External variables --------------------------------------------------------*/
/* USER CODE BEGIN EV */

/* USER CODE END EV */

/* Exported macros -----------------------------------------------------------*/
/* USER CODE BEGIN EM */

/* USER CODE END EM */

/* Exported functions prototypes ---------------------------------------------*/
/**
  * @brief  Init Subghz Application
  */
void SubghzApp_Init(void);   /*lora模块初始化*/

2.Subghz_phy_app.c

代码如下（示例）：

typedef enum  /*设置系统状态结构体*/
{
  RX,
  RX_TIMEOUT,
  RX_ERROR,
  TX,
  TX_TIMEOUT,
} States_t;
/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* Configurations */
/*Timeout（超时）*/
#define RX_TIMEOUT_VALUE              3000
#define TX_TIMEOUT_VALUE              3000
/* PING string，定义发送字符串*/
#define PING "PING"
/* PONG string*/
#define PONG "PONG"
/*Size of the payload to be sent*/
/* Size must be greater of equal the PING and PONG*/
#define MAX_APP_BUFFER_SIZE          255   /*最大数据长度*/
#if (PAYLOAD_LEN > MAX_APP_BUFFER_SIZE)    //判断缓存区大小和用户有效数据大小
#error PAYLOAD_LEN must be less or equal than MAX_APP_BUFFER_SIZE
#endif /* (PAYLOAD_LEN > MAX_APP_BUFFER_SIZE) */
/* wait for remote to be in Rx, before sending a Tx frame*/
#define RX_TIME_MARGIN                200    	//发送等待时间
/* Afc bandwidth in Hz */
#define FSK_AFC_BANDWIDTH             83333		//AFC带宽
/* LED blink Period*/
#define LED_PERIOD_MS                 200     //定义LED反转时间
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
/* Radio events function pointer */
static RadioEvents_t RadioEvents;
/* USER CODE BEGIN PV */
//uint8_t:一个字节表示；uint16_t:2字节表示；uint32_t：四字节表示
/*Ping Pong FSM states */
static States_t State = RX;
/* App Rx Buffer*/
static uint8_t BufferRx[MAX_APP_BUFFER_SIZE];//接收缓存区
/* App Tx Buffer*/
static uint8_t BufferTx[MAX_APP_BUFFER_SIZE];//发送缓存区
/* Last  Received Buffer Size*/
uint16_t RxBufferSize = 0;
/* Last  Received packer Rssi*/
int8_t RssiValue = 0;
/* Last  Received packer SNR (in Lora modulation)*/
int8_t SnrValue = 0;
/* Led Timers objects*/
static UTIL_TIMER_Object_t timerLed;
/* device state. Master: true, Slave: false*/
bool isMaster = true;
/* random delay to make sure 2 devices will sync*/
/* the closest the random delays are, the longer it will
   take for the devices to sync when started simultaneously*/
static int32_t random_delay;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
/*!
 * @brief Function to be executed on Radio Tx Done event
 */
static void OnTxDone(void);

/**
  * @brief Function to be executed on Radio Rx Done event
  * @param  payload ptr of buffer received
  * @param  size buffer size
  * @param  rssi
  * @param  LoraSnr_FskCfo
  */
static void OnRxDone(uint8_t *payload, uint16_t size, int16_t rssi, int8_t LoraSnr_FskCfo);

/**
  * @brief Function executed on Radio Tx Timeout event
  */
static void OnTxTimeout(void);

/**
  * @brief Function executed on Radio Rx Timeout event
  */
static void OnRxTimeout(void);

/**
  * @brief Function executed on Radio Rx Error event
  */
static void OnRxError(void);

/* USER CODE BEGIN PFP */
/**
  * @brief  Function executed on when led timer elapses
  * @param  context ptr of LED context
  */
static void OnledEvent(void *context);

/**
  * @brief PingPong state machine implementation
  */
static void PingPong_Process(void);
/* USER CODE END PFP */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)  /*按键IO中断回调函数*/
{
  switch (GPIO_Pin)
  {
    case  BUTTON_SW1_PIN:
        BSP_LED_Toggle(LED_BLUE) ;
        HAL_Delay(20);
        BSP_LED_Toggle(LED_BLUE) ;
		APP_PRINTF("BUTTON SW1\r\n");//打印日志
         
      break;
   
    default:
        APP_PRINTF("Unkonw Button\r\n");
      break;
  }
}
/* Exported functions ---------------------------------------------------------*/
void SubghzApp_Init(void)
{
  /* USER CODE BEGIN SubghzApp_Init_1 */

  APP_LOG(TS_OFF, VLEVEL_M, "\n\rPING PONG\n\r");
  /* Get SubGHY_Phy APP version*/
  APP_LOG(TS_OFF, VLEVEL_M, "APPLICATION_VERSION: V%X.%X.%X\r\n",
          (uint8_t)(APP_VERSION_MAIN),
          (uint8_t)(APP_VERSION_SUB1),
          (uint8_t)(APP_VERSION_SUB2));

  /* Get MW SubGhz_Phy info */
  APP_LOG(TS_OFF, VLEVEL_M, "MW_RADIO_VERSION:    V%X.%X.%X\r\n",
          (uint8_t)(SUBGHZ_PHY_VERSION_MAIN),
          (uint8_t)(SUBGHZ_PHY_VERSION_SUB1),
          (uint8_t)(SUBGHZ_PHY_VERSION_SUB2));

  /* Led Timers*/  //使用一个外设时，都要使能其定时器，定时器创建，定时开始
	//1、led定时器结构体，2、led寿命周期3、定时器模式4、定时器溢出回调
  UTIL_TIMER_Create(&timerLed, LED_PERIOD_MS, UTIL_TIMER_ONESHOT, OnledEvent, NULL);
  UTIL_TIMER_Start(&timerLed);
  /* USER CODE END SubghzApp_Init_1 */

  /* Radio initialization *///射频初始化
  RadioEvents.TxDone = OnTxDone;//发送完成
  RadioEvents.RxDone = OnRxDone;//接收完成
  RadioEvents.TxTimeout = OnTxTimeout;//发送超时
  RadioEvents.RxTimeout = OnRxTimeout;//接收超时
  RadioEvents.RxError = OnRxError;//接收错误

  Radio.Init(&RadioEvents);

  /* USER CODE BEGIN SubghzApp_Init_2 */
  /*calculate random delay for synchronization*///计算随机延迟
  random_delay = (Radio.Random()) >> 22; /*10bits random e.g. from 0 to 1023 ms*/

  /* Radio Set frequency */
  Radio.SetChannel(RF_FREQUENCY);   //设置通信频率

/* Radio configuration */ //设置模式为lora模式，并设置发送参数和接收参数
#if ((USE_MODEM_LORA == 1) && (USE_MODEM_FSK == 0))
  APP_LOG(TS_OFF, VLEVEL_M, "---------------\n\r");
  APP_LOG(TS_OFF, VLEVEL_M, "LORA_MODULATION\n\r");
  APP_LOG(TS_OFF, VLEVEL_M, "LORA_BW=%d kHz\n\r", (1 << LORA_BANDWIDTH) * 125);
  APP_LOG(TS_OFF, VLEVEL_M, "LORA_SF=%d\n\r", LORA_SPREADING_FACTOR);

  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, TX_TIMEOUT_VALUE);

  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, true);

  Radio.SetMaxPayloadLength(MODEM_LORA, MAX_APP_BUFFER_SIZE);   

#elif ((USE_MODEM_LORA == 0) && (USE_MODEM_FSK == 1))
  APP_LOG(TS_OFF, VLEVEL_M, "---------------\n\r");
  APP_LOG(TS_OFF, VLEVEL_M, "FSK_MODULATION\n\r");
  APP_LOG(TS_OFF, VLEVEL_M, "FSK_BW=%d Hz\n\r", FSK_BANDWIDTH);
  APP_LOG(TS_OFF, VLEVEL_M, "FSK_DR=%d bits/s\n\r", FSK_DATARATE);

  Radio.SetTxConfig(MODEM_FSK, TX_OUTPUT_POWER, FSK_FDEV, 0,
                    FSK_DATARATE, 0,
                    FSK_PREAMBLE_LENGTH, FSK_FIX_LENGTH_PAYLOAD_ON,
                    true, 0, 0, 0, TX_TIMEOUT_VALUE);

  Radio.SetRxConfig(MODEM_FSK, FSK_BANDWIDTH, FSK_DATARATE,
                    0, FSK_AFC_BANDWIDTH, FSK_PREAMBLE_LENGTH,
                    0, FSK_FIX_LENGTH_PAYLOAD_ON, 0, true,
                    0, 0, false, true);

  Radio.SetMaxPayloadLength(MODEM_FSK, MAX_APP_BUFFER_SIZE);

#else
#error "Please define a modulation in the subghz_phy_app.h file."
#endif /* USE_MODEM_LORA | USE_MODEM_FSK */
   /* LED initialization*///led和案件初始化
  BSP_LED_Init(LED_GREEN);
  BSP_LED_Init(LED_RED);
  BSP_LED_Init(LED_BLUE);
  BSP_PB_Init(BUTTON_SW1, BUTTON_MODE_EXTI);
  /*fills tx buffer*/
  memset(BufferTx, 0x0, MAX_APP_BUFFER_SIZE);//清空接收数组

  APP_LOG(TS_ON, VLEVEL_L, "rand=%d\n\r", random_delay);//打印随机延迟
  /*starts reception*/
  Radio.Rx(RX_TIMEOUT_VALUE + random_delay);  //设置lora为接收等待模式

  /*register task to to be run in while(1) after Radio IT*///注册任务
  UTIL_SEQ_RegTask((1 << CFG_SEQ_Task_SubGHz_Phy_App_Process), UTIL_SEQ_RFU, PingPong_Process);
  /* USER CODE END SubghzApp_Init_2 */
}

/* USER CODE BEGIN EF */

/* USER CODE END EF */

/* Private functions ---------------------------------------------------------*/
static void OnTxDone(void)   
{
  /* USER CODE BEGIN OnTxDone */
  APP_LOG(TS_ON, VLEVEL_L, "OnTxDone\n\r");
  /* Update the State of the FSM*/
  State = TX;
  /* Run PingPong process in background*/
  UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_SubGHz_Phy_App_Process), CFG_SEQ_Prio_0);
  /* USER CODE END OnTxDone */
}

static void OnRxDone(uint8_t *payload, uint16_t size, int16_t rssi, int8_t LoraSnr_FskCfo)
{
  /* USER CODE BEGIN OnRxDone */
  APP_LOG(TS_ON, VLEVEL_L, "OnRxDone\n\r");   
#if ((USE_MODEM_LORA == 1) && (USE_MODEM_FSK == 0))//打印信号强度和信噪比
  APP_LOG(TS_ON, VLEVEL_L, "RssiValue=%d dBm, SnrValue=%ddB\n\r", rssi, LoraSnr_FskCfo);
  /* Record payload Signal to noise ratio in Lora*/
  SnrValue = LoraSnr_FskCfo;   //记录有效荷载的信噪比
#endif /* USE_MODEM_LORA | USE_MODEM_FSK */
#if ((USE_MODEM_LORA == 0) && (USE_MODEM_FSK == 1))
  APP_LOG(TS_ON, VLEVEL_L, "RssiValue=%d dBm, Cfo=%dkHz\n\r", rssi, LoraSnr_FskCfo);
  SnrValue = 0; /*not applicable in GFSK*/
#endif /* USE_MODEM_LORA | USE_MODEM_FSK */
  /* Update the State of the FSM*/
  State = RX; //设置状态为接收状态
  /* Clear BufferRx*/
  memset(BufferRx, 0, MAX_APP_BUFFER_SIZE); //清空接收缓存区
  /* Record payload size*/
  RxBufferSize = size;   //保存接收内容的长度
  if (RxBufferSize <= MAX_APP_BUFFER_SIZE)//判断接收的数据长度是否小于接收缓存区
  {
    memcpy(BufferRx, payload, RxBufferSize);//将有效数据保存在接收缓存区中
  }
  /* Record Received Signal Strength*/
  RssiValue = rssi;  //记录信号接收强度
  /* Record payload content*/
  APP_LOG(TS_ON, VLEVEL_H, "payload. size=%d \n\r", size);  //打印有效数据长度
  for (int i = 0; i < PAYLOAD_LEN; i++)
  {
    APP_LOG(TS_OFF, VLEVEL_H, "%02X", BufferRx[i]);  //打印接收缓存内容
    if (i % 16 == 15)
    {
      APP_LOG(TS_OFF, VLEVEL_H, "\n\r");
    }
  }
  APP_LOG(TS_OFF, VLEVEL_H, "\n\r");
  /* Run PingPong process in background*/  //任务注册
  UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_SubGHz_Phy_App_Process), CFG_SEQ_Prio_0);
  /* USER CODE END OnRxDone */
}

static void OnTxTimeout(void)
{
  /* USER CODE BEGIN OnTxTimeout */
  APP_LOG(TS_ON, VLEVEL_L, "OnTxTimeout\n\r");
  /* Update the State of the FSM*/
  State = TX_TIMEOUT;
  /* Run PingPong process in background*/
  UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_SubGHz_Phy_App_Process), CFG_SEQ_Prio_0);
  /* USER CODE END OnTxTimeout */
}

static void OnRxTimeout(void)
{
  /* USER CODE BEGIN OnRxTimeout */
  APP_LOG(TS_ON, VLEVEL_L, "OnRxTimeout\n\r");
  /* Update the State of the FSM*/
  State = RX_TIMEOUT;
  /* Run PingPong process in background*/
  UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_SubGHz_Phy_App_Process), CFG_SEQ_Prio_0);
  /* USER CODE END OnRxTimeout */
}

static void OnRxError(void)
{
  /* USER CODE BEGIN OnRxError */
  APP_LOG(TS_ON, VLEVEL_L, "OnRxError\n\r");
  /* Update the State of the FSM*/
  State = RX_ERROR;
  /* Run PingPong process in background*/
  UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_SubGHz_Phy_App_Process), CFG_SEQ_Prio_0);
  /* USER CODE END OnRxError */
}

/* USER CODE BEGIN PrFD */
static void PingPong_Process(void)    //进程处理函数
{
  Radio.Sleep();   //睡眠模式

  switch (State)
  {
    case RX://如果接收完成

		if (isMaster == true)  //如果设备是一开始我们规定的主设备端
      {
        if (RxBufferSize > 0)//缓存区中有数据
        {
          if (strncmp((const char *)BufferRx, PONG, sizeof(PONG) - 1) == 0)//这个数据是不是PONG
          {
            UTIL_TIMER_Stop(&timerLed);  //停止并删除定时器
            /* switch off green led */
            HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin, GPIO_PIN_RESET); /* LED_GREEN */
						//LED2拉低，及关闭PONG灯
            /* master toggles red led */
            HAL_GPIO_TogglePin(LED3_GPIO_Port, LED3_Pin); /* LED_RED *///led3翻转，打开PING灯
            /* Add delay between RX and TX */
            HAL_Delay(Radio.GetWakeupTime() + RX_TIME_MARGIN);   //延时一段时间
            /* master sends PING*/
            APP_LOG(TS_ON, VLEVEL_L, "..."//打印PING，表示接收到PONG了
                    "PING"
                    "\n\r");
            APP_LOG(TS_ON, VLEVEL_L, "Master Tx start\n\r");  //打印开始发送
            memcpy(BufferTx, PING, sizeof(PING) - 1);//将PING写到发送缓存区中
            Radio.Send(BufferTx, PAYLOAD_LEN); //发送PING
          }
          else if (strncmp((const char *)BufferRx, PING, sizeof(PING) - 1) == 0)   
						//接收到的数据是PING,但还是主端
          {
            /* A master already exists then become a slave */
            isMaster = false;  //将主从转换变为从端
            APP_LOG(TS_ON, VLEVEL_L, "Slave Rx start\n\r");//打印准备好接受了
            Radio.Rx(RX_TIMEOUT_VALUE);//将lora设置为接收模式
          }
          else /* valid reception but neither a PING or a PONG message */
						//接受的数据既不是PING也不是PONG
          {
            /* Set device as master and start again */
            isMaster = true;//将设备设为主端
            APP_LOG(TS_ON, VLEVEL_L, "Master Rx start\n\r");//打印接收开始
            Radio.Rx(RX_TIMEOUT_VALUE);//将lora模式设置为接收模式
          }
        }
      }
      else//如果设备一开始是我们规定的从端设备
      {
        if (RxBufferSize > 0)//有数据
        {
          if (strncmp((const char *)BufferRx, PING, sizeof(PING) - 1) == 0)
						//这个数据是PING
          {
            UTIL_TIMER_Stop(&timerLed);//关闭定时器
            /* switch off red led */
						//led3灭及PING灯灭，换成led2亮，PONG灯亮
            HAL_GPIO_WritePin(LED3_GPIO_Port, LED3_Pin, GPIO_PIN_RESET); /* LED_RED */
            /* slave toggles green led */
            HAL_GPIO_TogglePin(LED2_GPIO_Port, LED2_Pin); /* LED_GREEN */
            /* Add delay between RX and TX */
						//延时一会，在打印
            HAL_Delay(Radio.GetWakeupTime() + RX_TIME_MARGIN);
            /*slave sends PONG*/
            APP_LOG(TS_ON, VLEVEL_L, "..."
                    "PONG"
                    "\n\r");
            APP_LOG(TS_ON, VLEVEL_L, "Slave  Tx start\n\r");
            memcpy(BufferTx, PONG, sizeof(PONG) - 1);//将PONG复制到发送缓存区
            Radio.Send(BufferTx, PAYLOAD_LEN);//发送PONG
          }
          else /* valid reception but not a PING as expected */
						//如果身为从端没接收到PING，则继续等待接收
          {
            /* Set device as master and start again */
            isMaster = true;//将状态改为主端
            APP_LOG(TS_ON, VLEVEL_L, "Master Rx start\n\r");//打印接收准备好了
            Radio.Rx(RX_TIMEOUT_VALUE);//接收等待
          }
        }
      }
      break;
    case TX://如果发送完成
      APP_LOG(TS_ON, VLEVEL_L, "Rx start\n\r");
      Radio.Rx(RX_TIMEOUT_VALUE);//接收模式
      break;
    case RX_TIMEOUT:
    #if  defined (LOW_POWER_DISABLE) && (LOW_POWER_DISABLE == 0)
        //UTIL_TIMER_SetPeriod(&timerLed, LED_PERIOD_MS*20);
        UTIL_TIMER_Stop(&timerLed);
        BSP_LED_Off(LED_RED) ;
        BSP_LED_Off(LED_GREEN) ;
  
        Radio.Sleep();
        break;
    #endif
    case RX_ERROR://如果接收错误
      if (isMaster == true)//如果是主端
      {
        /* Send the next PING frame */
        /* Add delay between RX and TX*/
        /* add random_delay to force sync between boards after some trials*/
        HAL_Delay(Radio.GetWakeupTime() + RX_TIME_MARGIN + random_delay);//
        APP_LOG(TS_ON, VLEVEL_L, "Master Tx start\n\r");
        /* master sends PING*/
        memcpy(BufferTx, PING, sizeof(PING) - 1);
				//准备发送PING
        Radio.Send(BufferTx, PAYLOAD_LEN);
				//发送PING
      }
      else//如果是从端
      {
        APP_LOG(TS_ON, VLEVEL_L, "Slave Rx start\n\r");
        Radio.Rx(RX_TIMEOUT_VALUE);//等待接收
      }
      break;
    case TX_TIMEOUT://如果发送超时了，
      APP_LOG(TS_ON, VLEVEL_L, "Slave Rx start\n\r");
      Radio.Rx(RX_TIMEOUT_VALUE);//等待接收模式
      break;
    default:
      break;
  }
}

static void OnledEvent(void *context)//定时器溢出回调
{
  HAL_GPIO_TogglePin(LED2_GPIO_Port, LED2_Pin); /* LED_GREEN */
  HAL_GPIO_TogglePin(LED3_GPIO_Port, LED3_Pin); /* LED_RED */
  UTIL_TIMER_Start(&timerLed);//更新定时器初值，重新计时
}

/* USER CODE END PrFD */

---