【 STM32WLE5系列#2 stm32wle5ccu6移植pingpong通信】

最新推荐文章于 2024-02-05 20:11:13 发布
最新推荐文章于 2024-02-05 20:11:13 发布
阅读量2.4k 收藏 18
点赞数 5
分类专栏： LoRaWAN 文章标签： stm32 单片机 arm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47159466/article/details/127074131
版权

STM32WLE5系列#2 stm32wle5ccu6移植pingpong通信

第一章 stm32wle5ccu6简介和开发环境搭建
第二章 stm32wle5ccu6移植pingpong通信
第三章 stm32wle5ccu6移植LoRaWAN_End_Node工程
第四章 stm32wle5ccu6移植LoRaWAN_AT_Slave工程
第五章 stm32wle5ccu6的序列器和定时器分析

目录

简介

官方只提供了STM32WL55JC和STM32WL55JC1的相关应用demo，由于封装不通我们并不能直接使用相关程序，需要移植才能使用。本次我们移植pingpong通信demo.
`

一、工程移植

1、打开STM32CubeMX,选择start My projext from MCU开始工程

在这里插入图片描述
2、在MCU/MPU处选择使用STM32WLE5CCU6
在这里插入图片描述3、在File->import project导入pingpong例程，选择导入工程为C"\Users\用户\STM32Cube\Repository\STM32CuBE_FW_WLV1.2.0\Projects\NUCLEO-WL55JC\Applications\SubGHz_Phy\SubGHz_Phy_PingPong\SubGHz_Phy_PingPong.ioc
用户为自己实际的用户名
在这里插入图片描述
导入后会有些报错，是因为原来WL55JC是BGA的封装引脚要多一些，而stm32wle5ccu6没有

4、在Project Manager->Project中设置工程名和存放路径，Toolchain/IDE设置为MDK-ARM;Code Generator设置为Copy all used libraries into the project folder
在这里插入图片描述
在这里插入图片描述
5、时钟输入配置，HSE和LSE都配置为Crystal/Ceramic Resonator
在这里插入图片描述
6、RTC开启Alarm A并且使能中断
在这里插入图片描述
7、SubGHz_Phy设置如下
在这里插入图片描述
在这里插入图片描述
8、时钟树配置，RTC使用LSE

在这里插入图片描述
9、点击GENERATE CODE生成代码，打开keil工程然后编译会报以下错误，是由于我们没有添加BSP包
在这里插入图片描述
10、把下载的软件包C:\Users\用户\STM32Cube\Repository\STM32Cube_FW_WL_V1.2.0\Drivers中的BSP包拷贝到当前工程下。然后在keil中添加文件和其所在目录索引。
在这里插入图片描述11、然后编译工程，0 error 0 waring
在这里插入图片描述

二、应用移植

1、修改BSP中关于射频开关部分的引脚定义，我们使用的亿佰特的E77模块，所以射频开关为PA6和PA7
stm32wlxx_nucleo_radio.h修改为下面这样，我们只使用了RF_SW_CTRL3_PIN、RF_SW_CTRL1_PIN 两个脚，另一个不用管。

#define RF_SW_CTRL3_PIN                          GPIO_PIN_6
#define RF_SW_CTRL3_GPIO_PORT                    GPIOA
#define RF_SW_CTRL3_GPIO_CLK_ENABLE()            __HAL_RCC_GPIOC_CLK_ENABLE()
#define RF_SW_CTRL3_GPIO_CLK_DISABLE()           __HAL_RCC_GPIOC_CLK_DISABLE()

#define RF_SW_CTRL1_PIN                          GPIO_PIN_7
#define RF_SW_CTRL1_GPIO_PORT                    GPIOA
#define RF_SW_CTRL1_GPIO_CLK_ENABLE()            __HAL_RCC_GPIOC_CLK_ENABLE()
#define RF_SW_RX_GPIO_CLK_DISABLE()              __HAL_RCC_GPIOC_CLK_DISABLE()

由于射频开关不同，射频控制逻辑也需要修改，把stm32wlxx_nucleo_radio.c中射频开关修改如下所示

int32_t BSP_RADIO_ConfigRFSwitch(BSP_RADIO_Switch_TypeDef Config)
{
  switch (Config)
  {
    case RADIO_SWITCH_OFF:
    {
      /* Turn off switch */
      HAL_GPIO_WritePin(RF_SW_CTRL3_GPIO_PORT, RF_SW_CTRL3_PIN, GPIO_PIN_RESET);
      HAL_GPIO_WritePin(RF_SW_CTRL1_GPIO_PORT, RF_SW_CTRL1_PIN, GPIO_PIN_RESET);
      HAL_GPIO_WritePin(RF_SW_CTRL2_GPIO_PORT, RF_SW_CTRL2_PIN, GPIO_PIN_RESET);
      break;      
    }
    case RADIO_SWITCH_RX:
    {
      /*Turns On in Rx Mode the RF Switch */
      HAL_GPIO_WritePin(RF_SW_CTRL3_GPIO_PORT, RF_SW_CTRL3_PIN, GPIO_PIN_RESET);
      HAL_GPIO_WritePin(RF_SW_CTRL1_GPIO_PORT, RF_SW_CTRL1_PIN, GPIO_PIN_SET); 
      HAL_GPIO_WritePin(RF_SW_CTRL2_GPIO_PORT, RF_SW_CTRL2_PIN, GPIO_PIN_RESET); 
      break;
    }
    case RADIO_SWITCH_RFO_LP:
    {
      /*Turns On in Tx Low Power the RF Switch */
      HAL_GPIO_WritePin(RF_SW_CTRL3_GPIO_PORT, RF_SW_CTRL3_PIN, GPIO_PIN_SET);
      HAL_GPIO_WritePin(RF_SW_CTRL1_GPIO_PORT, RF_SW_CTRL1_PIN, GPIO_PIN_RESET); 
      HAL_GPIO_WritePin(RF_SW_CTRL2_GPIO_PORT, RF_SW_CTRL2_PIN, GPIO_PIN_SET); 
      break;
    }
    case RADIO_SWITCH_RFO_HP:
    {
      /*Turns On in Tx High Power the RF Switch */
      HAL_GPIO_WritePin(RF_SW_CTRL3_GPIO_PORT, RF_SW_CTRL3_PIN, GPIO_PIN_SET);
      HAL_GPIO_WritePin(RF_SW_CTRL1_GPIO_PORT, RF_SW_CTRL1_PIN, GPIO_PIN_RESET); 
      HAL_GPIO_WritePin(RF_SW_CTRL2_GPIO_PORT, RF_SW_CTRL2_PIN, GPIO_PIN_SET); 
      break;
    }
    default:
      break;    
  }  

  return BSP_ERROR_NONE;
}

int32_t BSP_RADIO_GetTxConfig(void)
{
  //return RADIO_CONF_RFO_LP_HP;
	return RADIO_CONF_RFO_HP;
}

//
//使用无源晶振
/**
  * @brief  Get If TCXO is to be present on board
  * @note   never remove called by MW,
  * @retval
  *  RADIO_CONF_TCXO_NOT_SUPPORTED
  *  RADIO_CONF_TCXO_SUPPORTED
  */
int32_t BSP_RADIO_IsTCXO(void)
{
  //return RADIO_CONF_TCXO_SUPPORTED;
	return RADIO_CONF_TCXO_NOT_SUPPORTED
}
由于亿佰特的E77模块使用的是无源晶振，所以需要调整晶振负载电容以保证晶振精度
（这里不调整也可，因为是两个模块互通，但考虑后面lorawan工程还是调整为好）,采用
模块厂商推荐值0x0B
//#define XTAL_DEFAULT_CAP_VALUE      ( 0x20UL )
#define XTAL_DEFAULT_CAP_VALUE      ( 0x0BUL )

2、修改subghz_phy_app.c文件，CubeMx刚生成工程是没有应用程序的。我们只需要从STM32Cube_FW_WL_V1.2.0软件包中去找到对应的工程文件然后修改，修改后的subghz_phy_appp.c如下。

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file    subghz_phy_app.c
  * @author  MCD Application Team
  * @brief   Application of the SubGHz_Phy Middleware
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "platform.h"
#include "sys_app.h"
#include "subghz_phy_app.h"
#include "radio.h"

/* USER CODE BEGIN Includes */
#include "stm32_timer.h"
#include "stm32_seq.h"
#include "utilities_def.h"
#include "app_version.h"
#include "subghz_phy_version.h"
/* USER CODE END Includes */

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

/* USER CODE END EV */

/* Private typedef -----------------------------------------------------------*/

/* USER CODE BEGIN PTD */
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
/* LED blink Period*/
#define LED_PERIOD_MS                 200
/* 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 */
/*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 */

/* 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*/
  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 */
#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 */

  /*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);

  /*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)
          {
            UTIL_TIMER_Stop(&timerLed);
            /* switch off green led */
            HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin, GPIO_PIN_RESET); /* LED_GREEN */
            /* master toggles red led */
            HAL_GPIO_TogglePin(LED3_GPIO_Port, LED3_Pin); /* LED_RED */
            /* Add delay between RX and TX */
            HAL_Delay(Radio.GetWakeupTime() + RX_TIME_MARGIN);
            /* master sends PING*/
            APP_LOG(TS_ON, VLEVEL_L, "..."
                    "PING"
                    "\n\r");
            APP_LOG(TS_ON, VLEVEL_L, "Master Tx start\n\r");
            memcpy(BufferTx, PING, sizeof(PING) - 1);
            Radio.Send(BufferTx, PAYLOAD_LEN);
          }
          else if (strncmp((const char *)BufferRx, PING, sizeof(PING) - 1) == 0)
          {
            /* 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);
          }
          else /* valid reception but neither a PING or a PONG message */
          {
            /* 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);
          }
        }
      }
      else
      {
        if (RxBufferSize > 0)
        {
          if (strncmp((const char *)BufferRx, PING, sizeof(PING) - 1) == 0)
          {
            UTIL_TIMER_Stop(&timerLed);
            /* switch off red led */
            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);
            Radio.Send(BufferTx, PAYLOAD_LEN);
          }
          else /* valid reception but not a PING as expected */
          {
            /* 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:
    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);
        Radio.Send(BufferTx, PAYLOAD_LEN);
      }
      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 */

三、下载测试

最后烧录下载后，正常pingpong通信
在这里插入图片描述

北世安
关注
  • 5
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
E77(stm32wle5ccu6) Lora pingpong工程
06-05
E77(stm32wle5ccu6) Lora pingpong工程,适合看我文章小伙伴移植E77工程通信超时的小伙伴，这个是可以用的。可以自己的工程对比看下差异。
stm32wle5cc datasheet
01-18
ST出的无线soc stm32WLE系列MCU，基于此SOC开发物联网设备，完美替代分离MCU+radio的方案，具有集成度高，更低功耗，成本更低的优势。 易联网科技模组采用最新的方案，Lorawan，modbus ，CAN等常用协议栈于一片SoC。
【LoRaWAN_End_Node】基于STM32Cube IDE的代码移植与烧写
欢迎私信、留言交流
03-22 950
基于LM401模组 在 STM32Cube IDE 环境下实现 LoRaWAN_End_Node 代码的移植 编译和烧写，并成功接入lorawan网关
亿佰特E77模块（基于STM32WLE5CCU6）的使用（一篇就够了）
cai1dao3的专栏
08-02 2116
E77-400M22S 是基于ST 新推出的STM32WLE5CCU6（ARM Cortex-M4 + LoRa）SoC 无线通信模块，具备通信远，待机功耗低，抗干扰能力强，接口资源丰富，处理能力强，外形尺寸小等特性。并适用于433/470MHz 频段贴片式LoRa 无线模块, 使用工业级高精度32.768KHz 和32MHz 晶振。
【STM32WLE5系列#1芯片介绍和开发环境搭建】
qq_47159466的博客
09-27 3404
STM32WLE5介绍和开发环境搭建
【LM401】STM32WLE5+SPI接口驱动 2.66inch e-paper 墨水屏
欢迎私信、留言交流
03-29 1185
> 实现LM401模组（stm32wle5）基于SPI接口驱动墨水屏显示字符 > 利用 SPI1 PA5 6 7接口
【STM32WLE5之lora：6、易智联LM40评估板ADC定时采集上报低功耗处理】
ww2801的博客
01-20 2829
PingPong例程中已经提供了完整的低功耗处理框架，用户只需要打开应用低功耗宏定义即可进行测试。进行扩展时，用户只需在自己开发的功能模块，增加低功耗处理即可完成整个工程的低功耗处理。大大方便降低了用户的开发难度。
STM32WLE5系列#4 stm32wle5ccu6移植LoRaWAN_AT_Slave工程
qq_47159466的博客
09-29 2047
STM32WLE移植带AT指令的lorawan例程
实现LM401模组（stm32wle5）基于SPI接口驱动墨水屏显示字符利用 SPI1 PA5 6 7接口
03-29
实现过程参考博客： ...实现LM401模组（stm32wle5）基于SPI接口驱动墨水屏显示字符 利用 SPI1 PA5 6 7接口 显示图像、字符、中文、以及规定区域显示 可以实现低功耗模式 断电维持刷新状态 墨水屏刷新时间可调节
Penguino-STM32WL-LoRa-E5:此存储库包含基于Seeed Studio LoRa-E5的Penguino Feather突破板的所有必要设计和制造文件
04-30
企鹅-STM32WL-LoRa-E5 Seeedstudio的模块是最近宣布的，我可以自由地为其设计Penguino Feather突破板。 希望OSHW社区能从中受益。 关于企鹅羽毛突围 设法适合+2层（H1.6mm）低成本PCB上的所有产品。 精心的设计选择...
PingPong_download.zip
01-17
总结起来，"PingPong_download.zip"是一个包含易智联LM401 LoRaWAN评估板BSP和CubeMX工程的资源包，为开发者提供了一个快速开发基于STM32WLE5的LoRaWAN应用的起点。通过深入研究和实践这个工程，不仅可以熟悉STM32...
STM32WLE5JC
最新发布
Caramel_biscuit的博客
02-05 1455
sub-GHz无线电是一种超低功耗sub-GHz无线电，工作在150-960MHz ISM频段。在发送和接收中采用LoRa和（G）FSK调制，仅在发送中采用BPSK/(G)MSK调制，可以在距离、数据速率和功耗之间实现最佳权衡。这款sub-GHz无线电符合LoRaWAN®规范v1.0和无线电法规，如ETSI EN 300 220, EN 300 113, EN 301 166, FCC CFR 47 part 15, 24, 90, 101和ARIB STD-T30, T-67, T-108。
【STM32WLE5系列#3 stm32wle5ccu6移植LoRaWAN_End_Node通信】
qq_47159466的博客
09-29 2440
STM32WLE移植LoRaWAN_End_Node通信程序
STM32WL开发之LORA评估板上通过GPIO控制LED
enchen的专栏
10-18 1596
本文介绍了基于STM32WLE5芯片，在易智联LM401-Pro-Kit评估板和SubGHz_Phy_PingPong工程中通过GPIO控制LED灯闪烁的详细开发过程。
【STM32WLE5之LoRa# 系列2、易智联LM401 评估板PingPong工程移植】
ww2801的博客
01-16 2349
PingPong例程的CubeMX工程的移植和CubeIDE工程的生成。
STM32WL开发之LORA开发环境及其Demo例程介绍
enchen的专栏
10-18 3343
本文介绍了STM32WL开发的软件开发环境及工程代码分析，所用的硬件评估板及功能接口，最后给出了软件工程代码下载和硬件评估板采购地址。
【STM32WLE5之LoRa# 系列1、易智联LM401 评估板简介】
ww2801的博客
01-15 6927
STM32WLE5之LoRa# 系列1：易智联LM401 LoraWan评估板
【STM32WLE5之lora：4、易智联LM401 评估板PingPong例程分析】
ww2801的博客
01-18 2330
PingPong例程包含了序列调度、软定时、日志输出、队列、低功耗管理等常用功能。用户在了解该框架的基础上可以快速部署自己的应用，降低开发难度，提高开发效率。对PingPong例程进行简单分析。
stm32简单小实例_抓住蝶粉的心，STM32有“利器”
weixin_39874269的博客
11-20 542
尽管2020年注定是艰难的一年，但意法半导体STM32仍尽力为广大蝶粉提供了面对面沟通碰撞的机会。9月13日-9月25日，为期13天的2020年意法半导体STM32全国巡回研讨会圆满落幕。作为工程师洞悉嵌入式领域最新产品和人工智能物联网技术趋势的年度盛会，今年的STM32以“安全连接，智创未来”为主题，携手物联网生态合作伙伴，共同走进了深圳、杭州、郑州、长沙、南京等14座城市。2020年STM32...
STM32WLE5CCU6学习
07-28
您对STM32WLE5CCU6感兴趣，这是一款由STMicroelectronics公司推出的低功耗微控制器。它是基于Arm Cortex-M4内核和Sub-GHz无线通信技术的产品，适用于物联网应用。 要学习STM32WLE5CCU6，您可以按照以下步骤进行： 1. 了解STM32微控制器：首先，您可以熟悉STM32系列微控制器的基本知识，了解其架构、特性和应用领域。可以查阅STMicroelectronics的官方文档或参考一些STM32的教程和书籍。 2. 学习C语言编程：STM32WLE5CCU6使用C语言进行编程。如果您对C语言还不熟悉，可以通过在线教程、书籍或视频课程来学习C语言的基础知识和语法。 3. 掌握ARM Cortex-M4内核：了解ARM Cortex-M4内核的特性和编程模型，包括中断处理、寄存器操作等。您可以查阅ARM的官方文档或参考一些相关的学习资源。 4. 研究STM32WLE5CCU6文档：下载并阅读STM32WLE5CCU6的数据手册、参考手册和应用笔记。这些文档将详细介绍微控制器的功能、引脚配置、使用方法和示例代码等。 5. 使用开发工具和资源：为了编写、调试和下载代码到STM32WLE5CCU6，您可以使用STMicroelectronics提供的开发工具和资源，例如STM32CubeIDE集成开发环境、STM32Cube软件包和STM32CubeMX配置软件。 6. 实践和项目开发：通过实践项目来巩固所学知识。您可以选择一些简单的项目开始，逐步提高难度。在项目开发过程中，您可以利用STM32WLE5CCU6的无线通信功能，例如LoRa或Sigfox等，来实现物联网应用。 总之，学习STM32WLE5CCU6需要掌握STM32微控制器的基本知识、C语言编程和ARM Cortex-M4内核的理解。通过阅读文档、使用开发工具和实践项目，您将能够熟练地使用STM32WLE5CCU6进行开发。祝您取得成功！如有更多问题，请继续提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值