当前位置： 首页 > article >正文

解析十六进制雷达数据格式：解析雷达FSPEC数据

article 2024/11/14 20:10:15

以Cat62格式雷达数据为例，十六进制雷达数据部分代码：

3e0120bf7da4ffee0085

base_fspec_processor.h

//
// Created by qiaowei on 2024-02-03.
//

#ifndef RADARDATACONTROLLER_BASE_FSPEC_PROCESSOR_H
#define RADARDATACONTROLLER_BASE_FSPEC_PROCESSOR_H


#include <QVector>
#include <QString>


namespace processor {

    class BaseFspecProcessor {

    public:
        virtual QVector<int>* processor(const QString& content,
                                        int begin_position_index,
                                        int& end_position_index) = 0;
    };

} // processor

#endif //RADARDATACONTROLLER_BASE_FSPEC_PROCESSOR_H

cat62_fspec_processor.h

//
// Created by qiaowei on 2024-01-25.
//


#ifndef RADARDATACONTROLLER_CAT62_FSPEC_PROCESSOR_H
#define RADARDATACONTROLLER_CAT62_FSPEC_PROCESSOR_H


#include <QObject>
#include <QVector>
#include <QList>

#include "../baseprocess/base_fspec_processor.h"


namespace processor {

    /**
     * @copyright 2003-2024
     * @date      2024-02-09 22:40
     * @author    qiao wei
     * @version   1.0
     * @brief     处理十六进制雷达数据的FSPEC数据。
     * @history
     */
    class Cat62FspecProcessor : public QObject, public BaseFspecProcessor {

        Q_OBJECT

    public:
        explicit Cat62FspecProcessor(QObject* parent = nullptr);

        virtual ~Cat62FspecProcessor() override;

        /**
         * @author  qiao wei
         * @brief   从雷达数据hex_track_data中读取FSPEC数据。将FSPEC数据按照二进制格式保存到QVector<int>指针并返回。
         * @param   hex_track_data 十六进制雷达数据。
         * @param   begin_position FSPEC数据的起始索引。
         * @param   readed_data_end_position FSPEC数据的末位索引。
         * @return  QVector<int>指针。二进制格式保存的FSPEC数据。
         * @history
         */
        virtual QVector<int>* processor(const QString& hex_track_data,
                                        int begin_position,
                                        int& readed_data_end_position) override;

    private:
        /**
         * @author  qiao wei
         * @brief   将存储FSPEC内容由十六进制的字符串转换为二进制的QVector<int>*。
         * @param   fspec_content FSPEC内容字符串。
         * @param   count FSPEC内容的字节数。因为参数content是2个字符组成1个字节，所以count数为字符串中字符数量的一半。
         * @return  FSPEC内容转换为二进制的QVector<int>*。
         * @history
         */
        QVector<int>* convertFspecToIntArray(QString fspec_content);

        /**
         * @author  qiao wei
         * @brief   将int数据value以二进制数的格式保存到容器vector的指定位置处。
         *          传入的value是1个字节，将其转换为8位二进制数从左向右保存，因为每次只能保存1个字节的数据，保存多个
         *          字节的数据需要依次保存到容器vector中。
         * @param   vector 存储二进制数的容器。
         * @param   value FSPES数据中的1个字节。
         * @param   begin_position 将字节value转换成二进制数保存到容器vector的第一位索引。
         * @return
         * @history
         */
        virtual void replaceBinaryValueToContainer(QVector<int>* vector, int value, int begin_position);

        /**
         * @author  qiao wei
         * @brief   分步骤读取十六进制雷达数据track_data中的FSPEC数据，返回起始索引begin_position的1个字节FSPEC数据。
         * @param   track_data 十六进制雷达数据。
         * @param   begin_position 读取FSPEC数据的首位索引。
         * @param   readed_data_end_position 读取FSPEC数据的末位索引，该参数为引用类型。
         * @return  返回读取的1个字节FSPEC数据，如果数据读取异常则返回""。
         * @history
         */
        QString readAByteFspec(const QString& track_data,
                               int begin_position,
                               int& readed_data_end_position);

        /**
         * @author  qiao wei
         * @brief   将完整的FSPEC数据从雷达数据中读取出。
         * @param   track_data 十六进制雷达数据。
         * @param   begin_position_index FSPEC在track_data中的起始索引。
         * @return  FSPEC数据。
         * @history
         */
        QString readFspecContent(const QString& track_data,
                                 int begin_position_index);

        /**
         * @author  qiao wei
         * @brief   判断1个字节的数据是否是FSPEC数据的最后1个字节。
         * @param   a_byte_fspec_content 1个字节的FSPEC数据。
         * @return  true 已到FSPEC数据末位。
         * @history
         */
        bool isTheLastValueOfFspec(QString a_byte_fspec_content);

    private:
        /**
         * @author qiao wei
         * @brief  标识位，通过与运算判断字节最后一位是否为0。0b0000,0001。
         */
        const static int THE_0_POSITION_VALUE;

        /**
         * @author qiao wei
         * @brief  0b1000,0000。
         */
        const static int THE_7_POSITION_VALUE;
    };

} // processor

#endif //RADARDATACONTROLLER_CAT62_FSPEC_PROCESSOR_H

base_fspec_processor.cpp

//
// Created by qiaowei on 2024-01-25.
//


#include <QtDebug>

#include "cat62_fspec_processor.h"


namespace processor {

    const int Cat62FspecProcessor::THE_0_POSITION_VALUE{1};

    const int Cat62FspecProcessor::THE_7_POSITION_VALUE{128};

    Cat62FspecProcessor::Cat62FspecProcessor(QObject* parent) : QObject(parent) {}

    Cat62FspecProcessor::~Cat62FspecProcessor() {}

    QVector<int>* Cat62FspecProcessor::processor(const QString& hex_track_data,
                                                 int begin_position,
                                                 int& readed_data_end_position) {
        /**
         * 1：从hex_track_data数据中读取完整的FSPEC数据。
         * 1.1：从begin_position索引开始，依次读取2个字符（1个字节）。
         * 1.2：判断读取的2个字符是否是FSPEC数据结尾。
         * 1.3：将读取的2个字符依次添加到同一个字符串中，如果到了FSPEC数据结尾，则不再读取数据。
         * 2：将FSPEC数据转换成int类型，保存到QVector<int>*容器。
         * 3：返回QVect<int>*容器。
         */

        readed_data_end_position = begin_position;

        // 保存hex_track_data数据中指定位置的FSPEC数据。
        QString fspec_content = readFspecContent(hex_track_data, begin_position);

        readed_data_end_position = readed_data_end_position + fspec_content.length() - 1;
        QVector<int>* fspec_vector = convertFspecToIntArray(fspec_content);

        return fspec_vector;
    }

    QVector<int>* Cat62FspecProcessor::convertFspecToIntArray(QString fspec_content) {
        /**
         * 雷达数据中，2个字符表示1个字节。
         * 根据字节数设置对应的QVector<int>*容量。1个字节是8位二进制数。
         */
        // 获取FSPEC数据中字节个数。
        int byte_count{fspec_content.length() / 2};
        QVector<int>* vector{new QVector<int>(byte_count * 8)};

        const int step{2};
        int begin_position_index{0};
        int value{0};

        for (int index{0}; index != byte_count; ++index) {
            value = fspec_content.mid(begin_position_index, step).toInt(nullptr, 16);

            replaceBinaryValueToContainer(vector, value, index * 8);
            begin_position_index += step;
        }

        return vector;
    }

    void Cat62FspecProcessor::replaceBinaryValueToContainer(QVector<int>* vector,
                                                            int value,
                                                            int begin_position) {
        // 遍历1个字节所有位的次数。
        const int count{8};

        /**
         * 1：依次遍历value值的每一位（8位二进制，从左侧高位开始依次遍历），并将二级制值保存到容器vector。
         * 2：右移1位。依次读取value中每一位二进制值。
         */
        for (int index{0}; index != 8; ++index) {
            vector->replace(begin_position + index,
                            ((THE_7_POSITION_VALUE == (value & THE_7_POSITION_VALUE)) ? 1 : 0));
            value = value<<1;
        }
    }

    QString Cat62FspecProcessor::readAByteFspec(const QString& track_data,
                                                int begin_position,
                                                int& readed_data_end_position) {
        readed_data_end_position = begin_position;
        QString content{track_data.mid(begin_position, 2)};

        // 当前数据的末位索引。“+2”是当前数据末位下一位的索引，所以要减1。保证数据与参数名一致。
        readed_data_end_position = begin_position + 2 - 1;

        /**
         * 判断读取的1个字节（2个字符）的FSPEC数据是否为空，是否读取到的是1个字节。如果以上条件满足，返回
         * 字符串content，反之返回""。
         */
        if (!content.isNull() && 2 == content.length()) {
            return content;
        } else {
            return "";
        }
    }

    QString Cat62FspecProcessor::readFspecContent(const QString& track_data,
                                                  int begin_position_index) {
        int end_position_index{begin_position_index};
        QString fspec_content;
        QString a_byte_fspec_content;

        /**
         * 从雷达数据track_data中依次读取1个字节FSPEC数据，将数据保存到字符串fspec_content。
         * 判断是否是FSPEC最后一个字节，如果不是继续读取FSPEC数据，反之退出循环。
         */
        while (true) {
            a_byte_fspec_content =
                readAByteFspec(track_data,
                               begin_position_index,
                               end_position_index);

            begin_position_index = end_position_index + 1;
            fspec_content.append(a_byte_fspec_content);

            if (isTheLastValueOfFspec(a_byte_fspec_content)) {
                break;
            }
        }

        return fspec_content;
    }

    bool Cat62FspecProcessor::isTheLastValueOfFspec(QString a_byte_fspec_content) {
        int value{a_byte_fspec_content.toInt(nullptr, 16)};

        return ((THE_0_POSITION_VALUE & value) == THE_0_POSITION_VALUE) ? false : true;
    }

} // processor

main.cpp

#include <string>

#include <QApplication>
#include <QVector>
#include <QtDebug>
#include <QString>

#include "./form/main_window.h"
#include "./cat62process/cat62_fspec_processor.h"
#include "./cat62process/cat_62_length_processor.h"
#include "./cat62process/cat_62_header_processor.h"


using std::string;

using form::MainWindow;
using processor::Cat62FspecProcessor;
using processor::Cat62HeaderProcessor;
using processor::Cat62LengthProcessor;


int main(int argc,
         char *argv[]) {
    QApplication a(argc, argv);

//    MainWindow* main_window{new MainWindow{nullptr}};
//    main_window->show();

    QString content = "3e0120bf7da4ffee00859880007205a0";

    int begin_position{0};
    int end_position = begin_position;
    Cat62HeaderProcessor* header_processor{new Cat62HeaderProcessor{}};
    qDebug()<< header_processor->processor(content, begin_position, end_position);
    qDebug()<< "Header end position: " << end_position;

    begin_position = end_position + 1;
    Cat62LengthProcessor* lenght_processor{new Cat62LengthProcessor{}};
    qDebug()<< lenght_processor->processor(content, begin_position, end_position);
    qDebug()<< "Length end position: " << end_position;

    begin_position = end_position + 1;
    Cat62FspecProcessor* fspec_processor{new Cat62FspecProcessor{}};
    QVector<int>* vector = fspec_processor->processor(content, begin_position, end_position);

    for (int index = 0; index < vector->capacity(); ++index) {
        qDebug()<< index << ": " << vector->at(index) << ", ";
    }

    qDebug()<< "FSPEC end position: " << end_position;

    return QApplication::exec();
}

运行结果：


http://www.kler.cn/a/233711.html

相关文章：

  • 应用于新能源汽车NCV4275CDT50RKG车规级LDO线性电压调节器芯片
  • 【OH】openHarmony开发环境搭建（基于windows子系统WSL）
  • 爱普生SG-8200CJ可编程晶振在通信设备中的应用
  • influxDB 时序数据库安装 flux语法 restful接口 nodjsAPI
  • 深入理解BERT模型配置：BertConfig类详解
  • FatLab：我的编程课程系列
  • c语言内存对齐
  • Maui blazor ios 按设备类型设置是否启用safeArea
  • 思科模拟器命令大全详解
  • 当AGI遇到人形机器人
  • Lua可变参数函数
  • 使用virtualenv管理python环境
  • 如何将ChatGPT升级到4.0版本？如何充值？
  • Acwing---837. 连通块中点的数量
  • PCB板 3.3V和GND导通原因
  • 【NICN】之计算一个数的每位之和（递归实现）
  • Dubbo源码一：【Dubbo与Spring整合】
  • C语言中的宏定义：从常量到高级技巧
  • 十、项目开发总结报告（软件工程）
  • ubuntu篇---ubuntu安装python3.9
  • “深度解析Java虚拟机：运行时数据区域、垃圾收集、内存分配与回收策略、类加载机制“
  • 【前端高频面试题--TypeScript篇】
  • 从Unity到Three.js（画线组件line）
  • 微软AD域替代方案，助力企业摆脱hw期间被攻击的窘境
  • 【MySQL】-12 MySQL索引（上篇MySQL索引类型前置-2-高性能的索引策略）
  • Linux应用 进程间通信之共享内存(System V)