YRr YRr
YRr YRr

BP-50 开发框架使用解读

【独家框架】UWB DWM1000 开源项目框架 - 基础知识 51uwb.cn

[重要更新]51uwb_base code中断更新 - 基础知识 51uwb.cn

【软件资料】BP50 套件新框架定位代码实现 - 基础知识 51uwb.cn

【开源项目】纯Python TWR算法UWB上位机 - 基础知识 51uwb.cn

上位机软件通信协议更改说明 - 基础知识 51uwb.cn

Bphero-UWB 基站0 和 电脑串口数据格式定义 - 基础知识 51uwb.cn

DWM1000中断方式接收信息 代码参考 - 基础知识 51uwb.cn

配置STM32 中断引脚 – DWM1000 IRQ 【STM32 基础知识】 - 基础知识 51uwb.cn

DWM1000 自动应答 — 代码实现 - 基础知识 51uwb.cn

基站如何传输GPS数据给标签呢？要怎么更改发送帧的内容阿 - 问答社区 51uwb.cn

DWM1000 帧过滤代码实现 - tuzhuke - 博客园 (cnblogs.com)

[新人福利]UWB定位模块PCB及原理图 - 基础知识 51uwb.cn

STM32程序移植方法【STM32 基础知识】 - 基础知识 51uwb.cn

求助 DWM1000 谁有信号质量 和功率代码和计算方式 - 问答社区 51uwb.cn

UWB怎么校准？ - 基础知识 51uwb.cn

关于帧过滤问题，请大神解释一下，非常感谢 - 基础知识 51uwb.cn

dw1000帧过滤问题 - 基础知识 51uwb.cn

DWM1000 帧过滤功能实现 - 基础知识 51uwb.cn

基站0串口数据刷新慢解决方案【代码优化】 - 基础知识 51uwb.cn

UWB定位上位机增加导出数据功能 - 问答社区 51uwb.cn

上位机软件 代码注释 - 问答社区 51uwb.cn

UWB标签显示坐标的两种思路 - 基础知识 51uwb.cn

DW1000的移动标签能否自己解算位置？ - 问答社区 51uwb.cn

bp hero的位置数据从哪里读取啊？ - 问答社区 51uwb.cn

求一个小车轨迹追踪上位机设计论文的上位机软件部分怎么写！！！ - 问答社区 51uwb.cn

官方上位机修改 主窗体 名字方法 - 基础知识 51uwb.cn

卡尔曼滤波

RSSI信号强度

三边定位

BP-50 开发框架

概述

  1. 模块角色定义：

    • 在 bphero_uwb.h 文件中，通过软件定义模块角色，可以设置为基站（RX节点）或标签（TX节点）。通过注释或取消注释特定的宏定义来选择角色。
    • 如定义 RX_NODE 表示该模块为基站，定义 TX_NODE 表示为标签。
    //rx为基站，tx为标签
#define RX_NODE   // 基站
//#define TX_NODE //标签

  2. 基站和标签的地址设置：

    • 基站的地址从 0x0001 开始，且在部署完毕后，应将地址为 0x0001 的基站连接到串口。
    • 标签的地址从 0x0005 开始，确保标签和基站的地址不重叠。
    //基站节点地址0x0001 0x0002 0x0003
//部署完毕基站0x0001 链接串口
//基站地址必须从0x0001开始！！！
#ifdef RX_NODE
	#define SHORT_ADDR 0x0001
//#define LCD_ENABLE //没有液晶的时候，把这个宏定义注释掉
#endif

//标签和基站地址不能重叠
//标签节点地址 0x0005 0x0006 0x0007
#ifdef TX_NODE
	#define SHORT_ADDR 0x0005
	#define LCD_ENABLE //没有液晶的时候，把这个宏定义注释掉
#endif

  3. 多基站多标签的支持：

    • 通过修改 tx_main.c 文件来控制多标签和多基站的配置。
    • 对于多个基站，只需修改 MAX_ANTHOR 宏定义。基站地址应从 0x0001 开始。
    • SEPC_ADDRESS 定义为规0地址，用于在规0后向基站 0x0001 发送距离信息。DEST_BEGIN_ADDR 和 DEST_END_ADDR 定义了基站的地址范围。
    • 对于多标签控制，可以通过调整 MAX_FREQ_HZ（定位频率）和 MAX_TX_Node（系统中最多标签节点数）来进行配置。
      //多基站控制
  /************************!!!重要宏定义！！！******************************/
/****************多基站只需要修改MAX_ANTHOR即可***************************/
/*****************基站的地址必须是从0x0001 开始***************************/
#define MAX_ANTHOR 4
//anthor range
#define SEPC_ADDRESS 0x0000  //规0地址，每次规0后，向基站0x0001发送距离信息
#define DEST_BEGIN_ADDR 0x0001  //基站起始地址
#define DEST_END_ADDR   DEST_BEGIN_ADDR + MAX_ANTHOR - 1 //anthro address 0x001 0x002 0x003 for 2D ,0x0001 0x0002 0x0003 0x0004 for 3D

   //多标签控制
#define MAX_FREQ_HZ 10 //定位10HZ
#define MAX_TX_Node 2  //系统中实际存在最多标签节点

  4. 技术支持：

    • 遇到使用中的问题，可以通过51uwb.cn网站与开发团队联系交流。

mian.c

#include "stm32f10x.h" // 引入STM32F10x系列微控制器的头文件
#include  // 引入标准输入输出库
#include "deca_device_api.h" // 引入Decawave UWB设备的API定义
#include "deca_regs.h" // 引入Decawave设备的寄存器定义
#include "deca_sleep.h" // 引入Decawave设备的睡眠模式处理库
#include "port.h" // 引入与硬件端口相关的定义和函数
#include "bphero_uwb.h" // 引入与该UWB系统特定功能相关的头文件
//#include "lcd_oled.h" // 被注释掉的头文件，可能用于OLED显示的库

extern int rx_main(void); // 声明外部函数rx_main，用于接收节点（基站）
extern int tx_main(void); // 声明外部函数tx_main，用于发送节点（标签）

int main(void)
{
    peripherals_init(); // 初始化微控制器的外围设备
    BPhero_UWB_Message_Init(); // 初始化UWB消息系统
    BPhero_UWB_Init(); // 初始化UWB系统

#ifdef RX_NODE
    rx_main(); // 如果定义了RX_NODE，作为接收节点执行rx_main函数 基站
#endif

#ifdef TX_NODE
    tx_main(); // 如果定义了TX_NODE，作为发送节点执行tx_main函数 标签
#endif
}

这段代码是一个用于超宽带（UWB）技术的定位系统的主函数（main）部分。我将逐行解释其功能和作用：

  1. 包含头文件：

    • #include "stm32f10x.h": 引入STM32F10x系列微控制器的头文件，提供基础的硬件定义。
    • #include : 引入标准输入输出库，用于基本的I/O操作。
    • #include "deca_device_api.h": 引入Decawave UWB设备的API定义。
    • #include "deca_regs.h": 引入Decawave设备的寄存器定义。
    • #include "deca_sleep.h": 引入Decawave设备的睡眠模式处理库。
    • #include "port.h": 引入与硬件端口相关的定义和函数。
    • #include "bphero_uwb.h": 引入与该UWB系统特定功能相关的头文件。
    • //#include "lcd_oled.h": 被注释掉的头文件，可能是用于OLED显示的库，但在此代码中未使用。

  2. 外部函数声明：

    • extern int rx_main(void);: 声明外部函数rx_main，这是作为接收节点（基站）的主要功能函数。
    • extern int tx_main(void);: 声明外部函数tx_main，这是作为发送节点（标签）的主要功能函数。

  3. 主函数main的定义：

    • peripherals_init();: 初始化微控制器的外围设备。
    • BPhero_UWB_Message_Init();: 初始化UWB消息系统，可能是用于配置消息传输相关的参数。
    • BPhero_UWB_Init();: 初始化UWB系统，可能包括设置UWB设备的参数和状态。

  4. 条件编译指令：

    • #ifdef RX_NODE: 这是一个预处理指令，检查是否定义了RX_NODE。如果定义了，意味着当前模块配置为接收节点（基站）。
      • rx_main();: 在基站模式下调用rx_main函数，执行接收节点的主要操作。
    • #ifdef TX_NODE: 这是另一个预处理指令，检查是否定义了TX_NODE。如果定义了，意味着当前模块配置为发送节点（标签）。
      • tx_main();: 在标签模式下调用tx_main函数，执行发送节点的主要操作。

总结来说，这段代码是UWB系统主程序的入口，根据预编译的宏定义来决定当前设备是作为基站还是标签，并执行相应的初始化和主要功能函数。这种设计使得同一套代码可以用于不同的硬件配置，只需改变宏定义即可切换角色。

bp_filter.c

#define Filter_N 5  // 定义系统中使用的滤波器数量为5
#define Filter_D 5  // 定义每个滤波器包含的数据数量为5
int Value_Buf[Filter_N][Filter_D]= {0}; // 二维数组，存储每个滤波器的数据点
int filter_index[Filter_N] = {0}; // 数组，记录每个滤波器的当前数据点索引

// 定义滤波函数
int filter(int input, int fliter_idx )
{
    char count = 0; // 计数器变量
    int sum = 0, min, max; // 定义求和、最小值、最大值变量
    min = max = Value_Buf[fliter_idx][0]; // 初始化最小值和最大值为当前滤波器的第一个数据点的值

    // 如果输入值大于0，更新数据缓冲区和索引
    if(input > 0)
    {
        Value_Buf[fliter_idx][filter_index[fliter_idx]++]=input;
        if(filter_index[fliter_idx] == Filter_D) filter_index[fliter_idx] = 0;
    }

    // 遍历当前滤波器的所有数据点
    for(count = 0; count < Filter_D; count++)
    {
        // 找出最大值和最小值
        if (Value_Buf[fliter_idx][count] > max) max = Value_Buf[fliter_idx][count];
        if (Value_Buf[fliter_idx][count] < min) min = Value_Buf[fliter_idx][count];

        // 计算总和
        sum += Value_Buf[fliter_idx][count];
    }
    
    // 从总和中减去最大值和最小值
    sum = sum - max - min;
    
    // 返回处理后的平均值（排除了最大值和最小值）
    return (int)(sum / (Filter_D - 2));
}

这段代码定义了一个简单的滤波器函数，用于处理数字信号。代码的主要部分如下：

  1. 宏定义：

    • #define Filter_N 5: 定义系统中使用的滤波器数量，这里是5个。
    • #define Filter_D 5: 定义每个滤波器包含的数据数量，这里是5个数据点。

  2. 全局变量定义：

    • int Value_Buf[Filter_N][Filter_D]= {0};: 定义一个二维数组，用于存储每个滤波器的所有数据点。数组的大小由上面定义的 Filter_N 和 Filter_D 决定。
    • int filter_index[Filter_N] = {0};: 定义一个数组，用于记录每个滤波器的当前数据点索引。

  3. 滤波函数 filter：

    • int filter(int input, int fliter_idx ): 这个函数接受一个输入值 input 和一个滤波器索引 fliter_idx。
    • char count = 0;: 定义一个计数器变量。
    • int sum = 0, min, max;: 定义用于计算的变量 sum、min 和 max。
    • min = max = Value_Buf[fliter_idx][0];: 初始化 min 和 max 为当前滤波器的第一个数据点的值。
    • if(input > 0) {...}: 如果输入值大于0，则将其添加到相应滤波器的数据缓冲区中，并更新索引。
    • for(count = 0; count < Filter_D; count++) {...}: 遍历当前滤波器的所有数据点。
      • 在这个循环中，代码找出最大值和最小值，并计算所有数据点的总和。
    • sum = sum - max - min;: 从总和中减去找到的最大值和最小值。
    • return (int)(sum / (Filter_D - 2));: 返回处理后的平均值（排除了最大值和最小值）。

这个滤波器基本上是一个简化版的中值滤波器，它排除了每个样本集中的最大值和最小值，然后计算剩余值的平均值。这种方法有助于减少由极端值或噪声引起的误差。

rx_main.c

/**
  ******************************************************************************
  * @file    Project/STM32F10x_StdPeriph_Template/main.c
  * @author  MCD Application Team
  * @version V3.5.0
  * @date    08-April-2011
  * @brief   Main program body
  ******************************************************************************
  * @attention
  *
  * 本固件仅供指导之用，旨在为客户提供有关其产品的编码信息，以节省时间。
  * 因此，STMicroelectronics 对于任何由于本固件内容和/或客户使用此编码信息而产生的任何直接、
  * 间接或后果性损害不承担任何责任。
  *
  * 
© COPYRIGHT 2011 STMicroelectronics

  ******************************************************************************
  */

#include "stm32f10x.h" // 引入STM32F10x系列微控制器的头文件
#include  // 引入标准输入输出库
#include "deca_device_api.h" // 引入Decawave UWB设备的API定义
#include "deca_regs.h" // 引入Decawave设备的寄存器定义
#include "deca_sleep.h" // 引入Decawave设备的睡眠模式处理库
#include "port.h" // 引入与硬件端口相关的定义和函数
#include "lcd_oled.h" // 引入OLED显示屏的库
#include "frame_header.h" // 引入帧头文件
#include "bp_filter.h" // 引入滤波器头文件
#include "common_header.h" // 引入公共头文件
#include "bphero_uwb.h" // 引入与该UWB系统特定功能相关的头文件
#include "dwm1000_timestamp.h" // 引入与DW1000时间戳相关的头文件
#include "kalman.h" // 引入卡尔曼滤波算法的头文件

static void Handle_TimeStamp(void); // 处理时间戳的函数声明
#define MAX_ANTHOR_NODE 40 // 定义最大的基站节点数为40
struct distance_struct // 定义距离结构体
{
    double rx_distance; // 接收距离
    struct time_timestamp tx_node; // 发送节点的时间戳
    struct time_timestamp rx_node; // 接收节点的时间戳
    bool present; // 标记是否存在
    int count; // 计数器
} bphero_distance[MAX_ANTHOR_NODE]; // 定义存储最大基站节点距离的数组

typedef signed long long int64; // 定义64位有符号整型
typedef unsigned long long uint64; // 定义64位无符号整型
static uint64 poll_rx_ts; // 接收轮询时间戳
static uint64 resp_tx_ts; // 响应发送时间戳
static uint64 final_rx_ts; // 最终接收时间戳

static uint64 poll_tx_ts; // 发送轮询时间戳
static uint64 resp_rx_ts; // 响应接收时间戳
static uint64 final_tx_ts; // 最终发送时间戳

static srd_msg_dsss *msg_f; // 定义消息指针
static double tof; // 飞行时间
static double distance_temp = 0; // 临时距离
static double distance[256] = {0}; // 距离数组
extern dwt_config_t config; // 引入DW1000配置

/* 私有函数 ---------------------------------------------------------*/
void Simple_Rx_Callback()
{
    uint32 status_reg = 0, i = 0; // 定义并初始化状态寄存器和循环变量
    uint32 poll_tx_ts, resp_rx_ts, final_tx_ts; // 定义时间戳变量
    uint32 poll_rx_ts_32, resp_tx_ts_32, final_rx_ts_32; // 定义32位时间戳变量
    double Ra, Rb, Da, Db; // 定义计算飞行时间所需的变量
    int64 tof_dtu; // 定义飞行时间单位变量
    char dist_str[16] = {0}; // 定义距离字符串数组
    for (i = 0; i < FRAME_LEN_MAX; i++ )
    {
        rx_buffer[i] = '\0'; // 清空接收缓冲区
    }
    dwt_enableframefilter(DWT_FF_RSVD_EN); // 启用帧过滤功能（此处设置为禁用接收）
    status_reg = dwt_read32bitreg(SYS_STATUS_ID); // 读取系统状态寄存器

    if (status_reg & SYS_STATUS_RXFCG) // 如果接收到有效的消息
    {
        frame_len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFL_MASK_1023; // 获取帧长度
        if (frame_len <= FRAME_LEN_MAX)
        {
            dwt_readrxdata(rx_buffer, frame_len, 0); // 读取接收到的数据
            msg_f = (srd_msg_dsss*)rx_buffer; // 转换接收缓冲区为消息结构体
            msg_f_send.destAddr[0] = msg_f->sourceAddr[0]; // 复制源地址作为目的地址
            msg_f_send.destAddr[1] = msg_f->sourceAddr[1]; // 复制源地址作为目的地址
            msg_f_send.seqNum = msg_f->seqNum; // 复制序列号

            switch(msg_f->messageData[0]) // 根据消息类型进行处理
            {
                case 'P': // 处理轮询消息
                    msg_f_send.messageData[0]='A'; // 设置轮询应答消息
                    int temp = (int)(distance[msg_f_send.destAddr[0]]*100); // 将距离转换为厘米
                    msg_f_send.messageData[1]=temp/100;
                    msg_f_send.messageData[2]=temp%100;
                    dwt_writetxdata(14, (uint8 *)&msg_f_send, 0); // 写入帧数据
                    dwt_writetxfctrl(14, 0); // 设置帧控制
                    dwt_starttx(DWT_START_TX_IMMEDIATE); // 立即开始发送
                    while (!(dwt_read32bitreg(SYS_STATUS_ID) & SYS_STATUS_TXFRS)) { }; // 等待发送完成
                    poll_rx_ts = get_rx_timestamp_u64(); // 获取接收时间戳
                    break;

                case 'F': // 处理最终消息
                    /* 获取响应发送和最终接收的时间戳 */
                    resp_tx_ts = get_tx_timestamp_u64(); 
                    // 获取响应发送时间戳
                    final_rx_ts = get_rx_timestamp_u64(); 
                    // 获取最终接收时间戳

                    /* 从最终消息中获取嵌入的时间戳 */
                    final_msg_get_ts(&msg_f->messageData[FINAL_MSG_POLL_TX_TS_IDX], &poll_tx_ts); 
                    // 获取轮询发送时间戳
                    final_msg_get_ts(&msg_f->messageData[FINAL_MSG_RESP_RX_TS_IDX], &resp_rx_ts); 
                    // 获取响应接收时间戳
                    final_msg_get_ts(&msg_f->messageData[FINAL_MSG_FINAL_TX_TS_IDX], &final_tx_ts); 
                    // 获取最终发送时间戳

                    /* 计算飞行时间（ToF）。即使时钟发生了回绕，32位减法也能给出正确答案 */
                    poll_rx_ts_32 = (uint32)poll_rx_ts; // 将64位时间戳转换为32位
                    resp_tx_ts_32 = (uint32)resp_tx_ts; // 将64位时间戳转换为32位
                    final_rx_ts_32 = (uint32)final_rx_ts; // 将64位时间戳转换为32位
                    Ra = (double)(resp_rx_ts - poll_tx_ts); // 计算Ra值
                    Rb = (double)(final_rx_ts_32 - resp_tx_ts_32); // 计算Rb值
                    Da = (double)(final_tx_ts - resp_rx_ts); // 计算Da值
                    Db = (double)(resp_tx_ts_32 - poll_rx_ts_32); // 计算Db值
                    tof_dtu = (int64)((Ra * Rb - Da * Db) / (Ra + Rb + Da + Db)); // 计算飞行时间单位

                    tof = tof_dtu * DWT_TIME_UNITS; // 将飞行时间单位转换为实际时间
                    distance_temp = tof * SPEED_OF_LIGHT; // 根据飞行时间计算距离
                    distance[msg_f_send.destAddr[0]] = distance_temp - dwt_getrangebias(config.chan,(float)distance_temp, config.prf); // 减去矫正系数得到实际距离
                    #if 0 // 如果启用了卡尔曼滤波
                    distance[msg_f_send.destAddr[0]] =  KalMan(distance[msg_f_send.destAddr[0]]); // 应用卡尔曼滤波
                    #endif

                    #if 0 // 为了加快测距频率，基站尽量不要显示距离
                    {
                        sprintf(dist_str, "an0:%3.2fm     ", distance[msg_f_send.destAddr[0]]); // 格式化距离字符串
                        OLED_ShowString(0, 4, dist_str); // 在OLED显示屏上显示距离
                    }
                    #endif

                    break;

                case 'M': // 处理其他类型的消息
                    USART1WriteDataToBuffer(&msg_f->messageData[1],16); // 将数据发送到电脑
                    break;

                default:
                    break;
            }
        }
        dwt_write32bitreg(SYS_STATUS_ID, (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR)); // 重设系统状态
        dwt_enableframefilter(DWT_FF_DATA_EN); // 重新启用数据帧过滤功能
        dwt_setrxtimeout(0); // 重新设置接收超时
        dwt_rxenable(0); // 重新启用接收功能
    }
    else
    {
        dwt_write32bitreg(SYS_STATUS_ID, (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR)); // 清除错误标志
        dwt_enableframefilter(DWT_FF_DATA_EN); // 重新启用数据帧过滤功能
        dwt_rxenable(0); // 重新启用接收功能
    }
}


int rx_main(void)//接收函数
{
    OLED_ShowString(0,0,"   51UWB Node"); // 在OLED显示屏上显示“51UWB Node”
    OLED_ShowString(0,4,"  www.51uwb.cn"); // 在OLED显示屏上显示网址“www.51uwb.cn”
    OLED_ShowString(0,2,"    Rx Node "); // 在OLED显示屏上显示“Rx Node”，表明这是接收节点

	#if 0
    KalMan_Init(); // 初始化卡尔曼滤波器，当前被注释，不会执行
    #endif
    dwt_setrxtimeout(0); // 设置DW1000的接收超时时间为0，禁用接收超时
    dwt_enableframefilter(DWT_FF_DATA_EN); // 启用DW1000的数据帧过滤功能
    dwt_rxenable(0); // 启用DW1000的接收功能

    // 设置接收回调函数
    bphero_setcallbacks(Simple_Rx_Callback); // 当接收到数据时，调用Simple_Rx_Callback函数

    while (1) // 无限循环，等待接收数据
    {
    }
}


#ifdef  USE_FULL_ASSERT
/**
  * @brief  报告源文件名和发生assert_param错误的行号。
  * @param  file: 指向源文件名的指针
  * @param  line: assert_param错误行的行号
  * @retval None
  */
void assert_failed(uint8_t* file, uint32_t line)
{
    /* 用户可以添加自己的实现来报告文件名和行号,
       例如: printf("参数错误：文件 %s 在第 %d 行\r\n", file, line) */

    /* 无限循环 */
    while (1)
    {
    }
}
#endif

/**
  * @}
  */
/**
  * @}
  */
/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/

这段代码是一个基于STM32F10x微控制器和Decawave的DW1000 UWB (Ultra-Wideband) 模块的定位系统程序。代码的主要组成部分如下：

文件和作者信息

  • 这部分包含了文件的基本信息，例如文件名、作者、版本、日期和简要描述。

包含的头文件

  • 包括STM32F10x系列微控制器的头文件和其他必要的库，如Decawave的UWB API、寄存器定义、睡眠处理等。

定义和结构体

  • 定义了最大基站节点数 (MAX_ANTHOR_NODE) 和 distance_struct 结构体，用于存储与每个节点相关的距离信息和时间戳。

类型定义

  • 定义了64位整型变量 int64 和 uint64。

全局变量

  • 定义了一系列变量，用于处理UWB通信中的时间戳和距离计算。

Simple_Rx_Callback 函数

  • 这是一个回调函数，用于处理接收到的UWB消息。它读取状态寄存器，处理接收到的消息，并根据消息类型执行不同的操作，如处理距离测量和发送数据。

  • 这段代码是Simple_Rx_Callback函数的实现，它是UWB（超宽带）定位系统中用于处理接收到的消息的回调函数。下面详细解释这段代码：

    1. 初始化和读取状态：

      • uint32 status_reg = 0, i = 0;: 定义并初始化用于存储状态寄存器值的变量status_reg和循环变量i。
      • 初始化时间戳变量和其他所需的变量。
      • for (i = 0; i < FRAME_LEN_MAX; i++) { rx_buffer[i] = '\0'; }: 清空接收缓冲区。

    2. 启用帧过滤器：

      • dwt_enableframefilter(DWT_FF_RSVD_EN);: 启用帧过滤功能，但在这里它被设置为禁用接收。

    3. 读取并处理接收到的消息：

      • status_reg = dwt_read32bitreg(SYS_STATUS_ID);: 读取系统状态寄存器。
      • if (status_reg & SYS_STATUS_RXFCG) { ... }: 如果接收到了有效的消息，则进入此条件块。

    4. 处理接收到的帧：

      • 获取帧长度，读取接收到的数据，并根据接收到的消息类型执行不同的操作。
      • 操作包括处理轮询消息、最终消息，并根据消息类型计算飞行时间（ToF）。

    5. 计算飞行时间（ToF）并更新距离：

      • 使用DW1000的时间戳来计算ToF，进而计算出距离。

      • 如果启用了卡尔曼滤波，可以对距离值进行滤波处理。

      • 这段代码是从一个UWB（Ultra-Wideband）系统的接收回调函数中摘录的，主要用于计算从一个设备到另一个设备的飞行时间（ToF，Time of Flight），进而估计它们之间的距离。下面是对代码的详细解释：

        1. 获取时间戳：

          • resp_tx_ts = get_tx_timestamp_u64();：获取响应消息的发送时间戳。
          • final_rx_ts = get_rx_timestamp_u64();：获取最终接收的时间戳。

        2. 从接收到的消息中提取时间戳：

          • final_msg_get_ts(&msg_f->messageData[FINAL_MSG_POLL_TX_TS_IDX], &poll_tx_ts);：从消息中提取轮询消息的发送时间戳。
          • final_msg_get_ts(&msg_f->messageData[FINAL_MSG_RESP_RX_TS_IDX], &resp_rx_ts);：提取响应消息的接收时间戳。
          • final_msg_get_ts(&msg_f->messageData[FINAL_MSG_FINAL_TX_TS_IDX], &final_tx_ts);：提取最终消息的发送时间戳。

        3. 计算飞行时间（ToF）：

          • 时间戳转换：将64位的时间戳转换为32位，以便进行计算。
          • 计算四个关键值（Ra, Rb, Da, Db），这些值基于不同的时间戳差来计算。
          • tof_dtu = (int64)((Ra * Rb - Da * Db) / (Ra + Rb + Da + Db));：使用这四个值来计算飞行时间单位（ToF）。

        4. 计算距离：

          • tof = tof_dtu * DWT_TIME_UNITS;：将飞行时间单位转换为实际时间。
          • distance_temp = tof * SPEED_OF_LIGHT;：使用光速乘以飞行时间来计算距离。
          • distance[msg_f_send.destAddr[0]] = distance_temp - dwt_getrangebias(config.chan, (float)distance_temp, config.prf);：从计算出的距离中减去任何由硬件或配置引入的偏差。

        5. 可选的卡尔曼滤波：

          • 如果启用了卡尔曼滤波，使用KalMan函数进一步处理距离数据。

        6. 可选的显示距离：

          • 如果需要在OLED显示屏上显示距离，格式化距离字符串并显示。

        这段代码的关键在于精确计算飞行时间，这是UWB定位系统测距的核心。通过精确的时间戳测量和计算，可以估计出发射器和接收器之间的距离。可选的卡尔曼滤波和显示功能提供了额外的数据处理和用户界面支持。

      这段代码是一个条件编译语句，用于控制是否应用卡尔曼滤波器（Kalman Filter）来处理UWB定位系统中的距离数据。下面是对代码的详细解释以及如何启用卡尔曼滤波：

      代码解释

      1. 条件编译指令：
      • #if 0: 这是一个预处理指令，用于条件编译。当表达式的值为0时，编译器会忽略该块代码。在这个例子中，#if 0意味着紧随其后的代码不会被编译。
      1. 卡尔曼滤波应用：
      • distance[msg_f_send.destAddr[0]] = KalMan(distance[msg_f_send.destAddr[0]]);: 这行代码是将卡尔曼滤波应用于计算出的距离上。KalMan函数可能是实现卡尔曼滤波算法的函数，它接收原始距离作为输入，并返回经过滤波处理的距离。
      1. 结束条件编译：
      • #endif: 这标志着条件编译块的结束。

      如何启用卡尔曼滤波

      要启用这段代码中的卡尔曼滤波，需要更改预处理指令#if 0为#if 1或其他非零值。这样做将使得编译器编译并包含这段代码。更改后的代码如下：

      #if 1 // 启用卡尔曼滤波
distance[msg_f_send.destAddr[0]] = KalMan(distance[msg_f_send.destAddr[0]]);
#endif

      在进行此更改后，编译并运行程序时，卡尔曼滤波算法将被应用于处理距离数据。卡尔曼滤波是一种高效的算法，用于减少测量中的随机噪声，使得距离估计更加准确和稳定。它特别适合于处理动态系统中的数据，如跟踪移动的对象。

    6. 处理特定类型的消息：

      • 根据接收到的消息类型（如’P’, ‘F’, ‘M’）进行不同的处理。

    7. 重新启用接收：

      • 在消息处理完毕后，重新设置系统状态，启用帧过滤和接收功能，准备接收下一个消息。

    8. 错误处理：

      • 如果未接收到有效消息，则清除错误标志，并重新启用接收。

    总体来说，这个函数负责接收和处理来自其他UWB节点的消息，包括计算距离，处理不同类型的数据帧，以及更新系统状态以准备接收下一条消息。这是UWB定位系统中接收节点功能的核心部分。

rx_main 函数

  • 主要的接收函数。初始化OLED显示，设置超时，启用帧过滤器，然后进入一个无限循环等待接收消息。

  • 这段代码是rx_main函数的实现，它是一个用于超宽带（UWB）定位系统的接收节点（Rx Node）的主要函数。下面详细解释这段代码：

    1. OLED 显示初始化：

      • OLED_ShowString(0,0," 51UWB Node");: 在OLED显示屏上的第0行第0列位置显示字符串" 51UWB Node"。这可能是显示固定的标题或标识。
      • OLED_ShowString(0,4," www.51uwb.cn");: 在第4行显示网址" www.51uwb.cn"，可能是制造商或项目的网站。
      • OLED_ShowString(0,2," Rx Node ");: 在第2行显示" Rx Node "，表明这个节点是一个接收节点。

    2. 卡尔曼滤波初始化（如果启用）：

      • #if 0: 这是一个条件编译语句，当前设置为0，意味着下面的代码不会被编译。如果将0改为1或其他非0值，则下面的代码会被编译。
      • KalMan_Init();: 初始化卡尔曼滤波器。卡尔曼滤波是一种有效的算法，用于在存在噪声的情况下估计系统的状态。

    3. DW1000 UWB模块的设置：

      • dwt_setrxtimeout(0);: 设置DW1000模块的接收超时时间。这里设置为0表示禁用接收超时。
      • dwt_enableframefilter(DWT_FF_DATA_EN);: 启用帧过滤器。这里启用的是数据帧过滤，意味着模块将只处理数据帧。
      • dwt_rxenable(0);: 启用接收功能。参数0可能表示立即启动接收或某种默认配置。

    4. 设置接收回调函数：

      • bphero_setcallbacks(Simple_Rx_Callback);: 设置一个回调函数Simple_Rx_Callback，当接收到数据时，这个函数会被调用。

    5. 无限循环：

      • while (1) { }: 这是一个无限循环，使得程序持续运行并等待接收数据。在这个循环内部没有执行任何操作，实际的数据处理逻辑是在回调函数Simple_Rx_Callback中实现的。

    总体来说，这个函数设置了接收节点的初步配置，包括初始化显示屏，配置UWB模块，以及设置用于接收数据的回调函数。然后，它进入一个无限循环，等待并处理接收到的数据。

assert_failed 函数

  • 用于调试目的，当 USE_FULL_ASSERT 被定义时，报告源文件名和发生assert_param错误的行号。

文件结束注释

  • 表明文件属于STMicroelectronics的版权，以及文件结束的标记。

这个程序主要用于基于UWB技术的距离测量和定位。它通过处理来自UWB模块的信号，计算设备之间的时间差和距离。这对于需要精确定位的应用（如室内导航、资产跟踪）非常有用。程序中包含的不同部分是为了处理UWB信号、计算距离、显示信息以及处理错误情况。

tx_main.c

/**
  ******************************************************************************
  * @file    Project/STM32F10x_StdPeriph_Template/main.c
  * @author  MCD Application Team
  * @version V3.5.0
  * @date    08-April-2011
  * @brief   Main program body
  ******************************************************************************
  * @attention
  *
  * 本固件仅供指导之用，旨在为客户提供有关其产品的编码信息，以节省时间。
  * 因此，STMicroelectronics 对于任何由于本固件内容和/或客户使用此编码信息而产生的任何直接、
  * 间接或后果性损害不承担任何责任。
  *
  * 
© COPYRIGHT 2011 STMicroelectronics

  ******************************************************************************
  */

/* 包含的头文件 -----------------------------------------------------------*/
#include "stm32f10x.h" // 包含STM32F10x系列微控制器的头文件
#include  // 包含标准输入输出库
#include "deca_device_api.h" // 包含Decawave UWB设备的API定义
#include "deca_regs.h" // 包含Decawave设备的寄存器定义
#include "deca_sleep.h" // 包含Decawave设备的睡眠模式处理库
#include "port.h" // 包含与硬件端口相关的定义和函数
#include "frame_header.h" // 包含帧头文件
#include "common_header.h" // 包含公共头文件
#include "bphero_uwb.h" // 包含与该UWB系统特定功能相关的头文件
#include "dwm1000_timestamp.h" // 包含与DW1000时间戳相关的头文件

static unsigned char distance_seqnum = 0; // 距离测量的序列号

// 定义全局变量和类型
static srd_msg_dsss *msg_f_recv; // 定义接收消息的指针
typedef signed long long int64; // 定义64位有符号整型
typedef unsigned long long uint64; // 定义64位无符号整型
typedef unsigned int uint32; // 定义32位无符号整型

static uint64 poll_rx_ts; // 定义轮询接收时间戳
static uint64 resp_tx_ts; // 定义响应发送时间戳
static uint64 final_rx_ts; // 定义最终接收时间戳

static uint64 poll_tx_ts; // 定义轮询发送时间戳
static uint64 resp_rx_ts; // 定义响应接收时间戳
static uint64 final_tx_ts; // 定义最终发送时间戳

static void Send_Dis_To_Anthor1(void); // 发送距离信息到指定基站的函数

/************************!!!重要宏定义！！！******************************/
/****************多基站只需要修改MAX_ANTHOR即可***************************/
/*****************基站的地址必须是从0x0001 开始***************************/
#define MAX_ANTHOR 4 // 定义最大基站数量为4
#define SEPC_ADDRESS 0x0000  // 定义规0地址
#define DEST_BEGIN_ADDR 0x0001  // 定义基站起始地址
#define DEST_END_ADDR   DEST_BEGIN_ADDR + MAX_ANTHOR - 1 // 定义基站地址范围

int Final_Distance[MAX_ANTHOR] = {0}; // 存储从基站和标签之间的所有距离

char dist_str[16] = {0}; // 定义显示距离的字符串
unsigned long time_count = 0; // 定义时间计数器
unsigned long Tag_receive_poll = 0; // 标记是否接收到轮询
uint16 Dest_Address =  DEST_BEGIN_ADDR; // 定义目标地址

/* 私有函数 ---------------------------------------------------------*/
void Tx_Simple_Rx_Callback()
{
    uint32 status_reg = 0,i=0; // 定义状态寄存器和计数变量
    uint32 final_tx_time; // 定义最终传输时间

    dwt_enableframefilter(DWT_FF_RSVD_EN);//禁用接收
    status_reg = dwt_read32bitreg(SYS_STATUS_ID); // 读取系统状态寄存器

    if (status_reg & SYS_STATUS_RXFCG) // 检查是否成功接收到帧
    {
        /* 已收到帧，将其复制到本地缓冲区中。 */
        frame_len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFL_MASK_1023; // 读取帧长度
        if (frame_len <= FRAME_LEN_MAX) // 检查帧长度是否有效
        {
            dwt_readrxdata(rx_buffer, frame_len, 0); // 读取接收到的帧
            msg_f_recv = (srd_msg_dsss*)rx_buffer; // 转换接收缓冲区为消息格式
            msg_f_send.destAddr[0] = msg_f_recv->sourceAddr[0]; // 设置发送消息的目标地址
            msg_f_send.destAddr[1] = msg_f_recv->sourceAddr[1];
            msg_f_send.seqNum = msg_f_recv->seqNum; // 设置发送消息的序列号

            switch(msg_f_recv->messageData[0]) // 根据收到的消息类型进行处理
            {
                case 'A': // 收到轮询确认消息
                {
                    /* 检索轮询传输和响应接收时间戳。 */
                    resp_rx_ts = get_rx_timestamp_u64(); // 获取响应接收时间戳
                    final_tx_time =   dwt_readsystimestamphi32()  + 0x17cdc00/80; // 设置最终传输时间

                    dwt_setdelayedtrxtime(final_tx_time); // 设置延迟传输时间

                    /* 最终传输时间戳是我们编程的传输时间加上TX天线延迟。 */
                    final_tx_ts = (((uint64)(final_tx_time & 0xFFFFFFFE)) << 8); // 计算最终传输时间戳

                    msg_f_send.messageData[0]='F'; // 设置消息为最终消息
                    /* 在最终消息中写入所有时间戳。 */
                    final_msg_set_ts(&msg_f_send.messageData[FINAL_MSG_POLL_TX_TS_IDX], poll_tx_ts); // 设置轮询传输时间戳
                    final_msg_set_ts(&msg_f_send.messageData[FINAL_MSG_RESP_RX_TS_IDX], resp_rx_ts); // 设置响应接收时间戳
                    final_msg_set_ts(&msg_f_send.messageData[FINAL_MSG_FINAL_TX_TS_IDX], final_tx_ts); // 设置最终传输时间戳
                    dwt_writetxdata(25, (uint8 *)&msg_f_send, 0) ; // 写入帧数据
                    dwt_writetxfctrl(25, 0); // 设置传输控制
                    dwt_starttx(DWT_START_TX_DELAYED); // 开始延迟传输
                    // 计算并过滤最终距离
                    Final_Distance[(msg_f_send.destAddr[1]<<8)|msg_f_send.destAddr[0] - 1] = (msg_f_recv->messageData[1]*100 + msg_f_recv->messageData[2]); // 计算厘米单位的最终距离
                    Final_Distance[(msg_f_send.destAddr[1]<<8)|msg_f_send.destAddr[0] - 1] = filter(Final_Distance[(msg_f_send.destAddr[1]<<8)|msg_f_send.destAddr[0] - 1],\
                            (msg_f_send.destAddr[1]<<8)|msg_f_send.destAddr[0] - 1); // 过滤最终距离
                    while (!(dwt_read32bitreg(SYS_STATUS_ID) & SYS_STATUS_TXFRS))
                    { }; // 等待传输完成
                }
                break;
                default: // 默认情况不做处理
                    break;
            }
        }
    }
    else // 如果没有成功接收到帧
    {
        if(!(status_reg & SYS_STATUS_RXRFTO)) // 如果不是超时错误
            Tag_receive_poll = 1; // 设置为数据帧干扰
        dwt_write32bitreg(SYS_STATUS_ID, (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR|SYS_STATUS_TXFRS)); // 清除错误状态
    }
}

/************************标签发送数据给基站进行测距*****************************/
void BPhero_Distance_Measure_Specail_ANTHOR(void)
{
    msg_f_send.destAddr[0] = (Dest_Address) & 0xFF; // 设置消息的目标地址的低8位
    msg_f_send.destAddr[1] = ((Dest_Address) >> 8) & 0xFF; // 设置消息的目标地址的高8位

    msg_f_send.seqNum = distance_seqnum; // 设置消息的序列号
    msg_f_send.messageData[0] = 'P'; // 设置消息类型为轮询(Poll)消息

    dwt_writetxdata(12, (uint8 *)&msg_f_send, 0); // 将12字节的消息数据写入UWB模块
    dwt_writetxfctrl(12, 0); // 设置帧控制为12字节

    dwt_starttx(DWT_START_TX_IMMEDIATE); // 立即开始发送数据

    while (!(dwt_read32bitreg(SYS_STATUS_ID) & SYS_STATUS_TXFRS)) { }; // 等待直到消息发送完成

    dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG | SYS_STATUS_TXFRS); // 清除接收和发送完成标志
    poll_tx_ts = get_tx_timestamp_u64(); // 获取并保存轮询消息的发送时间戳

    for (int i = 0; i < FRAME_LEN_MAX; i++)
    {
        rx_buffer[i] = '\0'; // 清空接收缓冲区
    }

    dwt_enableframefilter(DWT_FF_DATA_EN); // 启用数据帧过滤
    dwt_setrxtimeout(RESP_RX_TIMEOUT_UUS * 10); // 设置接收超时时间
    dwt_rxenable(0); // 启用接收功能

    if (++distance_seqnum == 255)
        distance_seqnum = 0; // 序列号递增，达到255则重置为0
}


/************************************************************************/
/************************************************************************/
/************************标签发送数据给基站******************************/
/********************************BEGIN***********************************/
void TAG_SendOut_Messge(void)
{
    if(Dest_Address == SEPC_ADDRESS)
    {
        Send_Dis_To_Anthor1(); // 如果目标地址是特定地址，发送汇总距离信息到特定基站
    }
    else
    {
        BPhero_Distance_Measure_Specail_ANTHOR(); // 否则，与特定基站进行距离测量
    }
    Dest_Address++; // 递增目标地址，准备下一次通信

    if(Dest_Address == DEST_END_ADDR + 1)
    {
        Dest_Address = SEPC_ADDRESS; // 如果目标地址超过最后一个基站地址，重置为特定地址
    }
}


/************************使用定时器周期性启动测距************************/
/*********************************END***********************************/
void TIM3_Int_Init_timeout(u16 arr)// 初始化TIM3作为定时器，用于超时中断
{
    TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure; // 定义时基结构体
    NVIC_InitTypeDef NVIC_InitStructure; // 定义NVIC初始化结构体
    TIM_Cmd(TIM3, DISABLE);  // 关闭TIM3以进行设置
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); // 使能TIM3的时钟

    arr = arr*10-1; // 根据参数计算自动重载值
    TIM_TimeBaseStructure.TIM_Period = arr; // 设置自动重载寄存器周期的值
    TIM_TimeBaseStructure.TIM_Prescaler = 7199; // 设置预分频值，决定计时速度
    TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; // 设置时钟分割，这里不分割
    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  // 设置为向上计数模式
    TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); // 根据指定的参数初始化TIM3的时间基础设置

    TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE ); // 使能TIM3的更新中断
    NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;  // 设置NVIC中断通道为TIM3中断
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  // 设置抢占优先级为0
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 5;  // 设置子优先级为5
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; // 使能中断通道
    NVIC_Init(&NVIC_InitStructure);  // 根据设定初始化NVIC

    TIM_Cmd(TIM3, ENABLE);  // 最后，使能TIM3开始计时
}


void TIM3_IRQHandler(void)   // TIM3定时器的中断服务函数
{
    if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)  // 检查TIM3更新中断是否发生
    {
        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);  // 清除TIM3更新中断标志，准备下一次中断
        if( Tag_receive_poll ==  0) // 检查标志位，确定是否存在数据冲突
        {
            dwt_forcetrxoff();  // 强制关闭接收/发送功能，准备发送新的数据
            // 清除上次所有标志（代码被注释掉了）
            // dwt_write32bitreg(SYS_STATUS_ID, (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR|SYS_STATUS_TXFRS));
            TAG_SendOut_Messge();  // 发送定位信息
            if(Dest_Address == DEST_BEGIN_ADDR)
            {
                // 如果目的地址是起始地址，则执行特定操作（当前为空）
            }
            time_count = portGetTickCnt();  // 更新时间计数
            TIM3->ARR = TIM3_ReLoad;  // 重新设置定时器的自动重载值，准备下一次定时
        }
        else // 如果存在数据冲突
        {
            TIM3->ARR = TIM3_Delay_Step*((SHORT_ADDR%10)+1);  // 设置一个基于短地址的随机延时值，用于动态避让
            Tag_receive_poll = 0;  // 重置数据冲突标志位
        }
        TIM_Cmd(TIM3, ENABLE);  // 重新启用TIM3，继续计数直到下一次中断
    }
}


/************************使用定LCD 显示调试距离信息***********************/
/*********************调试完毕关闭LCD显示提高刷新频率*********************/
/********************************BEGIN***********************************/
static void LCD_Display_Distance(void)  // 定义一个静态函数，用于在LCD显示距离信息
{
    char dist_str[16] = {0};  // 定义一个字符数组用于存储距离字符串

    if(Final_Distance[0]>0)  // 如果第一个距离值大于0
    {
        sprintf(dist_str, "an1:%3.2fm      ", (float)Final_Distance[0]/100);  // 格式化第一个距离值为字符串
        OLED_ShowString(0, 2,dist_str);  // 在OLED上第2行显示第一个距离
    }
    
    if(Final_Distance[1]>0)  // 如果第二个距离值大于0
    {
        sprintf(dist_str, "an2:%3.2fm      ", (float)Final_Distance[1]/100);  // 格式化第二个距离值为字符串
        OLED_ShowString(0, 4,dist_str);  // 在OLED上第4行显示第二个距离
    }
    
    if(Final_Distance[2]>0)  // 如果第三个距离值大于0
    {
        sprintf(dist_str, "an3:%3.2fm      ", (float)Final_Distance[2]/100);  // 格式化第三个距离值为字符串
        OLED_ShowString(0, 6,dist_str);  // 在OLED上第6行显示第三个距离
    }
}


static void Send_Dis_To_Anthor1(void)
{
    static int framenum = 0 ; // 初始化静态变量framenum用于追踪消息帧数

    // 以下设置消息的目的地址为0x0001
    msg_f_send.destAddr[0] =(0x0001) &0xFF; // 目标地址的低8位
    msg_f_send.destAddr[1] =  ((0x0001)>>8) &0xFF; // 目标地址的高8位

    msg_f_send.seqNum = distance_seqnum; // 设置消息的序列号

#if 0 // 计算智能车的角度部分，当前被注释掉
    // 部分跟随小车代码，计算角度
    float dis3_constans = DISTANCE3;
    float cos = 0;
    float angle = 0 ;
    float dis1 = (float)Final_Distance[0]/100; // 将距离1转换为米
    float dis2 = (float)Final_Distance[1]/100;  // 将距离2转换为米

    if(dis1 + dis3_constans < dis2 || dis2+dis3_constans < dis1)
    {
    }
    cos = (dis1*dis1 + dis3_constans* dis3_constans - dis2*dis2)/(2*dis1*dis3_constans);
    angle  = acos(cos)*180/3.1415926;
    sprintf(dist_str, "angle: %3.2f m", angle); // 将角度转换为字符串
    OLED_ShowString(0, 6,"			  "); // 清除显示
    OLED_ShowString(0, 6,dist_str); // 显示角度

    if(dis1 > 1)
    {
        if(angle > 110)
        {
            printf("turn right\r\n"); // 角度大于110度时向右转
        }
        else if(angle < 75)
        {
            printf("turn left\r\n"); // 角度小于75度时向左转
        }
        else
        {
            printf("forward\r\n"); // 角度在这两者之间时直行
        }
    }
    else
    {
        printf("stay here\r\n"); // 距离太近时停在原地
    }
#else
    // 将距离信息整个发送到地址为0x0001的基站，数据包以‘M’标记
    msg_f_send.messageData[0]='M'; // 数据包的开始标记'M'
    {
        uint8 len = 0; // 定义长度变量
        uint8 LOCATION_INFO_START_IDX = 1; // 位置信息的起始索引
        msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = 'm'; // 加入位置信息标记为'm'
        msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = 'r'; // 加入位置信息标记为'r'
        msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = 0x02; // 加入位置信息，指定格式或者类型标识为0x02
        msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = SHORT_ADDR;// 将TAG ID加入消息数据

        msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = (uint8)(framenum&0xFF); // 加入帧号的低8位
        msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = (uint8)((framenum>>8)&0xFF); // 加入帧号的高8位

        // 加入距离信息，将每个距离分成两个字节进行发送
        msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = (uint8)((Final_Distance[0]>0?Final_Distance[0]:0xFFFF)&0xFF); // 加入第一个距离的低8位
        msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = (uint8)(((Final_Distance[0]>0?Final_Distance[0]:0xFFFF) >>8)&0xFF); // 加入第一个距离的高8位

        msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = (uint8)((Final_Distance[1]>0?Final_Distance[1]:0xFFFF)&0xFF); // 加入第二个距离的低8位
        msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = (uint8)(((Final_Distance[1]>0?Final_Distance[1]:0xFFFF) >>8)&0xFF); // 加入第二个距离的高8位

        msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = (uint8)((Final_Distance[2]>0?Final_Distance[2]:0xFFFF)&0xFF); // 加入第三个距离的低8位
        msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = (uint8)(((Final_Distance[2]>0?Final_Distance[2]:0xFFFF) >>8)&0xFF); // 加入第三个距离的高8位


        // 如果有超过3个基站，则包括第四个距离信息
        if(MAX_ANTHOR > 3)
        {
            msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = (uint8)((Final_Distance[MAX_ANTHOR-1]>0?Final_Distance[MAX_ANTHOR-1]:0xFFFF)&0xFF);
            msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = (uint8)(((Final_Distance[MAX_ANTHOR-1]>0?Final_Distance[MAX_ANTHOR-1]:0xFFFF) >>8)&0xFF);
        }
        else
        {
            msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = (uint8)((Final_Distance[0]>0?Final_Distance[0]:0xFFFF)&0xFF);
            msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = (uint8)(((Final_Distance[0]>0?Final_Distance[0]:0xFFFF) >>8)&0xFF);
        }

        msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = '\n'; // 加入换行符
        msg_f_send.messageData[LOCATION_INFO_START_IDX + (len++)] = '\r'; // 加入回车符
    }
#endif

    // 发送数据
    dwt_writetxdata(11 + 17,(uint8 *)&msg_f_send, 0) ;  // 写入帧数据
    dwt_writetxfctrl(11 + 17, 0); // 设置传输控制
    dwt_starttx(DWT_START_TX_IMMEDIATE); // 立即开始传输
    while (!(dwt_read32bitreg(SYS_STATUS_ID) & SYS_STATUS_TXFRS))
    { }; // 等待传输完成
    framenum++; // 增加帧数
    LCD_Display_Distance(); // 显示距离信息
}



int tx_main(void)  // 定义tx_main函数，作为主要的发送端程序
{
    OLED_ShowString(0,0,"   51UWB Node"); // 在OLED第0行显示“51UWB Node”，作为设备标题
    sprintf(dist_str, "    Tx Node"); // 将“Tx Node”字符串格式化到dist_str变量中，表示这是一个发送节点
    OLED_ShowString(0,2,dist_str); // 在OLED第2行显示dist_str变量的内容，即“Tx Node”
    OLED_ShowString(0,6,"  www.51uwb.cn"); // 在OLED第6行显示网址“www.51uwb.cn”，可能是产品或公司的网址

    bphero_setcallbacks(Tx_Simple_Rx_Callback); // 设置回调函数为Tx_Simple_Rx_Callback，用于处理接收数据
    dwt_forcetrxoff();  // 强制关闭无线传输的接收和发送功能，准备新的传输任务

    // 定时周期性发送数据
    TIM3_Int_Init_timeout(TIM3_ReLoad); // 初始化TIM3定时器，设置定时周期为TIM3_ReLoad

    while(1) // 进入无限循环
    {
        // 循环体为空，通常意味着程序的主要功能在中断或回调函数中实现
    }
}




#ifdef  USE_FULL_ASSERT
void assert_failed(uint8_t* file, uint32_t line)
{
    // 断言失败处理函数
    // 以下是报告文件名和行号的代码...
    while (1)
    {
    }
}
#endif

/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/

这段代码是一个较为完整的主程序，用于基于STM32F10x微控制器和Decawave UWB（Ultra-Wideband）模块的定位系统。程序的主要功能是通过UWB技术进行距离测量和定位。下面是对代码的详细解释：

代码结构和功能

  1. 文件和作者信息：

    • 代码开头的注释部分包含文件描述、作者、版本、日期以及版权信息。

  2. 包含的头文件：

    • #include 指令包含了所需的头文件，如STM32F10x的库文件和Decawave UWB模块的API。

  3. 全局变量和类型定义：

    • 定义了用于存储时间戳、距离等信息的变量。
    • 定义了有符号和无符号的64位整数类型，以及32位的无符号整数类型。

  4. 宏定义：

    • MAX_ANTHOR 定义了基站的最大数量，以及与之相关的地址范围。

  5. 距离测量相关的函数：

    • Tx_Simple_Rx_Callback：接收回调函数，处理接收到的UWB消息并计算距离。

      这段代码是Tx_Simple_Rx_Callback函数的实现，用于处理超宽带（UWB）定位系统中发送节点接收到的消息。函数主要处理接收到的UWB消息，计算时间戳，以及发送回复消息。下面是对代码的详细解释：

      代码解释

      1. 初始化变量：
      • uint32 status_reg = 0, i = 0;：定义并初始化用于存储状态寄存器的变量status_reg和循环计数器i。
      • uint32 final_tx_time;：定义用于存储最终发送时间的变量。
      1. 禁用接收并读取状态：
      • dwt_enableframefilter(DWT_FF_RSVD_EN);：禁用接收功能，启用帧过滤。
      • status_reg = dwt_read32bitreg(SYS_STATUS_ID);：读取并存储系统状态寄存器的值。
      1. 处理接收到的帧：
      • if (status_reg & SYS_STATUS_RXFCG)：检查是否成功接收到帧（RXFCG标志）。
      • 获取帧长度并从UWB模块的接收缓冲区读取数据。
      1. 解析接收到的消息并发送响应：
      • switch(msg_f_recv->messageData[0])：根据接收到的消息类型进行不同的处理。
      • 对于'A'（轮询应答消息）类型的消息，执行以下操作：
        • 获取响应接收时间戳。
        • 计算并设置最终消息的发送时间。
        • 设置最终发送时间戳。
        • 准备并发送最终消息。
        • 计算并保存距离信息。
        • 使用滤波器处理距离数据。
        • 等待直到消息发送完成。
      1. 处理错误和超时：
      • 如果未接收到有效消息并且不是因为超时，设置Tag_receive_poll标志表示可能的数据帧干扰。
      • 清除系统状态寄存器的相关标志，准备接收下一个消息。

      总结

      这个函数是UWB系统中发送节点的关键部分，负责接收来自其他节点的消息，根据这些消息计算时间戳，进而估算距离。它还处理了发送响应消息的逻辑，以及对接收到的数据进行滤波处理，以提高距离测量的准确性。此外，函数还包含了处理潜在的通信干扰和错误的逻辑。

    • BPhero_Distance_Measure_Specail_ANTHOR：用于与特定基站进行距离测量。

      这段代码是BPhero_Distance_Measure_Specail_ANTHOR函数的实现，它是超宽带（UWB）定位系统中用于与特定基站进行距离测量的函数。下面是对代码的详细解释：

      代码解释

      1. 设置目标地址：
      • msg_f_send.destAddr[0] = (Dest_Address) & 0xFF;
      • msg_f_send.destAddr[1] = ((Dest_Address) >> 8) & 0xFF;：这两行代码设置消息的目标地址。Dest_Address变量表示目标基站的地址，它被分解为两个字节。
      1. 配置消息内容：
      • msg_f_send.seqNum = distance_seqnum;：设置消息的序列号。
      • msg_f_send.messageData[0] = 'P';：设置消息类型为’P’，代表轮询消息。
      1. 发送消息：
      • dwt_writetxdata(12, (uint8 *)&msg_f_send, 0);：写入帧数据到UWB模块。
      • dwt_writetxfctrl(12, 0);：设置帧控制。
      • dwt_starttx(DWT_START_TX_IMMEDIATE);：立即开始发送数据。
      • 循环等待直到消息发送完成。
      1. 准备接收响应：
      • poll_tx_ts = get_tx_timestamp_u64();：获取并保存轮询消息的发送时间戳。
      • 清空接收缓冲区。
      • dwt_enableframefilter(DWT_FF_DATA_EN);：启用数据帧过滤。
      • dwt_setrxtimeout(RESP_RX_TIMEOUT_UUS * 10);：设置接收超时。
      • dwt_rxenable(0);：启用接收功能。
      1. 更新序列号：
      • if (++distance_seqnum == 255) distance_seqnum = 0;：递增序列号，如果达到255则重置为0。

      总结

      这个函数是UWB系统中的关键部分，负责向特定基站发送轮询消息，用于测量从发送节点到该基站的距离。它设置了目标基站的地址，配置了消息内容，发送轮询消息，并准备接收响应。该函数还处理了序列号的更新和接收超时的设置，确保了系统的连续性和稳定性。

    • TAG_SendOut_Messge：用于发送消息到基站进行距离测量。

      这段代码是TAG_SendOut_Messge函数的实现，用于超宽带（UWB）定位系统中标签节点向基站发送信息。该函数根据当前的目标地址决定是发送汇总的距离信息到特定基站还是与特定基站进行距离测量。下面是对代码的详细解释：

      代码解释

      1. 判断目标地址：
      • if (Dest_Address == SEPC_ADDRESS) { ... } else { ... }：这里检查当前的目标地址Dest_Address是否等于特定的地址（SEPC_ADDRESS）。这个特定地址用于控制是否向一个特定基站发送距离汇总信息。
      1. 发送距离汇总信息或进行距离测量：
      • Send_Dis_To_Anthor1();：如果目标地址是特定地址，则调用Send_Dis_To_Anthor1函数，该函数负责将汇总的距离信息发送到特定基站。
      • BPhero_Distance_Measure_Specail_ANTHOR();：如果目标地址不是特定地址，则调用BPhero_Distance_Measure_Specail_ANTHOR函数，与特定基站进行距离测量。
      1. 更新目标地址：
      • Dest_Address++;：递增目标地址，以便下次发送消息到下一个基站。
      • if (Dest_Address == DEST_END_ADDR + 1) { Dest_Address = SEPC_ADDRESS; }：如果目标地址超过了最后一个基站的地址，就将其重置为特定地址（SEPC_ADDRESS）。这样可以确保标签节点轮流与所有基站通信。

      总结

      这个函数是UWB定位系统中标签节点的关键部分，负责管理与不同基站的通信。它根据当前目标地址决定是发送汇总的距离信息还是进行距离测量，并在所有基站间循环发送消息。这种机制允许系统有效地从多个基站收集距离数据，用于后续的定位计算。

  6. 定时器初始化和中断处理函数：

    • TIM3_Int_Init_timeout 和 TIM3_IRQHandler 用于定时发送距离测量请求。

      这段代码是用于初始化STM32微控制器中的定时器3（TIM3）的函数，主要用于设置定时器的基础配置，并使其能够在指定的时间后产生中断。以下是该函数逐行解释：

      函数定义

      • void TIM3_Int_Init_timeout(u16 arr): 这是一个名为TIM3_Int_Init_timeout的函数，它接受一个名为arr的参数，这个参数与定时器超时时间有关。

      函数内部代码

      1. 变量声明:
      • TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;: 声明一个时基配置结构体。
      • NVIC_InitTypeDef NVIC_InitStructure;: 声明一个嵌套向量中断控制器（NVIC）配置结构体。
      1. 禁用定时器:
      • TIM_Cmd(TIM3, DISABLE);: 在配置之前先禁用TIM3。
      1. 时钟使能:
      • RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);: 使能TIM3的时钟。在STM32中，外设如定时器都需要手动开启时钟才能工作。
      1. 设置计时周期:
      • arr = arr*10-1;: 根据传入的参数计算自动重装载寄存器的值。这里将时间乘以10（可能是根据时钟频率和需要的时间分辨率来设定的）。
      • TIM_TimeBaseStructure.TIM_Period = arr;: 设置定时器的周期，即何时产生一个更新或中断事件。
      • TIM_TimeBaseStructure.TIM_Prescaler = 7199;: 设置预分频器的值。这里的值与时钟频率相关，用于确定定时器的计时频率。
      • TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;: 设置时钟分割。这里设置为不分割。
      • TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;: 设置为向上计数模式。
      1. 初始化定时器:
      • TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);: 用前面设置的参数初始化TIM3的时间基础。
      1. 中断配置:
      • TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE );: 使能TIM3的更新中断（当计时器溢出更新时发生）。
      • NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;: 指定TIM3中断。
      • NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;: 设置中断的抢占优先级为0。
      • NVIC_InitStructure.NVIC_IRQChannelSubPriority = 5;: 设置中断的子优先级为5。
      • NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;: 使能中断通道。
      • NVIC_Init(&NVIC_InitStructure);: 根据指定的参数初始化NVIC寄存器。
      1. 使能定时器:
      • TIM_Cmd(TIM3, ENABLE);: 最后使能TIM3，开始计时。

      总结

      这个函数通过配置STM32的定时器3来实现在给定的时间后产生一个中断的功能。它详细设置了定时器的工作周期、频率、计数模式，以及中断的优先级和使能，最终通过启用定时器来开始计时。这种类型的功能在需要精确计时的嵌入式系统应用中十分常见，比如定时采样、定时响应等。

      这段代码是STM32微控制器中TIM3定时器的中断处理函数。它主要用于在定时器达到预设时间时执行特定的任务。以下是该函数逐行的详细解释：

      函数定义

      • void TIM3_IRQHandler(void): 这是TIM3定时器的中断处理函数。

      函数内部代码

      1. 中断事件检查:
      • if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET): 这行代码检查TIM3的更新中断是否发生。如果发生，表示定时器计数到达了预设值。
      1. 清除中断标志:
      • TIM_ClearITPendingBit(TIM3, TIM_IT_Update);: 如果检测到更新中断，该行代码将清除TIM3更新中断标志，以便于定时器可以继续工作而不会被之前的中断影响。
      1. 根据标志位发送信息或进行延时:

      • if( Tag_receive_poll == 0): 检查标志位Tag_receive_poll，如果为0，表示没有数据冲突，可以进行正常的定位信息发送。

        • dwt_forcetrxoff();: 强制关闭接收和发送，准备发送新的消息。
        • TAG_SendOut_Messge();: 调用函数发送定位消息。
        • if(Dest_Address == DEST_BEGIN_ADDR){}: 一个空的条件语句，可能是预留给特定地址处理的代码。
        • time_count = portGetTickCnt();: 更新时间计数，可能用于下次发送或延时。
        • TIM3->ARR = TIM3_ReLoad;: 重新加载定时器的计数值，准备下一次中断。

      • else: 如果Tag_receive_poll不为0，表示存在数据冲突。

        • TIM3->ARR = TIM3_Delay_Step*((SHORT_ADDR%10)+1);: 设置定时器的计数值为一个基于设备地址的随机延时，作为动态避让机制。
        • Tag_receive_poll = 0;: 重置标志位，为下一次中断准备。
      1. 重新启动定时器:
      • TIM_Cmd(TIM3, ENABLE);: 再次启用TIM3，继续计数直到下一次中断。

      总结

      这个中断处理函数用于处理定时器的更新事件。它根据是否存在数据冲突来决定是立即发送定位信息还是延时发送以避免冲突。此函数的操作确保了定时器能够在特定的时间点触发发送定位信息或进行必要的延时，以优化通信和避免可能的数据干扰。

  7. LCD显示和距离信息发送：

    • LCD_Display_Distance 函数用于在LCD显示屏上显示距离信息。

      这段代码定义了一个函数LCD_Display_Distance，它的作用是在LCD屏幕上显示距离信息。以下是逐行解释：

      函数定义

      • static void LCD_Display_Distance(void): 定义一个静态函数，仅在声明它的文件内部可见，用于显示距离信息。

      函数内部代码

      1. 变量声明:
      • char dist_str[16] = {0};: 定义一个字符数组dist_str用于存储将要显示的距离字符串，初始化所有元素为0。
      1. 显示第一个距离（an1）:
      • if(Final_Distance[0]>0): 如果数组Final_Distance的第一个元素（表示第一个距离）大于0，则执行以下代码。
        • sprintf(dist_str, "an1:%3.2fm ", (float)Final_Distance[0]/100);: 使用sprintf将第一个距离格式化为字符串并存储在dist_str中。距离转换为米单位（假设Final_Distance中的值以厘米为单位）。
        • OLED_ShowString(0, 2,dist_str);: 调用OLED_ShowString函数在OLED屏幕的指定位置（第0列，第2行）显示距离字符串。
      1. 显示第二个距离（an2）:
      • if(Final_Distance[1]>0): 如果数组Final_Distance的第二个元素（表示第二个距离）大于0，则执行以下代码。
        • sprintf(dist_str, "an2:%3.2fm ", (float)Final_Distance[1]/100);: 格式化第二个距离并存储在dist_str中。
        • OLED_ShowString(0, 4,dist_str);: 显示第二个距离字符串在OLED屏幕的第0列，第4行。
      1. 显示第三个距离（an3）:
      • if(Final_Distance[2]>0): 如果数组Final_Distance的第三个元素（表示第三个距离）大于0，则执行以下代码。
        • sprintf(dist_str, "an3:%3.2fm ", (float)Final_Distance[2]/100);: 格式化第三个距离并存储在dist_str中。
        • OLED_ShowString(0, 6,dist_str);: 显示第三个距离字符串在OLED屏幕的第0列，第6行。

      总结

      这个函数用于显示三个不同的距离值（如果它们大于0）在OLED屏幕上，每个距离值显示在不同的行上。它使用sprintf函数来格式化距离值为字符串，并调用OLED_ShowString来在OLED上显示这些字符串。这种显示功能通常用于实时更新和监控距离信息，如在定位系统或距离感测设备中。

    • Send_Dis_To_Anthor1 用于将距离信息发送到特定的基站。

      这段代码看起来是一个更大程序的一部分，很可能用于无线通信或涉及智能车或机器人的跟踪系统。它用C语言编写，涉及发送和处理位置或移动指令的数据包。以下是代码不同部分的详细解释：

      函数概览

      • 函数名称： Send_Dis_To_Anthor1
      • 目的： 这个函数似乎负责向另一个设备或基站发送距离或位置数据。

      变量初始化

      • static int framenum = 0;：初始化了一个静态变量 framenum，它可能用于跟踪发送的帧数或消息数。作为静态变量，它在函数调用之间保持其值不变。

      设置目标地址

      • 代码设置了消息（msg_f_send.destAddr）的目的地址为 0x0001，将16位地址分成两个8位部分，并存储在数组中。

      序列号

      • 它将 distance_seqnum 分配给 msg_f_send.seqNum，这可能是用于跟踪消息的序列号。

      角度计算块（被注释）

      • 用 #if 0 包围的这部分代码当前不活跃。如果它被激活，它将根据距离（dis1、dis2 和一个常数 dis3_constans）使用三角函数计算角度。这个计算看来是为了决定智能车或类似设备转向或移向的方向。
      • 它使用 acos 函数来确定角度，然后根据这个角度做出决策（例如，向右转、向左转、前进或停留）。
      • 这部分还包括使用角度信息更新OLED显示。

      活动数据包准备块

      • 条件编译的另一部分（#else 块）准备了一个用于发送的数据包。它以 ‘M’ 标记，并包含一系列可能与位置或距离有关的测量和标识符。
      • 它包括帧号、标签ID和距离（Final_Distance[0] 到 Final_Distance[2]，如果 MAX_ANTHOR > 3 则条件性地包括第四个距离）。
      • 距离作为16位值发送，分成两个8位块。
      • 以换行符和回车符结束消息，这通常用来表示文本或消息的行结束。

      发送数据

      • 调用 dwt_writetxdata 和 dwt_writetxfctrl 分别设置传输数据和控制，然后调用 dwt_starttx 启动传输。
      • 代码在循环中等待，直到传输完成，通过检查系统状态寄存器的 SYS_STATUS_TXFRS 标志来判断。

      传输后

      • framenum++：发送包后帧数增加，为下一条消息做准备。
      • LCD_Display_Distance()：在最后调用这个函数，可能是为了更新LCD显示最新的距离或状态信息，虽然这个函数的具体内容没有包括在内。

      注释和观察

      • 代码看起来是实时定位系统（RTLS）相关的一部分，可能涉及UWB（超宽带）标签用于跟踪和导航。
      • 使用 #if 0 是在开发或调试期间轻松切换代码块的一种方式。它通常不用于生产代码。
      • 错误处理、距离验证或如果传输失败会发生什么在这个代码片段中不明显。这些方面对于现实世界应用的健壮性至关重要。
      • 代码注释混合使用英文和看似中文，表明它可能是双语开发环境或团队的一部分。

      这段代码是特定应用的专门部分，要完全理解其上下文需要更多关于它所针对的硬件和系统架构的细节。

  8. 主函数 tx_main：

    • 初始化OLED显示屏。

    • 设置回调函数。

    • 使用定时器周期性地发送距离测量请求。

      这段代码定义了一个名为tx_main的函数，看起来是用于初始化一个无线传输节点，并设置其显示和传输行为。以下是逐行的详细解释：

      函数定义

      • int tx_main(void): 定义了一个名为tx_main的函数，返回类型为int。

      函数内部代码

      1. OLED显示初始化信息:
      • OLED_ShowString(0,0," 51UWB Node");: 在OLED显示屏的第0行第0列位置显示字符串" 51UWB Node"，这似乎是设备的名称或标题。
      • sprintf(dist_str, " Tx Node");: 使用sprintf函数将字符串" Tx Node"格式化到dist_str变量中，表示这个设备是一个发送节点。
      • OLED_ShowString(0,2,dist_str);: 在OLED显示屏的第2行显示dist_str的内容，即" Tx Node"。
      • OLED_ShowString(0,6," www.51uwb.cn");: 在OLED显示屏的第6行显示网址" www.51uwb.cn"，可能是设备的官方网站或相关信息。
      1. 设置回调函数和关闭无线传输:
      • bphero_setcallbacks(Tx_Simple_Rx_Callback);: 设置无线传输的回调函数为Tx_Simple_Rx_Callback，这通常用于处理接收到的数据或状态更改。
      • dwt_forcetrxoff();: 强制关闭无线设备的接收和发送功能，准备开始新的发送任务。
      1. 初始化定时器并进入发送循环:
      • TIM3_Int_Init_timeout(TIM3_ReLoad);: 调用TIM3_Int_Init_timeout函数初始化TIM3定时器，TIM3_ReLoad可能是一个定义好的重装载值，用于设定定时器的超时时间。
      • while(1){}: 一个空的无限循环，表示主要的工作可能在中断或回调函数中完成，这里保持程序不退出等待事件。

      总结

      tx_main函数是一个无线传输节点的主要初始化和运行函数。它首先在OLED显示屏上显示节点的信息和状态，然后设置数据接收时的回调处理，并关闭当前的无线传输以准备新的传输任务。随后，它初始化一个定时器用于周期性地发送数据，最后进入一个等待状态，等待定时器中断或接收数据。这样的设计模式在嵌入式系统和无线节点中很常见，特别是在需要周期性或按需发送数据的应用中。

  9. 断言失败处理：

    • assert_failed 函数提供了一种调试机制，用于报告断言失败的详细信息。

总结

这个程序是一个UWB基于时间测距（TDoA，Time Difference of Arrival）的定位系统的示例。它涉及发送UWB信号、接收响应、计算飞行时间（ToF）和距离，以及处理和显示这些数据。通过对多个基站的测距，可以实现2D或3D定位。程序还包含了周期性发送测距请求的逻辑，以及可选的LCD显示功能。

bphero_uwb.h

#ifndef BPHERO_UWB_H  // 防止头文件重复引用
#define BPHERO_UWB_H

#include "frame_header.h"  // 包含帧头定义
#include "common_header.h"  // 包含通用头文件定义

// 定义设备角色为基站或标签
#define RX_NODE   // 定义为基站
//#define TX_NODE // 定义为标签，当前被注释

// 基站地址配置，地址从0x0001开始
#ifdef RX_NODE
	#define SHORT_ADDR 0x0001  // 为基站设置短地址
//#define LCD_ENABLE // 如果有LCD显示，则定义此宏，没有则注释
#endif

// 标签地址配置，确保与基站地址不重叠
#ifdef TX_NODE
	#define SHORT_ADDR 0x0005  // 为标签设置短地址
	#define LCD_ENABLE // 如果有LCD显示，则定义此宏，没有则注释
#endif

// 外部变量声明
extern int psduLength ;
extern srd_msg_dsss msg_f_send ; // 定义16位地址的ranging消息帧

// 常量定义
#ifndef SPEED_OF_LIGHT
#define SPEED_OF_LIGHT      (299702547.0)     // 空气中的光速，单位m/s
#endif

/* 接收帧的最大长度 */
#ifndef FRAME_LEN_MAX
#define FRAME_LEN_MAX 127
#endif

/* 天线延迟相关常量定义 */
#ifndef TX_ANT_DLY
#define TX_ANT_DLY 0
#endif

#ifndef RX_ANT_DLY
#define RX_ANT_DLY 32950
#endif

/* 时间戳相关常量定义 */
#define FINAL_MSG_POLL_TX_TS_IDX 2
#define FINAL_MSG_RESP_RX_TS_IDX 6
#define FINAL_MSG_FINAL_TX_TS_IDX 10
#define FINAL_MSG_TS_LEN 4

/* 微秒（uus）到设备时间单元（dtu）转换因子定义 */
#define UUS_TO_DWT_TIME 65536

/* 帧间延迟定义 */
#define POLL_RX_TO_RESP_TX_DLY_UUS 2600
#define RESP_TX_TO_FINAL_RX_DLY_UUS 500
#define FINAL_RX_TIMEOUT_UUS 3300
#define POLL_TX_TO_RESP_RX_DLY_UUS 150
#define RESP_RX_TO_FINAL_TX_DLY_UUS 3000 //2700将会失败
#define RESP_RX_TIMEOUT_UUS 2700

// 全局变量声明
extern uint8 rx_buffer[FRAME_LEN_MAX];  // 接收缓冲区
extern uint16 frame_len ;  // 接收到的帧的长度
extern void BPhero_UWB_Message_Init(void);  // UWB消息初始化函数声明
extern void BPhero_UWB_Init(void);  // UWB设备初始化函数声明

#endif // BPHERO_UWB_H 结束头文件保护

这段代码是一个C语言的头文件（通常以.h结尾），名为bphero_uwb.h。它是为UWB（超宽带）应用编写的，提供了一系列的宏定义、变量声明和函数原型，用于配置和操作UWB设备。以下是对该头文件中各部分的详细解释：

头文件保护

  • #ifndef BPHERO_UWB_H 到 #endif: 这是一个常见的C语言技巧，用于防止头文件内容被重复包含。如果BPHERO_UWB_H未定义，则定义它，并包含整个文件内容，否则跳过内容。

包含的其他头文件

  • #include "frame_header.h" 和其他类似语句：包含了其他相关的头文件，这些文件中可能声明了与UWB设备操作相关的结构、常量或函数。

基站和标签定义

  • #define RX_NODE 和 #ifdef RX_NODE：这部分代码用于根据设备是作为基站还是标签来定义不同的行为。如果设备是基站（RX_NODE），则设置其短地址为0x0001；如果设备是标签（TX_NODE），则设置其短地址为0x0005。

外部变量声明

  • extern int psduLength; 和其他类似语句：声明了在其他文件中定义的全局变量，这些变量用于存储UWB通信中的数据长度、消息框架和接收缓冲区等信息。

常量定义

  • #define SPEED_OF_LIGHT 和其他类似语句：定义了一些常量，如光速、最大帧长度、天线延迟等，这些常量用于UWB距离计算和配置。

时间相关宏定义

  • #define UUS_TO_DWT_TIME 和其他与时间相关的宏：定义了与时间相关的转换因子和延迟参数。这些参数对于配置DW1000设备的定时器和处理响应超时非常关键。

函数原型

  • extern void BPhero_UWB_Message_Init(void); 和 extern void BPhero_UWB_Init(void);：声明了在其他文件中定义的函数，这些函数用于初始化UWB消息和设备。

总结

bphero_uwb.h头文件为UWB系统的实现提供了必要的宏定义、外部变量声明和函数原型。它允许在整个项目中共享这些定义和声明，确保UWB设备的配置和操作的一致性。通过定义基站和标签、设置通信参数和声明关键函数，这个头文件为构建UWB应用提供了基础。

bphero_uwb.c

#include "bphero_uwb.h"  // 引入UWB相关的头文件
#include "port.h"        // 引入端口定义相关的头文件
#include         // 引入数学运算相关的头文件
int psduLength = 0;  // 定义变量存储PSDU长度
srd_msg_dsss msg_f_send; // 定义结构体存储即将发送的范围测量消息帧
uint8 rx_buffer[FRAME_LEN_MAX];  // 定义接收缓冲区数组
uint16 frame_len = 0;  // 定义变量存储接收到的帧长度

// 初始化UWB消息的内容
void BPhero_UWB_Message_Init(void)
{
    // 设置帧控制字节
    msg_f_send.frameCtrl[0] = 0x1 /* 帧类型为数据帧 */ | 0x40 /* PAN ID压缩 */|0x20 /* 请求ACK */;
    msg_f_send.frameCtrl[1] = 0x8 /* 目的地址模式为16位 */ | 0x80 /* 源地址模式为16位 */;
    msg_f_send.panID[0] = 0xF0;  // 设置PAN ID
    msg_f_send.panID[1] = 0xF0;

    // 初始化序列号和消息数据
    msg_f_send.seqNum = 0;
    msg_f_send.messageData[POLL_RNUM] = 3;  // 设置新的范围编号
    msg_f_send.messageData[FCODE] = RTLS_DEMO_MSG_ANCH_POLL;  // 设置消息功能码
    psduLength = (TAG_POLL_MSG_LEN + FRAME_CRTL_AND_ADDRESS_S + FRAME_CRC);

    // 初始化源地址和目的地址
    msg_f_send.seqNum = 0;
    msg_f_send.sourceAddr[0] = SHORT_ADDR & 0xFF; 
    msg_f_send.sourceAddr[1] = (SHORT_ADDR>>8) & 0xFF; 
    msg_f_send.destAddr[0] = 0x01; 
    msg_f_send.destAddr[1] = 0x01; 
}

// 默认通信配置
dwt_config_t config =
{
    2,               /* 信道号 */
    DWT_PRF_64M,     /* 脉冲重复频率 */
    DWT_PLEN_1024,   /* 前导码长度 */
    DWT_PAC32,       /* 前导码获取块大小 */
    9,               /* 发送前导码 */
    9,               /* 接收前导码 */
    1,               /* 使用非标准SFD */
    DWT_BR_110K,     /* 数据速率 */
    DWT_PHRMODE_STD, /* PHY头模式 */
    (1025 + 64 - 32) /* SFD超时（仅接收） */
};

// 初始化UWB设备
void BPhero_UWB_Init(void)
{
    reset_DW1000();  // 重置DW1000设备
    spi_set_rate_low();  // 设置SPI为低速

    dwt_rxreset();  // 重置DW1000接收器
    // 初始化DW1000，失败则持续指示错误
    if(dwt_initialise(DWT_LOADUCODE) == -1) 
    {
        while (1)
        {
            led_on(LED_ALL); // 开启所有LED
            deca_sleep(100); // 等待
            led_off(LED_ALL); // 关闭所有LED
            deca_sleep(100);
        }
    }
    spi_set_rate_high();  // 设置SPI为高速
    dwt_configure(&config);  // 配置DW1000
    dwt_setleds(1);  // 设置LED指示灯
    dwt_SetTxPower(&config);  // 设置发送功率
    dwt_setpanid(0xF0F0);  // 设置PAN ID
    dwt_setaddress16(SHORT_ADDR);  // 设置短地址
    // 设置天线延时
    dwt_setrxantennadelay(RX_ANT_DLY); 
    dwt_settxantennadelay(TX_ANT_DLY);
    // 设置中断
    dwt_setinterrupt(DWT_INT_RFCG | (DWT_INT_ARFE | DWT_INT_RFSL | DWT_INT_SFDT | DWT_INT_RPHE | DWT_INT_RFCE | DWT_INT_RFTO /*| DWT_INT_RXPTO*/), 1);
}

// 计算接收功率
static float calculatePower(float base, float N, uint8_t pulseFrequency)
{
    float A, corrFac;
    // 根据脉冲频率选择相关参数
    if(DWT_PRF_16M == pulseFrequency)
    {
        A = 115.72;
        corrFac = 2.3334;
    }
    else
    {
        A = 121.74;
        corrFac = 1.1667;
    }

    // 计算并返回功率估算值
    float estFpPwr = 10.0 * log10(base / (N * N)) - A;

    // 功率校正
    if(estFpPwr <= -88)
    {
        return estFpPwr;
    }
    else
    {
        // 近似计算修正后的功率值
        estFpPwr += (estFpPwr + 88) * corrFac;
    }

    return estFpPwr;
}

// 获取接收功率
float dwGetReceivePower(void)
{
    dwt_rxdiag_t *diagnostics;
    dwt_readdiagnostics(diagnostics);
    // 获取并处理诊断信息
    float C = (&diagnostics->stdNoise)[3];
    float N = diagnostics->rxPreamCount;

    float twoPower17 = 131072.0;  // 2^17
    // 计算并返回接收功率
    return calculatePower(C * twoPower17, N, config.prf);
}

这段代码涉及初始化和配置UWB（Ultra-Wideband）设备的步骤，以及计算接收信号功率的功能。它使用了一系列的硬件抽象和配置函数，这些函数通常是特定于设备的。以下是对代码各部分的逐行解释：

头文件和全局变量

  • #include语句：引入了必要的头文件，这些头文件中包含了UWB设备操作、端口和数学运算的相关函数和定义。
  • int psduLength = 0;：定义了一个整型变量psduLength，用来存储PSDU（PHY Service Data Unit）的长度。
  • srd_msg_dsss msg_f_send;：定义了一个结构体msg_f_send，用于存储即将发送的范围测量消息帧。
  • uint8 rx_buffer[FRAME_LEN_MAX];：定义了一个接收缓冲区数组rx_buffer。
  • uint16 frame_len = 0;：定义了一个变量frame_len，用来存储接收到的帧长度。

UWB消息初始化

  • void BPhero_UWB_Message_Init(void)：定义了一个函数，用于初始化UWB消息的内容，包括设置帧类型、地址模式、序列号、目的地址等。

    这段代码定义了一个名为BPhero_UWB_Message_Init的函数，其主要目的是初始化用于UWB通信的消息结构体msg_f_send。以下是逐行的详细解释：

    函数定义

    • void BPhero_UWB_Message_Init(void): 定义了一个无返回值，无参数的函数，用于初始化UWB消息。

    设置帧控制信息

    • msg_f_send.frameCtrl[0] = 0x1 /*frame type 0x1 == data*/ | 0x40 /*PID comp*/|0x20/* ACK request*/;: 设置帧控制字段的第一个字节。其中0x1设置帧类型为数据帧，0x40表示PAN ID压缩，0x20表示需要ACK响应。

    设置地址模式

    • msg_f_send.frameCtrl[1] = 0x8 /*dest extended address (16bits)*/ | 0x80 /*src extended address (16bits)*/;: 设置帧控制字段的第二个字节，其中0x8和0x80分别设置目的地址和源地址为16位扩展地址模式。

    设置PAN ID

    • msg_f_send.panID[0] = 0xF0; msg_f_send.panID[1] = 0xF0;: 设置PAN ID为0xF0F0。

    初始化序列号和消息数据

    • msg_f_send.seqNum = 0;: 初始化消息的序列号为0。
    • msg_f_send.messageData[POLL_RNUM] = 3;: 在消息数据中设置范围编号（POLL_RNUM）为3。
    • msg_f_send.messageData[FCODE] = RTLS_DEMO_MSG_ANCH_POLL;: 设置消息功能码，指明消息是轮询、响应还是其他类型。

    设置PSDU长度

    • psduLength = (TAG_POLL_MSG_LEN + FRAME_CRTL_AND_ADDRESS_S + FRAME_CRC);: 计算并设置PSDU长度。

    设置源地址和目的地址

    • msg_f_send.sourceAddr[0] = SHORT_ADDR & 0xFF; msg_f_send.sourceAddr[1] =(SHORT_ADDR>>8)& 0xFF;: 从SHORT_ADDR中提取源地址，并分为两个字节。
    • msg_f_send.destAddr[0] = 0x01; msg_f_send.destAddr[1] = 0x01;: 设置目的地址为0x0101。

    总结

    BPhero_UWB_Message_Init函数负责初始化UWB消息结构体，包括设置帧类型、地址模式、序列号、消息数据和目的地址等，以准备发送。这些设置是UWB通信中必要的步骤，确保消息能够被正确构造并发送到目标设备。

UWB通信配置

  • dwt_config_t config = {...}：定义了一个结构体变量config，用于配置UWB设备的通信参数，如信道、脉冲频率、前导码长度、数据速率等。

    这段代码定义了dwt_config_t类型的变量config，该变量用于配置UWB设备（如Decawave DW1000）的通信参数。dwt_config_t通常是一个结构体，包含了一系列用于设定UWB设备操作模式的字段。以下是对各个字段的逐行解释：

    结构体定义

    • dwt_config_t config = {...};: 定义并初始化一个名为config的结构体变量。

    结构体成员

    1. 信道号:
    • 2,: 设置UWB设备的信道号为2。不同信道对应不同的频率和带宽。
    1. 脉冲重复频率:
    • DWT_PRF_64M,: 设置脉冲重复频率为64MHz。PRF是影响测距精度和范围的关键参数。
    1. 前导码长度:
    • DWT_PLEN_1024,: 设置前导码长度为1024。前导码长度影响接收器的锁定性能和通信范围。
    1. 前导码获取块大小:
    • DWT_PAC32,: 设置前导码获取块大小为32。这个参数与前导码长度相关，用于接收过程中的帧同步。
    1. 发送前导码和接收前导码:
    • 9, 9,: 分别设置发送和接收前导码为编码9。前导码是UWB信号的一部分，有助于接收器进行帧同步和信号质量评估。
    1. 使用非标准SFD:
    • 1,: 设置为使用非标准的Start of Frame Delimiter（SFD）。SFD是帧开始的标记，非标准SFD可能用于特定的应用或与特定的硬件兼容。
    1. 数据速率:
    • DWT_BR_110K,: 设置数据速率为110kbps。较低的数据速率通常可以提供更远的通信距离和更强的信号穿透能力。
    1. PHY头模式:
    • DWT_PHRMODE_STD,: 设置PHY头模式为标准模式。
    1. SFD超时:
    • (1025 + 64 - 32),: 设置SFD超时。这个参数是接收时间的一个限制，用于确定何时放弃等待SFD。

    总结

    config结构体中的这些设置对于UWB设备的性能和行为至关重要。它们影响了设备的通信范围、速率、精度和兼容性。在初始化UWB设备时正确配置这些参数，可以确保设备按照预期的方式运行。

UWB设备初始化

  • void BPhero_UWB_Init(void)：定义了一个函数，用于初始化UWB设备。它包括重置设备、设置SPI速率、配置设备参数、设置LED指示灯等步骤。如果初始化失败，它会通过LED指示灯不断闪烁来提示错误。

    这段代码定义了一个名为BPhero_UWB_Init的函数，用于初始化DW1000 UWB模块。以下是逐行的详细解释：

    函数定义

    • void BPhero_UWB_Init(void): 定义了一个无返回值，无参数的函数，用于初始化UWB模块。

    设备重置和SPI速率设置

    • reset_DW1000();: 调用函数重置DW1000 UWB模块，确保从已知状态开始配置。
    • spi_set_rate_low();: 将SPI通信速率设置为低，这通常在初始化期间需要，以确保稳定的通信。

    接收器重置和设备初始化

    • dwt_rxreset();: 重置DW1000的接收器部分，以确保无残留状态或错误。
    • if(dwt_initialise(DWT_LOADUCODE) == -1): 调用dwt_initialise函数来初始化DW1000设备，如果返回-1表示初始化失败。DWT_LOADUCODE参数通常用于指示是否加载特定的微码以支持高级功能。

    错误指示

    • while (1) { ... }: 如果初始化失败，进入一个无限循环，并通过LED灯闪烁来指示错误。

    SPI速率和设备配置

    • spi_set_rate_high();: 初始化成功后，将SPI速率提高以优化性能。
    • dwt_configure(&config);: 使用前面定义的config结构体来配置DW1000的通信参数。

    LED、功率、PAN ID、地址和天线延时设置

    • dwt_setleds(1);: 启用LED指示灯，用于显示设备状态。
    • dwt_SetTxPower(&config);: 设置发送功率，通常根据配置或法规要求。
    • dwt_setpanid(0xF0F0);: 设置网络识别的PAN ID。
    • dwt_setaddress16(SHORT_ADDR);: 设置设备的短地址，用于网络中设备识别。
    • dwt_setrxantennadelay(RX_ANT_DLY); 和 dwt_settxantennadelay(TX_ANT_DLY);: 设置接收和发送天线的延迟，这对于精确的距离测量非常重要。

    中断设置

    • dwt_setinterrupt(DWT_INT_RFCG | (DWT_INT_ARFE | DWT_INT_RFSL | DWT_INT_SFDT | DWT_INT_RPHE | DWT_INT_RFCE | DWT_INT_RFTO /*| DWT_INT_RXPTO*/), 1);: 配置DW1000的中断，以响应不同的事件和错误。这些中断帮助软件正确响应接收和发送状态，以及错误条件。

    总结

    BPhero_UWB_Init函数是UWB设备的初始化脚本，负责设备的重置、配置、和错误处理。每一步都是确保UWB模块能够按照预期参数运行的关键，包括通信设置、地址分配和中断管理等。在实际应用中，这些配置需要根据具体的应用需求和法规要求进行调整。

功率计算函数

  • static float calculatePower(float base, float N, uint8_t pulseFrequency)：定义了一个函数，根据给定的参数计算接收信号的功率。它使用对数函数和一些固定参数来计算功率值。

    这段代码定义了一个名为calculatePower的函数，用于根据给定的基础功率值、脉冲数量以及脉冲频率来估算UWB设备的接收信号功率。以下是逐行的详细解释：

    函数定义

    • static float calculatePower(float base, float N, uint8_t pulseFrequency): 定义了一个静态函数，返回类型为float，接收三个参数：base（基础功率值），N（脉冲数量），pulseFrequency（脉冲频率）。

    参数选择

    • float A, corrFac;: 定义两个浮点型变量，A用于存储固定的衰减因子，corrFac用于存储功率校正因子。
    • if(DWT_PRF_16M == pulseFrequency) { ... } else { ... }: 根据传入的脉冲频率选择不同的参数值。如果脉冲频率是16MHz，则设置A和corrFac为特定值；否则，使用不同的值。这些参数对于估算功率值至关重要。

    功率估算

    • float estFpPwr = 10.0 * log10(base / (N * N)) - A;: 计算接收功率的估算值。这里使用对数函数来根据输入的基础功率值和脉冲数量计算接收信号的功率水平，并从中减去固定的衰减因子。

    功率校正

    • if(estFpPwr <= -88) { return estFpPwr; }: 如果计算出的估算功率值小于或等于-88dBm，则直接返回这个值。这可能是基于实际观察或设备规格确定的阈值。
    • estFpPwr += (estFpPwr + 88) * corrFac;: 如果估算的功率值大于-88dBm，则进行额外的校正计算，使用之前确定的corrFac进行调整。这是一个近似的校正方法，可能基于经验或设备特性。

    返回结果

    • return estFpPwr;: 返回最终计算和校正后的功率值。

    总结

    calculatePower函数是一个基于特定公式和校正方法来估算UWB设备接收信号功率的函数。它根据测量的基础功率、脉冲数量和脉冲频率来计算功率值，并对结果进行校正以提供更准确的估算。这种计算对于理解和调整UWB设备的性能非常重要，特别是在需要精确控制信号强度和质量的应用中。

接收功率获取函数

  • float dwGetReceivePower(void)：定义了一个函数，用于获取UWB设备接收信号的功率。它首先从设备中读取诊断信息，然后调用calculatePower函数来计算功率。

    这段代码定义了一个名为dwGetReceivePower的函数，用于获取并计算DW1000 UWB模块的接收信号功率。以下是逐行的详细解释：

    函数定义

    • float dwGetReceivePower(void): 定义了一个无参数的函数，返回类型为float，用于获取接收功率。

    变量定义与诊断信息读取

    • dwt_rxdiag_t *diagnostics;: 定义了一个指向dwt_rxdiag_t类型的指针，该类型是用于存储接收诊断信息的结构体。
    • dwt_readdiagnostics(diagnostics);: 调用函数dwt_readdiagnostics读取接收诊断信息，并将结果存储在diagnostics指针指向的结构体中。

    获取并处理诊断信息

    • float C = (&diagnostics->stdNoise)[3];: 从诊断信息中获取标准噪声级的第四个元素值，并将其赋给变量C。这个值通常与信号的噪声水平有关。
    • float N = diagnostics->rxPreamCount;: 获取接收到的前导码计数值，并将其赋给变量N。前导码计数是接收信号中前导序列的数量，与信号强度有关。

    计算接收功率

    • float twoPower17 = 131072.0;: 定义一个常数，表示(2^{17})，用于功率计算中的缩放。
    • return calculatePower(C * twoPower17, N, config.prf);: 调用calculatePower函数计算接收功率，并返回计算结果。传入的参数是调整后的标准噪声级C、前导码计数N和配置中的脉冲重复频率config.prf。

    总结

    dwGetReceivePower函数是用于读取UWB模块的接收诊断信息，并基于这些信息计算接收信号的功率。这个计算涉及到对接收信号的标准噪声水平和前导码计数的测量，以及对结果的数学处理。计算出的接收功率可以用于评估信号质量、调整传输功率或进行其他信号处理操作。

总结

这段代码是UWB设备（如Decawave的DW1000）的初始化、配置和功率计算的集合。代码中使用了许多特定于设备的函数和结构体，这些通常在设备的SDK或API文档中有详细描述。整体来看，这段代码用于设备的基础设置、通信配置和功率测量，是UWB定位或通信系统中常见的操作。

stm32f10x_it.c

//extern void Simple_Rx_Callback(void);  // 外部定义的接收回调函数，当前未使用，已被注释
extern void (*bphero_rxcallback)(void);  // 声明一个外部的函数指针，指向接收处理函数

void EXTI0_IRQHandler(void)  // 定义外部中断0处理函数
{
    if(EXTI_GetITStatus(EXTI_Line0)!= RESET)  // 如果外部中断0的标志位被设置
    {
        (*bphero_rxcallback)();  // 通过函数指针调用回调函数处理中断
        EXTI_ClearITPendingBit(EXTI_Line0);  // 清除外部中断0的标志位以防止再次触发
    }
}

这段代码定义了一个名为EXTI0_IRQHandler的外部中断服务例程（External Interrupt Handler），用于STM32微控制器的第0号外部中断（EXTI0）。以下是逐行的详细解释：

注释掉的外部函数声明

  • //extern void Simple_Rx_Callback(void);: 这是一个被注释掉的外部函数声明，原本可能用于处理接收回调，但在当前上下文中未被使用。

外部函数指针声明

  • extern void (*bphero_rxcallback)(void);: 声明了一个外部的函数指针bphero_rxcallback，它指向一个无返回值、无参数的函数。这意味着bphero_rxcallback可以被指定为任何符合此形式的函数，并在中断发生时被调用。

中断服务例程定义

  • void EXTI0_IRQHandler(void): 定义了一个名为EXTI0_IRQHandler的函数，作为第0号外部中断的处理函数。

中断状态检查和处理

  • if(EXTI_GetITStatus(EXTI_Line0)!= RESET): 检查第0号外部中断线（EXTI_Line0）的中断状态。如果该中断线的中断标志位被设置（即发生了中断事件），则执行大括号内的代码。

调用回调函数

  • (*bphero_rxcallback)();: 通过函数指针调用外部定义的回调函数。这意味着当EXTI0中断发生时，会执行bphero_rxcallback所指向的函数。

清除中断标志位

  • EXTI_ClearITPendingBit(EXTI_Line0);: 清除第0号外部中断线的中断标志位，以确保中断不会再次立即触发，并允许识别新的中断事件。

总结

EXTI0_IRQHandler函数是一个外部中断处理器，用于STM32的第0号外部中断。当EXTI0发生中断时，它会调用bphero_rxcallback指向的函数处理中断事件，然后清除中断标志位。这种中断处理机制常用于响应外部事件，如按钮按下、传感器信号变化等，并使系统能够在事件发生时立即执行相关处理。通过使用函数指针，这个处理器可以非常灵活地关联到不同的回调函数，以适应不同的处理需求。

关于回调函数如何被调用

为了解释Simple_Rx_Callback函数如何被调用，我们需要看看之前提到的几个代码段是如何一起工作的。这包括函数指针的声明、设置回调函数、中断处理程序以及回调函数的调用。以下是整合代码及其调用流程的解释：

1. 函数指针的声明

extern void (*bphero_rxcallback)(void);

这行代码声明了一个名为bphero_rxcallback的全局函数指针，它可以指向任何无参数和无返回值的函数。

这行代码是C语言中的一个外部变量声明，涉及到函数指针的使用。以下是逐部分的详细解释：

extern 关键字

  • extern: 这个关键字用于声明一个变量是在其他地方定义的。在这种情况下，它告诉编译器bphero_rxcallback变量在其他文件中定义，这是一种跨文件引用全局变量的方式。

函数指针

  • void (*bphero_rxcallback)(void);: 这部分定义了一个函数指针bphero_rxcallback。让我们分解一下这个声明：
    • void (...): 表明这个函数没有返回值。
    • (*bphero_rxcallback): 这是函数指针的名称，即bphero_rxcallback。
    • (void): 表明这个函数不接受任何参数。

整体含义

整体来看，这行代码声明了一个名为bphero_rxcallback的全局函数指针，该指针可以指向任何不接受参数且没有返回值的函数。在程序中，其他文件可能会定义一个实际的函数，该函数符合上述条件（即无参数无返回值），并将该函数的地址赋给bphero_rxcallback。这样，程序的其他部分就可以通过bphero_rxcallback()语法调用这个回调函数了，而具体调用的是哪个函数则取决于在运行时bphero_rxcallback被设置为指向哪个函数的地址。

应用场景

在事件驱动的编程中，如处理外部中断、接收数据等情况，函数指针作为回调函数非常常见。这允许程序设计者灵活地在运行时决定应该执行哪个函数，从而可以根据不同的事件或状态调用不同的处理函数，而无需改变调用函数的代码。这种设计提高了代码的模块化和复用性。

2. 设置回调函数

// 定义设置回调函数的函数
void bphero_setcallbacks(void (*rxcallback)(void))
{
    bphero_rxcallback = rxcallback; // 将传入的函数指针赋值给全局函数指针变量bphero_rxcallback
}

bphero_setcallbacks(Simple_Rx_Callback); // 调用bphero_setcallbacks函数，将Simple_Rx_Callback设置为接收回调函数

首先，bphero_setcallbacks函数被定义，用于将传入的函数地址赋给bphero_rxcallback函数指针。然后，bphero_setcallbacks(Simple_Rx_Callback)被调用，实际上是将Simple_Rx_Callback函数的地址赋给了bphero_rxcallback。这样，bphero_rxcallback现在指向Simple_Rx_Callback函数。

这段代码涉及到两个主要部分：一个是bphero_setcallbacks函数的定义，另一个是对该函数的调用。以下是逐行的详细解释：

函数定义：bphero_setcallbacks

  • void bphero_setcallbacks(void (*rxcallback)(void)): 定义了一个名为bphero_setcallbacks的函数，它接受一个参数，这个参数是一个指向函数的指针，具体来说，是指向一个没有参数和没有返回值的函数的指针。

函数内部代码

  • bphero_rxcallback = rxcallback;: 这行代码是函数的主体部分。它将传入的函数指针rxcallback赋值给全局变量bphero_rxcallback。此操作实质上是将bphero_rxcallback指向了rxcallback所指向的函数，这样，当需要调用回调函数时，可以通过bphero_rxcallback来调用。

函数调用

  • bphero_setcallbacks(Simple_Rx_Callback);: 这行代码调用了bphero_setcallbacks函数，并将Simple_Rx_Callback作为参数传递给这个函数。Simple_Rx_Callback是定义在程序其他部分的一个函数，它应该满足没有参数和没有返回值的条件。

总结

这段代码的主要作用是提供一种机制，允许在程序的其他部分动态地指定某个函数（在这个例子中是Simple_Rx_Callback）作为回调函数来处理特定事件。通过bphero_setcallbacks(Simple_Rx_Callback);调用，Simple_Rx_Callback函数的地址被赋值给了全局的函数指针bphero_rxcallback。在程序的其他地方，当相关事件发生，如接收到数据，可以通过调用bphero_rxcallback指向的函数来处理该事件，从而实现了回调机制。这使得程序在运行时更加灵活，可以根据需要选择或更改事件处理逻辑。

3. 外部中断处理程序

//extern void Simple_Rx_Callback(void);  // 外部定义的接收回调函数，当前未使用，已被注释
extern void (*bphero_rxcallback)(void);  // 声明一个外部的函数指针，指向接收处理函数

void EXTI0_IRQHandler(void)  // 定义外部中断0处理函数
{
    if(EXTI_GetITStatus(EXTI_Line0)!= RESET)  // 如果外部中断0的标志位被设置
    {
        (*bphero_rxcallback)();  // 通过函数指针调用回调函数处理中断
        EXTI_ClearITPendingBit(EXTI_Line0);  // 清除外部中断0的标志位以防止再次触发
    }
}

这是一个外部中断服务例程。当外部中断0触发时，它会检查中断标志位。如果中断确实发生，它通过调用(*bphero_rxcallback)();来执行Simple_Rx_Callback。因为之前已经通过bphero_setcallbacks(Simple_Rx_Callback)将bphero_rxcallback指向了Simple_Rx_Callback函数，所以这里实际上是在调用Simple_Rx_Callback。

总结

当系统初始化时，通过bphero_setcallbacks(Simple_Rx_Callback)将Simple_Rx_Callback函数设置为回调函数。然后，每当EXTI0外部中断触发，EXTI0_IRQHandler中断服务例程将被调用，它进一步调用(*bphero_rxcallback)()，即Simple_Rx_Callback函数。这是一个典型的中断驱动的回调机制，在事件发生时，如接收到数据，特定的回调函数（在本例中为Simple_Rx_Callback）将被执行，以处理该事件。这种设计模式允许高度灵活和可配置的事件处理。

函数指针

函数指针是C语言中一个指向函数的指针，即它的值是一个函数的地址。这样的指针可以用来调用函数和传递函数作为参数给其他函数。它们在编写可重用代码或回调函数时非常有用。

函数指针的基本语法

在C语言中，函数指针的声明包含了函数的返回类型、函数指针的名字以及函数的参数类型。以下是基本的函数指针声明语法：

返回类型 (*指针变量名)(参数类型);

函数指针的使用

  1. 声明函数指针：首先需要声明一个函数指针，指明它所指向的函数的类型。
  2. 指向函数：然后，将函数指针指向一个具体的函数。
  3. 通过函数指针调用函数：一旦函数指针被赋予了一个函数的地址，就可以通过它来调用这个函数。

代码实例

假设我们有一个简单的函数，该函数接受两个整数参数并返回它们的和。然后我们使用函数指针调用这个函数。

#include 

// 一个简单的函数，计算两个整数的和
int add(int a, int b) {
    return a + b;
}

int main() {
    // 声明一个指向函数的指针
    int (*funcPtr)(int, int);

    // 将funcPtr指向add函数
    funcPtr = add;

    // 使用函数指针调用函数
    int sum = funcPtr(2, 3);
    printf("Sum = %d\n", sum);

    return 0;
}

在这个例子中：

  • int add(int a, int b) 是我们想要通过函数指针调用的函数。
  • int (*funcPtr)(int, int); 声明了一个函数指针funcPtr，它指向一个接受两个int类型参数并返回int类型的函数。
  • funcPtr = add; 将funcPtr指向add函数。
  • int sum = funcPtr(2, 3); 通过函数指针调用add函数。

函数指针的应用场景

函数指针广泛用于以下场景：

  • 回调函数：允许用户将自己的函数传递给库函数，然后在适当的时候由库函数回调。
  • 事件驱动的编程：在事件发生时调用预先指定的函数。
  • 接口实现：允许变更算法或策略，动态改变调用的函数。
  • 表驱动的代码：函数指针数组可以用于根据条件简洁地选择并执行函数。

总结

函数指针是C语言中一个强大的特性，允许编程更灵活、代码更模块化。它们使得程序可以在不同的上下文中重用函数，提高了代码的通用性和灵活性。

帧过滤

你可能感兴趣的:(UWB,BP-50开发框架,室内定位导航,嵌入式硬件,stm32)

  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchainmicrosoft数据库python
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
  • STM32中的计时与延时 lupinjia STM32stm32单片机
    前言在裸机开发中，延时作为一种规定循环周期的方式经常被使用，其中尤以HAL库官方提供的HAL_Delay为甚。刚入门的小白可能会觉得既然有官方提供的延时函数，而且精度也还挺好，为什么不用呢？实际上HAL_Delay中有不少坑，而这些也只是HAL库中无数坑的其中一些。想从坑里跳出来还是得加强外设原理的学习和理解，切不可只依赖HAL库。除了延时之外，我们在开发中有时也会想要确定某段程序的耗时，这就需要
  • 基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程 极客小张 stm32qt机器人物联网人机交互毕业设计c语言
    一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
  • 基于STM32的汽车仪表显示系统：集成CAN、UART与I2C总线设计流程 极客小张 stm32汽车嵌入式硬件物联网单片机c语言
    一、项目概述项目目标与用途本项目旨在设计和实现一个基于STM32微控制器的汽车仪表显示系统。该系统能够实时显示汽车的速度、转速、油量等关键信息，并通过CAN总线与其他汽车控制单元进行通信。这种仪表显示系统不仅提高了驾驶的安全性和便捷性，还能为汽车提供更智能的用户体验。技术栈关键词微控制器：STM32显示技术：TFTLCD/OLED传感器：速度传感器、温度传感器、油量传感器通信协议：CAN总线、UA
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗? 瑞金彭于晏 springboot后端javaMVCspring数据库
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
  • 基于STM32的简易RTOS分析-预备知识 騏威 嵌入式
    写下这篇文章的主要目的是对自己学习RTOS的历程做一个记录和总结，方便以后回忆翻看。以下内容主要来自宋岩先生翻译的《Cortex-M3权威指南》。目录一、Cortex-M3寄存器简介二、堆栈操作简介三、汇编指令简介LDR和STR指令STMDB和LDMIA指令B、BX、BL、BLX指令MRS和MSR指令四、中断简介中断响应过程简介SVC和PensSV中断简介软件中断五、汇编基础一、Cortex-M3
  • 15-自编写rtos-结合stm32实际调试(ladylolo-os) Ladylolo-lsm stm32嵌入式硬件单片机
    一、任务调度:1.理解:任务切换，用堆栈指针SP保存即将要切换的任务的前后文，然后是用PendSV来执行这些操作的；由于是基于优先级的调度策略，所以每次“心跳”都会看有没有优先级更高的出现，如果有就用PendSV进行上下文切换。2.编写部分:①每个任务自己的属性统称为TCB任务控制块。②任务就绪表有设置优先级(设置的时候变量或上优先级的变量让某个位数等于1)，从任务就绪表中删除(删除时用与来得等于
  • 【鸿蒙应用】总结一下ArkUI 读心悦 鸿蒙基础鸿蒙应用
    ArkUI是HarmonyOS应用界面的UI开发框架，提供了简洁的UI语法、UI组件、动画机制和事件交互等等UI开发基础，以此满足应用开发者对UI界面开发的需求。组件是界面搭建的最小单位，开发者通过多种组件的组合构成完整的界面。页面是ArkUI最小的调度分隔单位，开发者可以将应用设计为多个功能页面，每一个页面进行单独的文件管理，并且通过页面路由API完成页面之间的调度管理，以此来实现应用内功能的解
  • 【C#生态园】深度剖析：C#嵌入式开发工具大揭秘 friklogff C#生态园c#开发语言
    C#嵌入式开发：全面了解六大框架与库前言随着物联网和嵌入式系统的快速发展，越来越多的开发者开始关注使用C#语言进行嵌入式开发。本文将介绍几种用于C#的嵌入式开发框架和相关库，以及它们的核心功能、安装配置方法和API概览，帮助读者了解并选择适合自己项目的工具和资源。欢迎订阅专栏：C#生态园文章目录C#嵌入式开发：全面了解六大框架与库前言1.nanoFramework：一个用于C#的嵌入式开发框架1.
  • 小米嵌入式面试题目RTOS面试题目 嵌入式面试题目 好家伙VCC 面试杂谈杂谈面试职场和发展
    第一章-非RTOSbootloader工作流程MCU启动流程通信协议，SPIIICMCU怎么选型，STM32F1和F4有什么区别外部RAM和内部RAM区别，怎么分配外部总线和内部总线区别MCU上的固件，数据是怎么分配的MCU启动流程IAP是怎么升级的，突然断电怎么办挑了麦轮项目（因为大疆RM也是麦轮，面试官看样子比较感兴趣）为什么用的CAN总线你说一下spi和i2c和UART的各自的工作方式优缺点
  • 基于STM32F103C8T6定时器的PWM通道的重映射 —你的鼬先生 stm32嵌入式硬件单片机
    在我们平时的的使用中，我们最常使用的是TIM2和TIM3的PWM通道，但是由于C8T6的IO口有限，所以可能会出现PWM通道的资源不够的情况，从而我们可能会使用PWM4的PWM通道，但是TIM4的PWM通道并不能直接使用，它需要进行一个重映射，不然可能会导致PWM波不能正常发送。以下就是对PWM4的PWM通道进行一个重映射#include"stm32f10x.h"//Deviceheadervoi
  • 【STM32系统】基于STM32设计的锂电池电量/电压检测报警器系统——文末完整资料下载（程序源码/电路原理图/电路PCB/设计文档/模块资料/元器件清单/实物图/答辩问题技巧/PPT模版等） 阿齐Archie 单片机嵌入式项目stm32嵌入式硬件单片机
    基于STM32设计的锂电池电量/电压检测报警器系统系统视频：摘要：本设计旨在研究一个基于STM32F103C8T6微控制器的锂电池电量/电压检测报警器系统，应用于便携式电子设备电池管理。系统通过STM32的ADC模块对锂电池电压进行采集，利用LCD1602显示模块实时显示电池电压，当检测到电池电量不足或电压异常时，蜂鸣器报警模块会发出警报提醒用户。系统采用简单的硬件结构和优化的软件架构，通过对实际
  • Dubbo架构概览：服务注册与发现、远程调用、监控与管理 木南曌 dubbo架构
    Dubbo是一个成熟的、高性能的、基于Java的微服务开发框架，它主要用于解决分布式系统中的服务治理问题，包括服务的注册与发现、远程过程调用（RPC）、服务监控与管理等多个关键环节。以下是Dubbo架构概览的详细介绍：服务注册与发现Dubbo的服务注册与发现机制是其核心功能之一，它依赖于注册中心来管理服务的生命周期和定位服务提供者。1.服务提供者（Provider）服务提供者是实际提供服务的节点，
  • 使用STM32实现简单的智能温控系统 棂梓知识 stm32单片机嵌入式硬件
    智能温控系统是一种能够根据环境温度实时调整设备的工作状态的系统。在本篇文章中，我们将使用STM32微控制器来实现一个简单的智能温控系统。该系统将会有以下功能：实时监测环境温度，并显示在LCD屏幕上。当环境温度超过设定的阈值时，自动开启风扇。当环境温度恢复正常时，自动关闭风扇。通过按键模拟调节设定的阈值。系统设计首先，我们需要准备一些硬件设备。具体而言，我们需要以下组件：STM32F103C8T6开
  • STM32 HAL freertos零基础（九）任务通知 啥也不会的小白研究生 零基础学习Freertosstm32嵌入式硬件单片机
    1、任务通知任务通知用于任务之间同步和通信。任务通知允许一个任务向另一个任务发送一个32位的值，并可以选择是否唤醒正在等待通知的任务。这使得任务之间的同步更加简单和灵活。任务通知功能：发送通知：一个任务可以向另一个任务发送一个32位的值。接收通知：接收任务可以根据接收到的通知来决定何时执行某些操作。通知状态：可以检查任务的当前通知状态。2、相关APIxTaskNotify()//发送通知，带有通知
  • 4×4矩阵键盘详解（STM32） 辰哥单片机设计 STM32传感器教学矩阵计算机外设stm32嵌入式硬件单片机传感器
    目录一、介绍二、传感器原理1.原理图2.工作原理介绍三、程序设计main.c文件button4_4.h文件button4_4.c文件四、实验效果五、资料获取项目分享一、介绍矩阵键盘，又称为行列式键盘，是用4条I/O线作为行线，4条I/O线作为列线组成的键盘。在行线和列线的每一个交叉点上设置一个按键，因此键盘中按键的个数是4×4个。这种行列式键盘结构能够有效地提高单片机系统中I/O口的利用率，节约单
  • STM32的寄存器深度解析 千千道 STM32stm32单片机物联网
    目录一、STM32寄存器概述二、寄存器的定义与作用三、寄存器分类1.内核寄存器2.外设寄存器四、重要寄存器详解1.GPIO相关寄存器2.定时器相关寄存器3.中断相关寄存器4.RCC相关寄存器五、寄存器操作方法1.直接操作寄存器2.使用库函数操作寄存器六、总结在嵌入式系统开发中，STM32微控制器以其强大的性能和丰富的功能而备受青睐。而理解和掌握STM32的寄存器是深入学习和开发STM32的关键。本
  • STM32 如何生成随机数 千千道 STM32stm32单片机物联网
    目录一、引言二、STM32随机数发生器概述三、工作原理1.噪声源2.线性反馈移位寄存器（LFSR）3.数据寄存器（RNG_DR）4.监控和检测电路：5.控制和状态寄存器6.生成流程四、使用方法1.使能随机数发生器2.读取随机数3.错误处理五、注意事项1.随机数的质量2.安全性3.性能考虑六、总结一、引言在嵌入式系统开发中，随机数的生成常常是一个重要的需求。无论是用于加密、模拟、游戏还是其他需要不确
  • STM32——看门狗通俗解析 百里与司空 stm32嵌入式硬件单片机门控循环单元
    笔者在学习看门狗的视频后，对看门狗仍然是一知半解，后面在实际应用中发现它是一个很好用的检测或者调试工具。所以总结一下笔者作为初学小白对看门狗的理解。主函数初始化阶段、循环阶段和复位众所周知，程序的运行一般是这样的：程序在进入循环阶段之前，会在初始化阶段将每个寄存器或者某些变量赋值。初始化阶段的代码执行一次后，就不再执行了。而循环阶段的代码会执行很多次，一直循环反复的执行下去。这时，如果进行了复位，
  • STM32 的 RTC（实时时钟）详解 千千道 STM32stm32物联网单片机
    目录一、引言二、RTC概述三、RTC的工作原理1.时钟源2.计数器3.闹钟功能4.备份寄存器四、RTC寄存器1.RTC_TR（TimeRegister，时间寄存器）2.RTC_DR（DateRegister，日期寄存器）3.RTC_SSR（SubsecondRegister，亚秒寄存器）4.RTC_PRER（PrescalerRegister，预分频器寄存器）5.RTC_CR（ControlReg
  • 1-1.Jetpack 之 Navigation 简单编码模板 我命由我12345 Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack
    一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
  • 外卖霸王餐返利外卖会员卡小程序开发 闹小艾 good506070微信小程序小程序
    外卖霸王餐返利外卖会员卡小程序开发"社交电商赋能下的外卖返利小程序"是专为商家与用户双赢而设计的创新平台。以下是其开发方案的详细步骤：一、需求梳理：首先，我们需要明确小程序的核心功能和特色。包括设定活动类型、返利策略，以及用户体验友好的界面设计。二、技术决策：技术选型是关键。我们采用小程序的开发框架，利用JavaScript作为前端开发语言，并结合微信提供的API进行后端接口调用与数据处理。三、账
  • Spring Boot 请求处理流程：从负载均衡到多实例并发 - 电子商务网站实例 烟雨国度 springboot负载均衡后端
    SpringBoot请求处理流程：从负载均衡到多实例并发-电子商务网站实例SpringBoot请求处理流程：从负载均衡到多实例并发SpringBoot作为一个强大的Java应用开发框架，能够有效地处理高并发请求。本文将基于三个关键流程图，详细分析SpringBoot应用如何从负载均衡到请求处理，再到多实例并发处理的整个过程。1.负载均衡和多实例处理首先，让我们看一下描述负载均衡和多实例处理的流程图
  • 技术周总结 09.09~09.15周日(C# WinForm WPF) 打破砂锅问到底007 wpfc#WinForm
    文章目录一、09.09周一1.1)问题01:Windows桌面开发中，WPF和WinForm的区别和联系？联系：区别：二、09.12周四2.1）问题01：visualstudio的相关快捷键有哪些？通用快捷键编辑导航调试窗口管理2.2）问题02：publicpartialclassChoosePLReason:CommonBaseForm2.3)问题03：介绍WindowsForms中的Syste
  • 微信小程序常用开发框架有哪些？ +码农快讯+ 分享微信小程序小程序开发
    想要开发出一套高质量的小程序，运用框架，组件库是省时省力省心必不可少一部分，随着小程序日渐火爆，各种不同类型的小程序也渐渐更新，其中不乏一些优秀好用的框架/组件库。1：WeUI小程序–使用教程https://weui.io/官方介绍：WeUI是一套同微信原生视觉体验一致的基础样式库，由微信官方设计团队为微信内网页和微信小程序量身设计，令用户的使用感知更加统一。小程序开发中最常用到的一款框架，受广大
  • 网上商城项目总结 续 猫只i javaweb电子商城结构
    前台1.用户登录注册邮箱验证校验用户名是否存在验证码自动登录2.导航条自定义标签库采用异步读取数据（使用gson将集合转换json数据）Redis服务器3.首页热门商品查询展示4.分类列表分页查询5.商品详情用cookie实现浏览记录6.购物车实现商品添加到购物车商品的查询，添加，修改，删除清空购物车7.提交订单添加订单（订单详情）确认订单（易宝支付）8.我的订单9.Fliter定义权限拦截（提交
  • （小白入门）Windows环境下搭建React Native Android开发环境 码农老黑 前端ReactNative移动开发Androidstudio
    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
  • 2020-11-12 写单片机内存的脚本 nc openocd 事务自动测试 linuxScripter
    这是写单片机内存的脚本：z@z-ThinkPad-T400:~/zworkT400/EDA_heiche/zREPOgit/simple-gcc-stm32-project$catz.wholeRun.oneCase.cmdcattmp6.toWrite|awk'{system("echomwb"$1""$2"|nclocalhost4444");}'catUSER/DEBUG/debug.h|g
  • jQuery 键盘事件keydown ,keypress ,keyup介绍 107x jsjquerykeydownkeypresskeyup
    本文章总结了下些关于jQuery 键盘事件keydown ,keypress ,keyup介绍，有需要了解的朋友可参考。 一、首先需要知道的是： 1、keydown() keydown事件会在键盘按下时触发. 2、keyup()  代码如下 复制代码 $('input').keyup(funciton(){      
  • AngularJS中的Promise bijian1013 JavaScriptAngularJSPromise
    一.Promise         Promise是一个接口，它用来处理的对象具有这样的特点：在未来某一时刻（主要是异步调用）会从服务端返回或者被填充属性。其核心是，promise是一个带有then()函数的对象。         为了展示它的优点，下面来看一个例子，其中需要获取用户当前的配置文件： var cu
  • c++ 用数组实现栈类 CrazyMizzz 数据结构C++
    #include<iostream> #include<cassert> using namespace std; template<class T, int SIZE = 50> class Stack{ private: T list[SIZE];//数组存放栈的元素 int top;//栈顶位置 public: Stack(
  • java和c语言的雷同 麦田的设计者 java递归scaner
    软件启动时的初始化代码，加载用户信息2015年5月27号 从头学java二 1、语言的三种基本结构：顺序、选择、循环。废话不多说，需要指出一下几点：      a、return语句的功能除了作为函数返回值以外，还起到结束本函数的功能，return后的语句 不会再继续执行。      b、for循环相比于whi
  • LINUX环境并发服务器的三种实现模型 被触发 linux
    服务器设计技术有很多，按使用的协议来分有TCP服务器和UDP服务器。按处理方式来分有循环服务器和并发服务器。 1  循环服务器与并发服务器模型 在网络程序里面，一般来说都是许多客户对应一个服务器，为了处理客户的请求，对服务端的程序就提出了特殊的要求。 目前最常用的服务器模型有： ·循环服务器：服务器在同一时刻只能响应一个客户端的请求 ·并发服务器：服
  • Oracle数据库查询指令 肆无忌惮_ oracle数据库
    20140920   单表查询 -- 查询************************************************************************************************************ -- 使用scott用户登录   -- 查看emp表   desc emp  
  • ext右下角浮动窗口 知了ing JavaScriptext
    第一种 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/
  • 浅谈REDIS数据库的键值设计 矮蛋蛋 redis
    http://www.cnblogs.com/aidandan/ 原文地址：http://www.hoterran.info/redis_kv_design 丰富的数据结构使得redis的设计非常的有趣。不像关系型数据库那样，DEV和DBA需要深度沟通，review每行sql语句，也不像memcached那样，不需要DBA的参与。redis的DBA需要熟悉数据结构，并能了解使用场景。
  • maven编译可执行jar包 alleni123 maven
    http://stackoverflow.com/questions/574594/how-can-i-create-an-executable-jar-with-dependencies-using-maven <build> <plugins> <plugin> <artifactId>maven-asse
  • 人力资源在现代企业中的作用 百合不是茶 HR 企业管理
    //人力资源在在企业中的作用人力资源为什么会存在，人力资源究竟是干什么的 人力资源管理是对管理模式一次大的创新，人力资源兴起的原因有以下点： 工业时代的国际化竞争，现代市场的风险管控等等。所以人力资源 在现代经济竞争中的优势明显的存在，人力资源在集团类公司中存在着 明显的优势(鸿海集团)，有一次笔者亲自去体验过红海集团的招聘，只 知道人力资源是管理企业招聘的 当时我被招聘上了，当时给我们培训 的人
  • Linux自启动设置详解 bijian1013 linux
    linux有自己一套完整的启动体系，抓住了linux启动的脉络，linux的启动过程将不再神秘。 阅读之前建议先看一下附图。 本文中假设inittab中设置的init tree为： /etc/rc.d/rc0.d /etc/rc.d/rc1.d /etc/rc.d/rc2.d /etc/rc.d/rc3.d /etc/rc.d/rc4.d /etc/rc.d/rc5.d /etc
  • Spring Aop Schema实现 bijian1013 javaspringAOP
    本例使用的是Spring2.5 1.Aop配置文件spring-aop.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmln
  • 【Gson七】Gson预定义类型适配器 bit1129 gson
    Gson提供了丰富的预定义类型适配器，在对象和JSON串之间进行序列化和反序列化时，指定对象和字符串之间的转换方式，   DateTypeAdapter   public final class DateTypeAdapter extends TypeAdapter<Date> { public static final TypeAdapterFacto
  • 【Spark八十八】Spark Streaming累加器操作（updateStateByKey) bit1129 update
    在实时计算的实际应用中，有时除了需要关心一个时间间隔内的数据，有时还可能会对整个实时计算的所有时间间隔内产生的相关数据进行统计。 比如： 对Nginx的access.log实时监控请求404时，有时除了需要统计某个时间间隔内出现的次数，有时还需要统计一整天出现了多少次404，也就是说404监控横跨多个时间间隔。   Spark Streaming的解决方案是累加器，工作原理是，定义
  • linux系统下通过shell脚本快速找到哪个进程在写文件 ronin47
    一个文件正在被进程写 我想查看这个进程 文件一直在增大 找不到谁在写 使用lsof也没找到 这个问题挺有普遍性的，解决方法应该很多，这里我给大家提个比较直观的方法。 linux下每个文件都会在某个块设备上存放，当然也都有相应的inode, 那么透过vfs.write我们就可以知道谁在不停的写入特定的设备上的inode。 幸运的是systemtap的安装包里带了inodewatch.stp，位
  • java-两种方法求第一个最长的可重复子串 bylijinnan java算法
    import java.util.Arrays; import java.util.Collections; import java.util.List; public class MaxPrefix { public static void main(String[] args) { String str="abbdabcdabcx";
  • Netty源码学习-ServerBootstrap启动及事件处理过程 bylijinnan javanetty
    Netty是采用了Reactor模式的多线程版本，建议先看下面这篇文章了解一下Reactor模式： http://bylijinnan.iteye.com/blog/1992325 Netty的启动及事件处理的流程，基本上是按照上面这篇文章来走的 文章里面提到的操作，每一步都能在Netty里面找到对应的代码 其中Reactor里面的Acceptor就对应Netty的ServerBo
  • servelt filter listener 的生命周期 cngolon filterlistenerservelt生命周期
    1. servlet    当第一次请求一个servlet资源时，servlet容器创建这个servlet实例，并调用他的 init(ServletConfig config)做一些初始化的工作，然后调用它的service方法处理请求。当第二次请求这个servlet资源时，servlet容器就不在创建实例，而是直接调用它的service方法处理请求，也就是说
  • jmpopups获取input元素值 ctrain JavaScript
    jmpopups 获取弹出层form表单 首先，我有一个div，里面包含了一个表单，默认是隐藏的，使用jmpopups时，会弹出这个隐藏的div，其实jmpopups是将我们的代码生成一份拷贝。 当我直接获取这个form表单中的文本框时，使用方法：$('#form input[name=test1]').val()；这样是获取不到的。 我们必须到jmpopups生成的代码中去查找这个值，$(
  • vi查找替换命令详解 daizj linux正则表达式替换查找vim
    一、查找 查找命令 /pattern<Enter> ：向下查找pattern匹配字符串 ?pattern<Enter>：向上查找pattern匹配字符串 使用了查找命令之后，使用如下两个键快速查找： n：按照同一方向继续查找 N：按照反方向查找 字符串匹配 pattern是需要匹配的字符串，例如： 1:  /abc<En
  • 对网站中的js,css文件进行打包 dcj3sjt126com PHP打包
    一，为什么要用smarty进行打包 apache中也有给js,css这样的静态文件进行打包压缩的模块，但是本文所说的不是以这种方式进行的打包，而是和smarty结合的方式来把网站中的js,css文件进行打包。 为什么要进行打包呢，主要目的是为了合理的管理自己的代码 。现在有好多网站，你查看一下网站的源码的话，你会发现网站的头部有大量的JS文件和CSS文件，网站的尾部也有可能有大量的J
  • php Yii: 出现undefined offset 或者 undefined index解决方案 dcj3sjt126com undefined
    在开发Yii 时，在程序中定义了如下方式：        if($this->menuoption[2] === 'test')，那么在运行程序时会报：undefined offset:2，这样的错误主要是由于php.ini 里的错误等级太高了，在windows下错误等级
  • linux 文件格式（1） sed工具 eksliang linuxlinux sed工具sed工具linux sed详解
    转载请出自出处： http://eksliang.iteye.com/blog/2106082 简介       sed 是一种在线编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（pattern space），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾
  • Android应用程序获取系统权限 gqdy365 android
    引用 如何使Android应用程序获取系统权限         第一个方法简单点，不过需要在Android系统源码的环境下用make来编译：         1. 在应用程序的AndroidManifest.xml中的manifest节点
  • HoverTree开发日志之验证码 hvt .netC#asp.nethovertreewebform
    HoverTree是一个ASP.NET的开源CMS，目前包含文章系统，图库和留言板功能。代码完全开放，文章内容页生成了静态的HTM页面，留言板提供留言审核功能，文章可以发布HTML源代码，图片上传同时生成高品质缩略图。推出之后得到许多网友的支持，再此表示感谢！留言板不断收到许多有益留言，但同时也有不少广告，因此决定在提交留言页面增加验证码功能。ASP.NET验证码在网上找，如果不是很多，就是特别多
  • JSON API：用 JSON 构建 API 的标准指南中文版 justjavac json
    译文地址：https://github.com/justjavac/json-api-zh_CN 如果你和你的团队曾经争论过使用什么方式构建合理 JSON 响应格式， 那么 JSON API 就是你的 anti-bikeshedding 武器。 通过遵循共同的约定，可以提高开发效率，利用更普遍的工具，可以是你更加专注于开发重点：你的程序。 基于 JSON API 的客户端还能够充分利用缓存，
  • 数据结构随记_2 lx.asymmetric 数据结构笔记
    第三章 栈与队列 一．简答题 1. 在一个循环队列中，队首指针指向队首元素的  前一个    位置。  2.在具有n个单元的循环队列中，队满时共有  n-1  个元素。  3. 向栈中压入元素的操作是先  移动栈顶指针&n
  • Linux下的监控工具dstat 网络接口 linux
    1) 工具说明dstat是一个用来替换 vmstat,iostat netstat,nfsstat和ifstat这些命令的工具, 是一个全能系统信息统计工具. 与sysstat相比, dstat拥有一个彩色的界面, 在手动观察性能状况时, 数据比较显眼容易观察; 而且dstat支持即时刷新, 譬如输入dstat 3, 即每三秒收集一次, 但最新的数据都会每秒刷新显示. 和sysstat相同的是,
  • C 语言初级入门--二维数组和指针 1140566087 二维数组c/c++指针
    /* 二维数组的定义和二维数组元素的引用 二维数组的定义： 当数组中的每个元素带有两个下标时，称这样的数组为二维数组； (逻辑上把数组看成一个具有行和列的表格或一个矩阵); 语法： 类型名 数组名[常量表达式1][常量表达式2] 二维数组的引用： 引用二维数组元素时必须带有两个下标，引用形式如下： 例如： int a[3][4];  引用：
  • 10点睛Spring4.1-Application Event wiselyman application
    10.1 Application Event Spring使用Application Event给bean之间的消息通讯提供了手段 应按照如下部分实现bean之间的消息通讯 继承ApplicationEvent类实现自己的事件 实现继承ApplicationListener接口实现监听事件 使用ApplicationContext发布消息
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他