NRF24L01的收发调试—USB无线串口模块（HAL库）

目录

NRF24L01模块介绍

1、模块和USB连接

2、查询NRF模块的基本信息，使用串口助手：

3、编写发送端代码

4、代码如下：

---

NRF24L01模块介绍

NRF24L01 2.4G 通讯模块采用 SPI 通信，引脚如下：

1、CSN：芯片的片选线，低电平芯片工作；

2、SCK：芯片控制的时钟线（SPI的时钟）；

3、MISO：芯片控制数据线（SPI的MISO）；

4、MOSI：芯片控制数据线（SPI的MOSI）；

5、IRQ：中断信号，NRF24L01芯片收到数据、或者发送完数据等等一些情况会产生下降沿中断；

6、CE：芯片的模式控制线，决定了芯片的工作状态。

如果使用市面上的USB转NRF模块，使用到的AT指令：

1、模块和USB连接

2、查询NRF模块的基本信息，使用串口助手：

 波特率（9600）

波特率：9600
目标地址：     0xFF,0xFF,0xFF,0xFF,0xFF
本地接收地址0：0xFF,0xFF,0xFF,0xFF,0xFF
通讯频率：2.400GHz
校验模式：16位CRC校验
发射?β剩?dBm
空中传输速率：2Mbps

目标地址、通讯频率、校验模式等需要和发送端保持一致。

3、编写发送端代码

 选择调试 

外部高速晶振（8MHz） 

选择SPI2配置 

设置CE,CS,IRQ引脚 

设置好时钟，生成初始代码

 整体引脚设置

PB13     ------> SPI2_SCK
PB14     ------> SPI2_MISO
PB15     ------> SPI2_MOSI

PC13     ------> CS
PC14     ------> CE
PC15     ------> IRQ

4、代码如下：

nrf24l01.h

#ifndef _NRF24L01_H
#define _NRF24L01_H

#include "main.h"

/* 宏定义 --------------------------------------------------------------------*/

#define NRF24L01_SPI_CS_ENABLE()    HAL_GPIO_WritePin(CS_GPIO_Port,CS_Pin,GPIO_PIN_RESET)
#define NRF24L01_SPI_CS_DISABLE()   HAL_GPIO_WritePin(CS_GPIO_Port,CS_Pin,GPIO_PIN_SET)

#define NRF24L01_CE_LOW()   HAL_GPIO_WritePin(CE_GPIO_Port,CE_Pin,GPIO_PIN_RESET)
#define NRF24L01_CE_HIGH() HAL_GPIO_WritePin(CE_GPIO_Port,CE_Pin,GPIO_PIN_SET)

#define NRF24L01_IRQ_PIN_READ()  HAL_GPIO_ReadPin(IRQ_GPIO_Port,IRQ_Pin)


// NRF24L01发送接收数据宽度定义
#define TX_ADR_WIDTH                                  5   	//5字节的地址宽度
#define RX_ADR_WIDTH                                  5   	//5字节的地址宽度
#define TX_PLOAD_WIDTH                                32  	//32字节的用户数据宽度
#define RX_PLOAD_WIDTH                                32  	//32字节的用户数据宽度

//NRF24L01寄存器操作命令
#define NRF_READ_REG                                  0x00  //读配置寄存器,低5位为寄存器地址
#define NRF_WRITE_REG                                 0x20  //写配置寄存器,低5位为寄存器地址
#define RD_RX_PLOAD                                   0x61  //读RX有效数据,1~32字节
#define WR_TX_PLOAD                                   0xA0  //写TX有效数据,1~32字节
#define FLUSH_TX                                      0xE1  //清除TX FIFO寄存器.发射模式下用
#define FLUSH_RX                                      0xE2  //清除RX FIFO寄存器.接收模式下用
#define REUSE_TX_PL                                   0xE3  //重新使用上一包数据,CE为高,数据包被不断发送.
#define NOP                                           0xFF  //空操作,可以用来读状态寄存器
//SPI(NRF24L01)寄存器地址
#define CONFIG                                        0x00  //配置寄存器地址;bit0:1接收模式,0发射模式;bit1:电选择;bit2:CRC模式;bit3:CRC使能;
//bit4:中断MAX_RT(达到最大重发次数中断)使能;bit5:中断TX_DS使能;bit6:中断RX_DR使能
#define EN_AA                                         0x01  //使能自动应答功能  bit0~5,对应通道0~5
#define EN_RXADDR                                     0x02  //接收地址允许,bit0~5,对应通道0~5
#define SETUP_AW                                      0x03  //设置地址宽度(所有数据通道):bit1,0:00,3字节;01,4字节;02,5字节;
#define SETUP_RETR                                    0x04  //建立自动重发;bit3:0,自动重发计数器;bit7:4,自动重发延时 250*x+86us
#define RF_CH                                         0x05  //RF通道,bit6:0,工作通道频率;
#define RF_SETUP                                      0x06  //RF寄存器;bit3:传输速率(0:1Mbps,1:2Mbps);bit2:1,发射功率;bit0:低噪声放大器增益
#define STATUS                                        0x07  //状态寄存器;bit0:TX FIFO满标志;bit3:1,接收数据通道号(最大:6);bit4,达到最多次重发
//bit5:数据发送完成中断;bit6:接收数据中断;
#define MAX_TX  		                                  0x10  //达到最大发送次数中断
#define TX_OK   		                                  0x20  //TX发送完成中断
#define RX_OK   		                                  0x40  //接收到数据中断

#define OBSERVE_TX                                    0x08  //发送检测寄存器,bit7:4,数据包丢失计数器;bit3:0,重发计数器
#define CD                                            0x09  //载波检测寄存器,bit0,载波检测;
#define RX_ADDR_P0                                    0x0A  //数据通道0接收地址,最大长度5个字节,低字节在前
#define RX_ADDR_P1                                    0x0B  //数据通道1接收地址,最大长度5个字节,低字节在前
#define RX_ADDR_P2                                    0x0C  //数据通道2接收地址,最低字节可设置,高字节,必须同RX_ADDR_P1[39:8]相等;
#define RX_ADDR_P3                                    0x0D  //数据通道3接收地址,最低字节可设置,高字节,必须同RX_ADDR_P1[39:8]相等;
#define RX_ADDR_P4                                    0x0E  //数据通道4接收地址,最低字节可设置,高字节,必须同RX_ADDR_P1[39:8]相等;
#define RX_ADDR_P5                                    0x0F  //数据通道5接收地址,最低字节可设置,高字节,必须同RX_ADDR_P1[39:8]相等;
#define TX_ADDR                                       0x10  //发送地址(低字节在前),ShockBurstTM模式下,RX_ADDR_P0与此地址相等
#define RX_PW_P0                                      0x11  //接收数据通道0有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P1                                      0x12  //接收数据通道1有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P2                                      0x13  //接收数据通道2有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P3                                      0x14  //接收数据通道3有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P4                                      0x15  //接收数据通道4有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P5                                      0x16  //接收数据通道5有效数据宽度(1~32字节),设置为0则非法
#define NRF_FIFO_STATUS                               0x17  //FIFO状态寄存器;bit0,RX FIFO寄存器空标志;bit1,RX FIFO满标志;bit2,3,保留
//bit4,TX FIFO空标志;bit5,TX FIFO满标志;bit6,1,循环发送上一数据包.0,不循环;


/* 函数声明 ------------------------------------------------------------------*/
void NRF24L01_RX_Mode(void);					//配置为接收模式
void NRF24L01_TX_Mode(void);					//配置为发送模式
uint8_t NRF24L01_Write_Buf(uint8_t reg, uint8_t *pBuf, uint8_t uint8_ts);//写数据区
uint8_t NRF24L01_Read_Buf(uint8_t reg, uint8_t *pBuf, uint8_t uint8_ts);	//读数据区
uint8_t NRF24L01_Read_Reg(uint8_t reg);					//读寄存器
uint8_t NRF24L01_Write_Reg(uint8_t reg, uint8_t value);		//写寄存器
uint8_t NRF24L01_Check(void);						//检查24L01是否存在
uint8_t NRF24L01_TxPacket(uint8_t *txbuf);				//发送一个包的数据
uint8_t NRF24L01_RxPacket(uint8_t *rxbuf);				//接收一个包的数据
void NRF_LowPower_Mode(void);


#endif

nrf24l01.c 

#include "nrf24L01.h"
#include "spi.h"

const uint8_t TX_ADDRESS[TX_ADR_WIDTH]={0x34,0x43,0x10,0x10,0x01}; //发送地址
const uint8_t RX_ADDRESS[RX_ADR_WIDTH]={0x34,0x43,0x10,0x10,0x01}; //接收地址

/**
  * 函数功能: 往串行Flash读取写入一个字节数据并接收一个字节数据
  * 输入参数: byte：待发送数据
  * 返 回 值: uint8_t：接收到的数据
  * 说    明：无
  */
uint8_t SPIx_ReadWriteByte(SPI_HandleTypeDef* hspi,uint8_t byte)
{
    uint8_t d_read,d_send=byte;
    if(HAL_SPI_TransmitReceive(hspi,&d_send,&d_read,1,0xFF)!=HAL_OK)
    {
        d_read=0xFF;
    }
    return d_read;
}

/**
  * 函数功能: 检测24L01是否存在
  * 输入参数: 无
  * 返 回 值: 0，成功;1，失败
  * 说    明：无
  */
uint8_t NRF24L01_Check(void)
{
    uint8_t buf[5]={0XA5,0XA5,0XA5,0XA5,0XA5};
    uint8_t i;

    NRF24L01_Write_Buf(NRF_WRITE_REG+TX_ADDR,buf,5);//写入5个字节的地址.
    NRF24L01_Read_Buf(TX_ADDR,buf,5); //读出写入的地址
    for(i=0;i<5;i++)if(buf[i]!=0XA5)break;
    if(i!=5)return 1;   //检测24L01错误
    return 0;		 	//检测到24L01
}

/**
  * 函数功能: SPI写寄存器
  * 输入参数: 无
  * 返 回 值: 无
  * 说    明：reg:指定寄存器地址
  *
  */
uint8_t NRF24L01_Write_Reg(uint8_t reg,uint8_t value)
{
    uint8_t status;
    NRF24L01_SPI_CS_ENABLE();                 //使能SPI传输
    status =SPIx_ReadWriteByte(&hspi2,reg);   //发送寄存器号
    SPIx_ReadWriteByte(&hspi2,value);         //写入寄存器的值
    NRF24L01_SPI_CS_DISABLE();                //禁止SPI传输
    return(status);       			//返回状态值
}

/**
  * 函数功能: 读取SPI寄存器值
  * 输入参数: 无
  * 返 回 值: 无
  * 说    明：reg:要读的寄存器
  *
  */
uint8_t NRF24L01_Read_Reg(uint8_t reg)
{
    uint8_t reg_val;
    NRF24L01_SPI_CS_ENABLE();          //使能SPI传输
    SPIx_ReadWriteByte(&hspi2,reg);   //发送寄存器号
    reg_val=SPIx_ReadWriteByte(&hspi2,0XFF);//读取寄存器内容
    NRF24L01_SPI_CS_DISABLE();          //禁止SPI传输
    return(reg_val);           //返回状态值
}

/**
  * 函数功能: 在指定位置读出指定长度的数据
  * 输入参数: 无
  * 返 回 值: 此次读到的状态寄存器值
  * 说    明：无
  *
  */
uint8_t NRF24L01_Read_Buf(uint8_t reg,uint8_t *pBuf,uint8_t len)
{
    uint8_t status,uint8_t_ctr;

    NRF24L01_SPI_CS_ENABLE();           //使能SPI传输
    status=SPIx_ReadWriteByte(&hspi2,reg);//发送寄存器值(位置),并读取状态值
    for(uint8_t_ctr=0;uint8_t_ctr<len;uint8_t_ctr++)
    {
        pBuf[uint8_t_ctr]=SPIx_ReadWriteByte(&hspi2,0XFF);//读出数据
    }
    NRF24L01_SPI_CS_DISABLE();       //关闭SPI传输
    return status;        //返回读到的状态值
}

/**
  * 函数功能: 在指定位置写指定长度的数据
  * 输入参数: 无
  * 返 回 值: 无
  * 说    明：reg:寄存器(位置)  *pBuf:数据指针  len:数据长度
  *
  */
uint8_t NRF24L01_Write_Buf(uint8_t reg, uint8_t *pBuf, uint8_t len)
{
    uint8_t status,uint8_t_ctr;
    NRF24L01_SPI_CS_ENABLE();          //使能SPI传输
    status = SPIx_ReadWriteByte(&hspi2,reg);//发送寄存器值(位置),并读取状态值
    for(uint8_t_ctr=0; uint8_t_ctr<len; uint8_t_ctr++)
    {
        SPIx_ReadWriteByte(&hspi2,*pBuf++); //写入数据
    }
    NRF24L01_SPI_CS_DISABLE();       //关闭SPI传输
    return status;          //返回读到的状态值
}

/**
  * 函数功能: 启动NRF24L01发送一次数据
  * 输入参数: 无
  * 返 回 值: 发送完成状况
  * 说    明：txbuf:待发送数据首地址
  *
  */
uint8_t NRF24L01_TxPacket(uint8_t *txbuf)
{
    uint8_t sta;
    NRF24L01_CE_LOW();
    NRF24L01_Write_Buf(WR_TX_PLOAD,txbuf,TX_PLOAD_WIDTH);//写数据到TX BUF  32个字节
    NRF24L01_CE_HIGH();//启动发送

    while(NRF24L01_IRQ_PIN_READ()!=0);//等待发送完成

    sta=NRF24L01_Read_Reg(STATUS);  //读取状态寄存器的值
    NRF24L01_Write_Reg(NRF_WRITE_REG+STATUS,sta); //清除TX_DS或MAX_RT中断标志
    if(sta&MAX_TX)//达到最大重发次数
    {
        NRF24L01_Write_Reg(FLUSH_TX,0xff);//清除TX FIFO寄存器
        return MAX_TX;
    }
    if(sta&TX_OK)//发送完成
    {
        return TX_OK;
    }
    return 0xff;//其他原因发送失败
}

/**
  * 函数功能:启动NRF24L01接收一次数据
  * 输入参数: 无
  * 返 回 值: 无
  * 说    明：无
  *
  */
uint8_t NRF24L01_RxPacket(uint8_t *rxbuf)
{
    uint8_t sta;
    sta=NRF24L01_Read_Reg(STATUS);  //读取状态寄存器的值
    NRF24L01_Write_Reg(NRF_WRITE_REG+STATUS,sta); //清除TX_DS或MAX_RT中断标志
    if(sta&RX_OK)//接收到数据
    {
        NRF24L01_Read_Buf(RD_RX_PLOAD,rxbuf,RX_PLOAD_WIDTH);//读取数据
        NRF24L01_Write_Reg(FLUSH_RX,0xff);//清除RX FIFO寄存器
        return 0;
    }
    return 1;//没收到任何数据
}

/**
  * 函数功能: 该函数初始化NRF24L01到RX模式
  * 输入参数: 无
  * 返 回 值: 无
  * 说    明：无
  *
  */
void NRF24L01_RX_Mode(void)
{
    NRF24L01_CE_LOW();
    NRF24L01_Write_Reg(NRF_WRITE_REG+CONFIG, 0x0F);//配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC
    NRF24L01_Write_Reg(NRF_WRITE_REG+EN_AA,0x01);    //使能通道0的自动应答
    NRF24L01_Write_Reg(NRF_WRITE_REG+EN_RXADDR,0x01);//使能通道0的接收地址
    NRF24L01_Write_Reg(NRF_WRITE_REG+RF_CH,40);	     //设置RF通信频率
    NRF24L01_Write_Reg(NRF_WRITE_REG+RF_SETUP,0x0f);//设置TX发射参数,0db增益,2Mbps,低噪声增益开启
    NRF24L01_Write_Reg(NRF_WRITE_REG+RX_PW_P0,RX_PLOAD_WIDTH);//选择通道0的有效数据宽度
    NRF24L01_Write_Buf(NRF_WRITE_REG+RX_ADDR_P0,(uint8_t*)RX_ADDRESS,RX_ADR_WIDTH);//写RX节点地址
    NRF24L01_CE_HIGH(); //CE为高,进入接收模式
    HAL_Delay(1);
}

/**
  * 函数功能: 该函数初始化NRF24L01到TX模式
  * 输入参数: 无
  * 返 回 值: 无
  * 说    明：无
  *
  */
void NRF24L01_TX_Mode(void)
{
    NRF24L01_CE_LOW();
    NRF24L01_Write_Buf(NRF_WRITE_REG+TX_ADDR,(uint8_t*)TX_ADDRESS,TX_ADR_WIDTH);//写TX节点地址
    NRF24L01_Write_Buf(NRF_WRITE_REG+RX_ADDR_P0,(uint8_t*)RX_ADDRESS,RX_ADR_WIDTH); //设置TX节点地址,主要为了使能ACK
    NRF24L01_Write_Reg(NRF_WRITE_REG+EN_AA,0x01);     //使能通道0的自动应答
    NRF24L01_Write_Reg(NRF_WRITE_REG+EN_RXADDR,0x01); //使能通道0的接收地址
    NRF24L01_Write_Reg(NRF_WRITE_REG+SETUP_RETR,0xff);//设置自动重发间隔时间:4000us + 86us;最大自动重发次数:15次
    NRF24L01_Write_Reg(NRF_WRITE_REG+RF_CH,40);       //设置RF通道为40
    NRF24L01_Write_Reg(NRF_WRITE_REG+RF_SETUP,0x0f);  //设置TX发射参数,0db增益,2Mbps,低噪声增益开启
    NRF24L01_Write_Reg(NRF_WRITE_REG+CONFIG,0x0e);    //配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,接收模式,开启所有中断
    NRF24L01_CE_HIGH();//CE为高,10us后启动发送
    HAL_Delay(1);
}

/**
  * 函数功能: 该函数NRF24L01进入低功耗模式
  * 输入参数: 无
  * 返 回 值: 无
  * 说    明：无
  *
  */
void NRF_LowPower_Mode(void)
{
    NRF24L01_CE_LOW();
    NRF24L01_Write_Reg(NRF_WRITE_REG+CONFIG, 0x00);		//配置工作模式:掉电模式
}

main.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 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 "main.h"
#include "spi.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "oled.h"
#include "led.h"
#include "nrf24l01.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
uint8_t data[5] = {0};
/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

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

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void) {
    /* USER CODE BEGIN 1 */

    /* USER CODE END 1 */

    /* MCU Configuration--------------------------------------------------------*/

    /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    HAL_Init();

    /* USER CODE BEGIN Init */

    /* USER CODE END Init */

    /* Configure the system clock */
    SystemClock_Config();

    /* USER CODE BEGIN SysInit */

    /* USER CODE END SysInit */

    /* Initialize all configured peripherals */
    MX_GPIO_Init();
    MX_SPI2_Init();
    /* USER CODE BEGIN 2 */
    OLED_Init();
    OLED_Display_On();
    while (NRF24L01_Check()) {
        OLED_ShowString(2, 2, "NRF24L01_fail");
        HAL_Delay(1000);
    }
    OLED_ShowString(2, 2, "NRF24L01_success");

//    NRF24L01_TX_Mode();//设置为发送模式
    NRF24L01_RX_Mode();//设置为接收模式

    /* USER CODE END 2 */

    /* Infinite loop */
    /* USER CODE BEGIN WHILE */
    while (1) {
        /* USER CODE END WHILE */

        /* USER CODE BEGIN 3 */
//    uint8_t Send_Out[33]="本段数据来自NRF24L01发�?�端 ";   //要发送的内容(单次�?�?32个字�?)
//        data[0] = 4;
//        data[1] = 0x78;
//        data[2] = 0x79;
//        data[3] = 0x80;
//        data[4] = 0x81;

//        OLED_ShowString(2, 2, "123244444");
        HAL_Delay(1000);
//        if (NRF24L01_TxPacket(data) == TX_OK) {
//            OLED_ShowString(2, 6, "OK");
//        } else {
//            OLED_ShowString(2, 6, "NOOK");
//        }

        if(NRF24L01_RxPacket(data)==0)
        {
            data[32]=0;//加入字符串结束符
            OLED_ShowString(2, 6, "REOK");
        }else{
            OLED_ShowString(2, 6, "RENOOK");
        }
        HAL_Delay(500);



//        HAL_GPIO_TogglePin(LED0_GPIO_Port, LED0_Pin);
//        HAL_GPIO_TogglePin(LED1_GPIO_Port, LED1_Pin);
//        LED_FLASH();
    }
    /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void) {
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

    /** Initializes the RCC Oscillators according to the specified parameters
    * in the RCC_OscInitTypeDef structure.
    */
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
    RCC_OscInitStruct.HSEState = RCC_HSE_ON;
    RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
    RCC_OscInitStruct.HSIState = RCC_HSI_ON;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
        Error_Handler();
    }

    /** Initializes the CPU, AHB and APB buses clocks
    */
    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK
                                  | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK) {
        Error_Handler();
    }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void) {
    /* USER CODE BEGIN Error_Handler_Debug */
    /* User can add his own implementation to report the HAL error return state */
    __disable_irq();
    while (1) {
    }
    /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */