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

最新推荐文章于 2024-01-22 08:43:29 发布
最新推荐文章于 2024-01-22 08:43:29 发布
阅读量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
    评论
专栏目录
stm8-stm32-ping-pong
05-12
/ _____) _ | | ( (____ _____ ____ _| |_ _____ ____| |__ \____ \| ___ | (_ _) ___ |/ ___) _ \ _____) ) ____| | | || |_| ____( (___| | | | (______/|_____)_|_|_| \__)_____)\____)_| |_| (C)2013 Semtech SX1272 / 76无线电驱动程序以及Ping-Pong固件和LoRaWAN节点固件实现。 介绍 该项目的目的是展示LoRaWAN规范端点固件实现的示例。 备注1： Semtech实现是EU868频段A类和C类端点实现，完全兼容LoRaWAN 1.0规范。 备注2： C类正常操作已使用Actility服务器进行了
E77(stm32wle5ccu6) Lora pingpong工程
06-05
E77(stm32wle5ccu6) Lora pingpong工程,适合看我文章小伙伴移植E77工程通信超时的小伙伴，这个是可以用的。可以自己的工程对比看下差异。
【LoRaWAN_End_Node】基于STM32Cube IDE的代码移植与烧写
欢迎私信、留言交流
03-22 950
基于LM401模组 在 STM32Cube IDE 环境下实现 LoRaWAN_End_Node 代码的移植 编译和烧写，并成功接入lorawan网关
【STM32WLE5之LoRa# 系列3、易智联LM401 评估板PingPong应用移植】
ww2801的博客
01-17 1541
STM32WLE5平台的PingPong应用程序移植
STM32WLE5系列#4 stm32wle5ccu6移植LoRaWAN_AT_Slave工程
qq_47159466的博客
09-29 2047
STM32WLE移植带AT指令的lorawan例程
亿佰特E77模块（基于STM32WLE5CCU6）的使用（一篇就够了）
cai1dao3的专栏
08-02 2116
E77-400M22S 是基于ST 新推出的STM32WLE5CCU6（ARM Cortex-M4 + LoRa）SoC 无线通信模块，具备通信远，待机功耗低，抗干扰能力强，接口资源丰富，处理能力强，外形尺寸小等特性。并适用于433/470MHz 频段贴片式LoRa 无线模块, 使用工业级高精度32.768KHz 和32MHz 晶振。
【STM32WLE5之lora：4、易智联LM401 评估板PingPong例程分析】
ww2801的博客
01-18 2330
PingPong例程包含了序列调度、软定时、日志输出、队列、低功耗管理等常用功能。用户在了解该框架的基础上可以快速部署自己的应用，降低开发难度，提高开发效率。对PingPong例程进行简单分析。
stm32wle5cc datasheet
01-18
ST出的无线soc stm32WLE系列MCU，基于此SOC开发物联网设备，完美替代分离MCU+radio的方案，具有集成度高，更低功耗，成本更低的优势。 易联网科技模组采用最新的方案，Lorawan，modbus ，CAN等常用协议栈于一片SoC。
实现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上的所有产品。 精心的设计选择...
Keil.STM32WLxx_DFP.1.0.0.pack
07-29
Keil.STM32WLxx_DFP.1.0.0.pack Keil.STM32WLxx_DFP.1.0.0.pack Keil.STM32WLxx_DFP.1.0.0.pack Keil.STM32WLxx_DFP.1.0.0.pack
PingPong_download.zip
01-17
总结起来，"PingPong_download.zip"是一个包含易智联LM401 LoRaWAN评估板BSP和CubeMX工程的资源包，为开发者提供了一个快速开发基于STM32WLE5的LoRaWAN应用的起点。通过深入研究和实践这个工程，不仅可以熟悉STM32...
【STM32WLE5系列#1芯片介绍和开发环境搭建】
qq_47159466的博客
09-27 3404
STM32WLE5介绍和开发环境搭建
【STM32WLE5之LoRa# 系列2、易智联LM401 评估板PingPong工程移植】
ww2801的博客
01-16 2349
PingPong例程的CubeMX工程的移植和CubeIDE工程的生成。
【LM401】STM32WLE5+SPI接口驱动 2.66inch e-paper 墨水屏
欢迎私信、留言交流
03-29 1185
> 实现LM401模组（stm32wle5）基于SPI接口驱动墨水屏显示字符 > 利用 SPI1 PA5 6 7接口
STM32WLE5JC 低功耗模式
最新发布
Caramel_biscuit的博客
01-22 1163
PKA用于计算加密公钥原语，特别是与RSA (Rivest, Shamir和Adleman)， Diffie-Hellmann或ECC(椭圆曲线加密)在GF§(伽罗瓦域)上相关的原语。传感器提供良好的线性，但它必须校准，以获得良好的整体精度的温度测量。为了改善复位下的消耗，复位下和复位后的I/O状态为“模拟状态”（I/O斯密特触发器被禁用）。这些器件包括一个高级16位定时器，一个通用32位定时器，两个16位基本定时器，三个低功耗定时器，两个看门狗定时器和一个SysTick定时器。
【STM32WLE5系列#3 stm32wle5ccu6移植LoRaWAN_End_Node通信】
qq_47159466的博客
09-29 2440
STM32WLE移植LoRaWAN_End_Node通信程序
STM32WLE5JC介绍
Caramel_biscuit的博客
01-18 1236
STM32WLE5/E4xx远程无线和超低功耗器件嵌入了强大的超低功耗LPWAN兼容无线电解决方案，支持以下调制：LoRa，（G）FSK，（G）MSK和BPSK。LoRa®调制仅适用于STM32WLx5xx。这些器件被设计为功耗极低，基于高性能ARM Cortex-M4 32位RISC内核，工作频率高达48MHz。该核心实现了一套完整的DSP指令和一个独立的内存保护单元（MPU），提高了应用程序的安全性。
【STM32WLE5之lora：6、易智联LM40评估板ADC定时采集上报低功耗处理】
ww2801的博客
01-20 2829
PingPong例程中已经提供了完整的低功耗处理框架，用户只需要打开应用低功耗宏定义即可进行测试。进行扩展时，用户只需在自己开发的功能模块，增加低功耗处理即可完成整个工程的低功耗处理。大大方便降低了用户的开发难度。
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、付费专栏及课程。

余额充值