txtBINhex转换工具

最新推荐文章于 2024-05-29 09:02:53 发布
最新推荐文章于 2024-05-29 09:02:53 发布
阅读量1.2k 收藏 1
点赞数 1
文章标签： qt 格式工厂
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DENGFAMAN/article/details/131982928
版权

       近来抽时间写了一个txt、bin、hex格式互转工具，由其中一种格式生成对应名称的其他两种格式文件。记录一下。

平台：Qt Creator 10.0.2

QT版本：Qt 6.2.4 (MinGW 11.2.0 64bit)

下面是widget.cpp原码：

#include <QRegularExpressionValidator>
#include "widget.h"
#include "ui_widget.h"

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    ui->groupBox->setTitle("");//不显示groupBox名
    ui->plaTxtEdit_hexBaseAddr->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); // 禁用垂直滚动条
    ui->plaTxtEdit_hexBaseAddr->setStyleSheet("background-color: #FFFFFF; color:black; font-family:\"Helvetica\"; font-size:28px;");
    hex_base_addr = "00000000";
    ui->plaTxtEdit_hexBaseAddr->setPlainText(hex_base_addr);
    //show pictures of supported txt format
    QPixmap pixmap1(":/new/prefix1/txt_examp1.png");
    QSize p1Sz = pixmap1.size();
    ui->exampPic1->setFixedSize(p1Sz);//根据图片大小来显示
    ui->exampPic1->setPixmap(pixmap1);
    ui->exampPic1->show();
    QPixmap pixmap2(":/new/prefix1/txt_examp2.png");
    QSize p2Sz = pixmap2.size();
    ui->exampPic2->setFixedSize(p2Sz);
    ui->exampPic2->setPixmap(pixmap2);
    ui->exampPic2->show();
}

Widget::~Widget()
{
    delete ui;
}

typedef enum
{
    NONE_FILE_TYPE,
    BIN_FILE,
    HEX_FILE,
    TXT_FILE,
    OTHER_FILE_TYPE
}OpenedFileType;

typedef enum
{
    NORMAL_DATA,
    HEX_FILE_END,
    EXPAND_ADDR,
    BEGIN_ADDR,
    EXPAND_LINE_ADDR,
    BEGIN_LINE_ADDR
}HexDataType;

void Widget::on_pushButton_select_clicked()
{
    QString curPath = QDir::currentPath(); //获取应用程序当前目录
    QString dlgTitle = "打开一个文件"; //设置对话框名称
    QString fileFilter = "文本文件(*.txt);;二进制文件(*.bin);;十六进制文件(*.hex)"; //设置过滤文件类型
    QString objFileName = QFileDialog::getOpenFileName(this, dlgTitle, curPath, fileFilter);

    if (objFileName.isEmpty())
        return;

    ui->plainTextEdit->setPlainText(objFileName);
    openByIO_Whole(objFileName);
}

unsigned char char_to_hex_transfer(char preTransfer)
{
    unsigned char result = 0;
    if (preTransfer >= 0x30 && preTransfer <= 0x39) // 0~9
    {
        result = preTransfer - 0x30;
    }
    else if (preTransfer >= 0x41 && preTransfer <= 0x46) //A ~ F
    {
        result = preTransfer - 0x41 + 0x0A;
    }
    else if (preTransfer >= 0x61 && preTransfer <= 0x66) //a ~ f
    {
        result = preTransfer - 0x61 + 0x0A;
    }
    return result;
}

unsigned char decToChar_transfer(unsigned char preTranData)
{
    if (preTranData <= 9)
    {
        return preTranData + 0x30;
    }
    else if (preTranData < 16)
    {
        return preTranData - 10 + 0x41;
    }

    return 0x30;
}

/* hex文件解析
 *   02     0000      04      0001 F9
 * 数据长度 数据写入地址 数据类型 数据  校验
 * 数据类型：00数据，01文件结束，02扩展段地址，03开始段地址，04扩展线性地址，05开始线性地址
 */
void charToByte_Transfer(unsigned char *write_buff, char * read_buff, int size)
{
    for (int ind = 0; ind < size; ind ++)
    {
        if (ind % 2)
            write_buff[ind/2] |= char_to_hex_transfer(read_buff[ind]);
        else
            write_buff[ind/2] = (char_to_hex_transfer(read_buff[ind])) << 4;
    }
}

uint Widget::hexToBin_Transfer(uint readSize, unsigned char *org_buff, char *obj_buff)
{
    uint realSize = 0;
    int data_len = 0; //record the length of one line data
    unsigned int data_addr = 0;//record the address of one line data
    unsigned int curr_data_addr = 0; // point to address that next data going write to
    unsigned char hex_buff[16] = {0};
    HexDataType data_type = NORMAL_DATA;
    for (uint i = 0; i < readSize; i ++)
    {
        if (org_buff[i] == ':') //begin of line
        {
            data_len = (org_buff[i+1] - 0x30) * 16 + org_buff[i+2] - 0x30;
            data_type = (HexDataType)(org_buff[i+8] - 0x30);
        }
        else
            continue;
        switch(data_type)
        {
        case NORMAL_DATA:
            curr_data_addr = char_to_hex_transfer(org_buff[i + 3]) << 12;
            curr_data_addr |= char_to_hex_transfer(org_buff[i + 4]) << 8;
            curr_data_addr |= char_to_hex_transfer(org_buff[i + 5]) << 4;
            curr_data_addr |= char_to_hex_transfer(org_buff[i + 6]);
            charToByte_Transfer(hex_buff, (char *)(org_buff + i + 9), data_len*2);
            memcpy(obj_buff + data_addr + curr_data_addr, hex_buff, data_len);
            realSize += data_len;
            break;
        case HEX_FILE_END:

            break;
        case EXPAND_ADDR:
            data_addr = char_to_hex_transfer(org_buff[i + 9]) << 12;
            data_addr |= char_to_hex_transfer(org_buff[i + 10]) << 8;
            data_addr |= char_to_hex_transfer(org_buff[i + 11]) << 4;
            data_addr |= char_to_hex_transfer(org_buff[i + 12]);
            data_addr <<= 2;
            break;
        case EXPAND_LINE_ADDR:
            data_addr = char_to_hex_transfer(org_buff[i + 9]) << 12;
            data_addr |= char_to_hex_transfer(org_buff[i + 10]) << 8;
            data_addr |= char_to_hex_transfer(org_buff[i + 11]) << 4;
            data_addr |= char_to_hex_transfer(org_buff[i + 12]);
            data_addr <<= 16;
            break;
        default:
            break;
        }
    }

    return realSize;
}

uint Widget::binToTxt_Transfer(uint readSize, unsigned char *org_buff, char *obj_buff)
{
    uint realSize = 0, lst_realSize = 0;
    char tmp_data = 0;
    char mid_data = 0;
    for (uint i = 0; i < readSize; i ++)
    {
        obj_buff[realSize] = '0';
        obj_buff[realSize + 1] = 'x';
        realSize += 2;
        mid_data = org_buff[i] >> 4;
        if (mid_data >= 0 && mid_data <= 9) // 0~9
        {
            tmp_data = mid_data + 0x30;
        }
        else if (mid_data >= 0x0A && mid_data <= 0x0F) //A ~ F
        {
            tmp_data = mid_data - 0x0A + 0x41;
        }
        obj_buff[realSize] = tmp_data;
        realSize ++;
        mid_data = org_buff[i] & 0x0f;
        if (mid_data >= 0 && mid_data <= 9) // 0~9
        {
            tmp_data = mid_data + 0x30;
        }
        else if (mid_data >= 0x0A && mid_data <= 0x0F) //A ~ F
        {
            tmp_data = mid_data - 0x0A + 0x41;
        }

        obj_buff[realSize] = tmp_data;
        obj_buff[realSize + 1] = ',';
        realSize += 2;

        if ((realSize - lst_realSize) == 80) //go to next line per 16bytes
        {
            obj_buff[realSize] = '\r';
            obj_buff[realSize + 1] = '\n';
            realSize += 2;
            lst_realSize = realSize;
        }
    }

    return realSize;
}

void hexFileLineChecksumCalc_func(char *cal_buff)
{
    unsigned short checksum = 0;
    unsigned char test_data = 0;
    int data_length = char_to_hex_transfer(cal_buff[2]) + ((char_to_hex_transfer(cal_buff[1])) << 4);
    //wrong data, return immediately
    if (data_length > 16)
        return;
    checksum = data_length;
    data_length = data_length * 2 + 9;
    for (int i = 3; i < data_length; i += 2)
    {
        test_data = char_to_hex_transfer(cal_buff[i + 1]) + ((char_to_hex_transfer(cal_buff[i])) << 4);
        checksum += test_data;
    }

    checksum = 0x100 - checksum%0x100;
    cal_buff[data_length] = decToChar_transfer((checksum >> 4) & 0x0f);
    cal_buff[data_length + 1] = decToChar_transfer(checksum & 0x0f);
}

uint Widget::binToHex_Transfer(uint readSize, unsigned char *org_buff, char *obj_buff, unsigned int base_addr)
{
    uint firstLineSize = 0, ri = 0, wi = 0;
    unsigned short tmp_addr = 0, data_addr = 0;
    unsigned char tmp_data = 0;
//    char mid_data = 0;
    const char first_line[] = {':','0','2','0','0','0','0','0','4','0','0','0','0','F','A','\r','\n'};
    const char end_line[] = {':','0','0','0','0','0','0','0','1','F','F'};

    tmp_addr = base_addr >> 16;
    data_addr = base_addr & 0xffff;
    firstLineSize = sizeof(first_line);
    memcpy(obj_buff, first_line, firstLineSize);
    obj_buff[9] = decToChar_transfer((tmp_addr >> 12) & 0x0f);
    obj_buff[10] = decToChar_transfer((tmp_addr >> 8) & 0x0f);
    obj_buff[11] = decToChar_transfer((tmp_addr >> 4) & 0x0f);
    obj_buff[12] = decToChar_transfer(tmp_addr & 0x0f);
    hexFileLineChecksumCalc_func(obj_buff);
    wi = firstLineSize;
    while (ri < readSize)
    {
        obj_buff[wi] = ':';
        tmp_data = (readSize - ri) >= 16?(16):(readSize - ri);
        if (tmp_data >= 16)
        {
            tmp_data = 16;
            obj_buff[wi + 1] = 0x31; // '1'
            obj_buff[wi + 2] = 0x30; // '0'
        }
        else
        {
            obj_buff[wi + 1] = decToChar_transfer((tmp_data >> 4) & 0x0f);
            obj_buff[wi + 2] = decToChar_transfer(tmp_data & 0x0f);
        }
        obj_buff[wi + 3] = decToChar_transfer((data_addr >> 12) & 0x0f);
        obj_buff[wi + 4] = decToChar_transfer((data_addr >> 8) & 0x0f);
        obj_buff[wi + 5] = decToChar_transfer((data_addr >> 4) & 0x0f);
        obj_buff[wi + 6] = decToChar_transfer(data_addr & 0x0f);
        obj_buff[wi + 7] = 0x30; //'0'
        obj_buff[wi + 8] = 0x30; //'0'
        wi += 9;
        for (int j = 0; j < tmp_data; j ++)
        {
            obj_buff[wi] = decToChar_transfer((org_buff[ri] >> 4) & 0x0f);
            wi ++;
            obj_buff[wi] = decToChar_transfer(org_buff[ri] & 0x0f);
            wi ++;
            ri ++;
        }

        hexFileLineChecksumCalc_func(obj_buff + wi - tmp_data*2 - 9);
        wi += 2;
        obj_buff[wi] = '\r';
        obj_buff[wi + 1] = '\n';
        wi += 2;

        if (data_addr + tmp_data > 0xffff)
        {
            tmp_addr += 1;  //increase 0x10000 offset
            memcpy(obj_buff + wi, first_line, firstLineSize);
            obj_buff[wi + 9] = decToChar_transfer((tmp_addr >> 12) & 0x0f);
            obj_buff[wi + 10] = decToChar_transfer((tmp_addr >> 8) & 0x0f);
            obj_buff[wi + 11] = decToChar_transfer((tmp_addr >> 4) & 0x0f);
            obj_buff[wi + 12] = decToChar_transfer(tmp_addr & 0x0f);
            hexFileLineChecksumCalc_func(obj_buff + wi);
            wi += firstLineSize;
            data_addr = data_addr + tmp_data - 0x10000;
        }
        else
            data_addr += tmp_data;
    }
    memcpy(obj_buff + wi, end_line, sizeof(end_line));

    return wi + sizeof(end_line);
}

uint Widget::txtToBin_Transfer(uint readSize, char *org_buff, char *obj_buff)
{
    uint realSize = 0;
    char tmp_data = 0;
    for (uint i = 0; i < readSize; i ++)
    {
        if (org_buff[i] == '0' && (org_buff[i + 1] == 'x' || org_buff[i + 1] == 'X'))
        {
            i ++;
            continue;
        }
        else if (org_buff[i] >= 0x30 && org_buff[i] <= 0x39) // 0~9
        {
            tmp_data = org_buff[i] - 0x30;
        }
        else if (org_buff[i] >= 0x41 && org_buff[i] <= 0x46) //A ~ F
        {
            tmp_data = org_buff[i] - 0x41 + 0x0A;
        }
        else if (org_buff[i] >= 0x61 && org_buff[i] <= 0x66) //a ~ f
        {
            tmp_data = org_buff[i] - 0x61 + 0x0A;
        }
        else
            continue;
        if (realSize % 2 == 0)
            obj_buff[realSize/2] = tmp_data << 4;
        else
        {
            obj_buff[realSize/2] |= tmp_data;
        }
        realSize ++;
    }

    return realSize/2;
}

bool Widget::openByIO_Whole(const QString &tgtFileName)
{
    QString objFile1, objFile2, tmpQStrFileName;
    uint readSize = 0, writeSize_file1 = 0, writeSize_file2 = 0;
    unsigned int hex_start_addr = 0;
    bool ok;
    char *tmp_buff = NULL, *obj_buff1 = NULL, *obj_buff2 = NULL;
    QByteArray org_file_byte_array;
    OpenedFileType fileType = NONE_FILE_TYPE;
    fileDevice = new QFile(tgtFileName);

    if (!fileDevice->exists())
        return false;
    if (!fileDevice->open(QIODevice::ReadOnly))
        return false;

    tmpQStrFileName = tgtFileName;

    if (tgtFileName.endsWith("txt"))
    {
        objFile1 = tmpQStrFileName.replace(".txt", ".bin");
        objFile2 = tmpQStrFileName.replace(".bin", ".hex");
        fileType = TXT_FILE;
    }
    else if (tgtFileName.endsWith("bin"))
    {
        objFile1 = tmpQStrFileName.replace(".bin", ".txt");
        objFile2 = tmpQStrFileName.replace(".txt", ".hex");
        fileType = BIN_FILE;
    }
    else if (tgtFileName.endsWith("hex"))
    {
        objFile1 = tmpQStrFileName.replace(".hex", ".bin");
        objFile2 = tmpQStrFileName.replace(".bin", ".txt");
        fileType = HEX_FILE;
    }
    else if (tgtFileName.endsWith("TXT"))
    {
        objFile1 = tmpQStrFileName.replace(".TXT", ".bin");
        objFile2 = tmpQStrFileName.replace(".bin", ".hex");
        fileType = TXT_FILE;
    }
    else if (tgtFileName.endsWith("BIN"))
    {
        objFile1 = tmpQStrFileName.replace(".BIN", ".txt");
        objFile2 = tmpQStrFileName.replace(".txt", ".hex");
        fileType = BIN_FILE;
    }
    else if (tgtFileName.endsWith("HEX"))
    {
        objFile1 = tmpQStrFileName.replace(".HEX", ".bin");
        objFile2 = tmpQStrFileName.replace(".bin", ".txt");
        fileType = HEX_FILE;
    }
    ui->label_oprtTip->setText("正在读取文件");
    fileStream = new QDataStream(fileDevice);
    fileStream->setVersion(QDataStream::Qt_6_2);
    fileStream->setByteOrder(QDataStream::LittleEndian);
//    fileStream->readRawData(ch,strLen);
    readSize = fileDevice->size();
//    fileStream->readRawData(tmp_buff, readSize);

    switch(fileType)
    {
    case BIN_FILE:
        obj_buff1 = (char *)malloc(readSize*5 + readSize/16*2);
        if (obj_buff1 == NULL)
        {
            ui->label_oprtTip->setText("申请内存失败！");
            return false;
        }
        tmp_buff = (char *)malloc(readSize);
        if (tmp_buff == NULL)
        {
            ui->label_oprtTip->setText("申请内存失败！");
            return false;
        }
        fileStream->readRawData(tmp_buff, readSize);
        writeSize_file1 = binToTxt_Transfer(readSize, (unsigned char*)tmp_buff, obj_buff1);

        hex_start_addr = hex_base_addr.toInt(&ok, 16);
        obj_buff2 = (char *)malloc((readSize+7)*3);
        if (obj_buff2 == NULL)
        {
            ui->label_oprtTip->setText("申请内存失败！");
            return false;
        }
        writeSize_file2 = binToHex_Transfer(readSize, (unsigned char*)tmp_buff, obj_buff2, hex_start_addr);
        free(tmp_buff);
        tmp_buff = NULL;
        break;
    case HEX_FILE:
        org_file_byte_array = fileDevice->readAll();
        tmp_buff = org_file_byte_array.data();
        obj_buff1 = (char *)malloc(readSize/2);
        if (obj_buff1 == NULL)
        {
            ui->label_oprtTip->setText("申请内存失败！");
            return false;
        }
        writeSize_file1 = hexToBin_Transfer(readSize, (unsigned char*)tmp_buff, obj_buff1);

        obj_buff2 = (char *)malloc(writeSize_file1*5 + writeSize_file1/16*2);
        if (obj_buff2 == NULL)
        {
            ui->label_oprtTip->setText("申请内存失败！");
            return false;
        }
        writeSize_file2 = binToTxt_Transfer(writeSize_file1, (unsigned char*)obj_buff1, obj_buff2);
        break;
    case TXT_FILE:
        org_file_byte_array = fileDevice->readAll();
        tmp_buff = org_file_byte_array.data();
        obj_buff1 = (char *)malloc(readSize/2);
        if (obj_buff1 == NULL)
        {
            ui->label_oprtTip->setText("申请内存失败！");
            return false;
        }
        writeSize_file1 = txtToBin_Transfer(readSize, tmp_buff, obj_buff1);

        hex_start_addr = hex_base_addr.toInt(&ok, 16);
        obj_buff2 = (char *)malloc((writeSize_file1+7)*3);
        if (obj_buff2 == NULL)
        {
            ui->label_oprtTip->setText("申请内存失败！");
            return false;
        }
        writeSize_file2 = binToHex_Transfer(writeSize_file1, (unsigned char*)obj_buff1, obj_buff2, hex_start_addr);
        break;
    default:
        break;
    }

    ui->label_oprtTip->setText("读取完成");
    fileDevice->close();

    QFile *File1_handle = new QFile(objFile1);
    if (!File1_handle->open(QIODevice::WriteOnly))
        return false;
    fileStream = new QDataStream(File1_handle);
    fileStream->setVersion(QDataStream::Qt_6_2);
    fileStream->setByteOrder(QDataStream::LittleEndian);
    fileStream->writeRawData(obj_buff1, writeSize_file1);
    File1_handle->close();
    delete fileStream;
    delete File1_handle;

    QFile *File2_handle = new QFile(objFile2);
    if (!File2_handle->open(QIODevice::WriteOnly))
        return false;
    fileStream = new QDataStream(File2_handle);
    fileStream->setVersion(QDataStream::Qt_6_2);
    fileStream->setByteOrder(QDataStream::LittleEndian);
    fileStream->writeRawData(obj_buff2, writeSize_file2);
    File2_handle->close();
    delete fileStream;
    delete File2_handle;
    if (obj_buff1 != NULL)
    {
        free(obj_buff1);
        obj_buff1 = NULL;
    }
    if (obj_buff2 != NULL)
    {
        free(obj_buff2);
        obj_buff2 = NULL;
    }
    ui->label_oprtTip->setText("转换完成");

    return true;
}

void Widget::on_plaTxtEdit_hexBaseAddr_textChanged()
{
    bool ok;
    hex_base_addr = ui->plaTxtEdit_hexBaseAddr->toPlainText();
    //user only can input letter or number all 8 characters
    QRegularExpression expre("^[A-Fa-f0-9]{1,8}$");

    if (!expre.match(hex_base_addr).hasMatch())
    {
        if (hex_base_addr.length() > 0)
        {
            hex_base_addr = hex_base_addr.left(hex_base_addr.length() - 1);
            ui->plaTxtEdit_hexBaseAddr->setPlainText(hex_base_addr);
        }
        else
        {
            hex_base_addr = "00000000";
            ui->plaTxtEdit_hexBaseAddr->setPlainText(hex_base_addr);
        }
    }
    qDebug()<<hex_base_addr.toInt(&ok, 16);
}

main.cpp代码如下：

#include "widget.h"

#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Widget w;
    w.setWindowTitle("格式转换器");
    w.show();
    return a.exec();
}

widget.h代码如下：

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QFileDialog>

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();
    uint txtToBin_Transfer(uint readSize, char *org_buff, char *obj_buff);
    uint binToTxt_Transfer(uint readSize, unsigned char *org_buff, char *obj_buff);
    uint hexToBin_Transfer(uint readSize, unsigned char *org_buff, char *obj_buff);
    uint binToHex_Transfer(uint readSize, unsigned char *org_buff, char *obj_buff, unsigned int base_addr);

private slots:
    void on_pushButton_select_clicked();
    bool openByIO_Whole(const QString &tgtFileName);

    void on_plaTxtEdit_hexBaseAddr_textChanged();

private:
    Ui::Widget *ui;
    QDataStream *fileStream;
    QFile *fileDevice;
    QString hex_base_addr;
};
#endif // WIDGET_H

widget.ui代码如下

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>Widget</class>
 <widget class="QWidget" name="Widget">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>800</width>
    <height>600</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Widget</string>
  </property>
  <widget class="QGroupBox" name="groupBox">
   <property name="geometry">
    <rect>
     <x>20</x>
     <y>60</y>
     <width>751</width>
     <height>161</height>
    </rect>
   </property>
   <property name="title">
    <string>GroupBox</string>
   </property>
   <widget class="QPlainTextEdit" name="plainTextEdit">
    <property name="geometry">
     <rect>
      <x>10</x>
      <y>44</y>
      <width>621</width>
      <height>51</height>
     </rect>
    </property>
   </widget>
   <widget class="QPushButton" name="pushButton_select">
    <property name="geometry">
     <rect>
      <x>650</x>
      <y>70</y>
      <width>93</width>
      <height>28</height>
     </rect>
    </property>
    <property name="text">
     <string>打开</string>
    </property>
   </widget>
   <widget class="QPlainTextEdit" name="plaTxtEdit_hexBaseAddr">
    <property name="geometry">
     <rect>
      <x>50</x>
      <y>110</y>
      <width>151</width>
      <height>41</height>
     </rect>
    </property>
   </widget>
   <widget class="QLabel" name="label0x">
    <property name="geometry">
     <rect>
      <x>10</x>
      <y>110</y>
      <width>41</width>
      <height>41</height>
     </rect>
    </property>
    <property name="font">
     <font>
      <pointsize>16</pointsize>
     </font>
    </property>
    <property name="text">
     <string>0x</string>
    </property>
    <property name="alignment">
     <set>Qt::AlignCenter</set>
    </property>
   </widget>
   <widget class="QLabel" name="addrInputTip">
    <property name="geometry">
     <rect>
      <x>220</x>
      <y>120</y>
      <width>351</width>
      <height>31</height>
     </rect>
    </property>
    <property name="font">
     <font>
      <pointsize>11</pointsize>
     </font>
    </property>
    <property name="text">
     <string>HEX数据起始地址，输入后不需要按Enter键。</string>
    </property>
   </widget>
  </widget>
  <widget class="QLabel" name="label_oprtTip">
   <property name="geometry">
    <rect>
     <x>90</x>
     <y>230</y>
     <width>521</width>
     <height>41</height>
    </rect>
   </property>
   <property name="font">
    <font>
     <pointsize>12</pointsize>
    </font>
   </property>
   <property name="text">
    <string>请选择要转换的文件</string>
   </property>
   <property name="alignment">
    <set>Qt::AlignCenter</set>
   </property>
  </widget>
  <widget class="QLabel" name="exampPic1">
   <property name="geometry">
    <rect>
     <x>70</x>
     <y>360</y>
     <width>69</width>
     <height>19</height>
    </rect>
   </property>
   <property name="text">
    <string>示例1</string>
   </property>
  </widget>
  <widget class="QLabel" name="exampPic2">
   <property name="geometry">
    <rect>
     <x>70</x>
     <y>470</y>
     <width>69</width>
     <height>19</height>
    </rect>
   </property>
   <property name="text">
    <string>示例2</string>
   </property>
  </widget>
  <widget class="QLabel" name="txt_type_tip">
   <property name="geometry">
    <rect>
     <x>70</x>
     <y>308</y>
     <width>281</width>
     <height>41</height>
    </rect>
   </property>
   <property name="text">
    <string>txt文件仅支持以下两种格式</string>
   </property>
  </widget>
 </widget>
 <resources/>
 <connections/>
</ui>

QT工程文件代码如下

QT       += core gui

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

CONFIG += c++17

# You can make your code fail to compile if it uses deprecated APIs.
# In order to do so, uncomment the following line.
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0

SOURCES += \
    main.cpp \
    widget.cpp

HEADERS += \
    widget.h

FORMS += \
    widget.ui

RC_ICONS = tubiao.ico
# Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target

RESOURCES += \
    txtPic.qrc

运行效果如图所示

 

forrestDun
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
BIN文件转为TXT文件工具
10-08
因为前几天用到BIN转为TXT，苦于没有合适工具，自己写了一个，送给有用的朋友吧
Bin与Hex互转软件(软件最大支持64k大小Bin文件)
06-15
软件最大支持64k大小Bin文件
HEX文件转化成Txt文件工具_HEX2Txt.rar
07-31
采用C#语言编写，VS2010工具编译，可以将.hex文件转换成.txt文件，将.hex文件中的数据提取到.txt文件中，每行显示一个数据，可选择1byte/2byte/4byte转换方式。
【bin txt】数据读取-转换格式-保存
计算机视觉方面的点点滴滴，欢迎一起讨论
12-27 814
总是看到.bin后缀名的输入文件，怎么知道它里面数据到底是多少呢？可以通过如下方式将.bin数据转换为txt文件。
bin文件转txt文件工具
05-21
bin文件转txt文件工具，工程使用vs2010，该工具支持任意大小文件转换
.bin二进制文件转换为.txt（.bin）文件
weixin_45783610的博客
11-10 3266
python 二进制.bin转 .txt .dat文件，用于神经网络参数网络读取
windows 下如何将 二进制 bin 文件转换成 txt 文件，并对不同 txt 文件进行比对?
weixin_42083266的博客
11-18 9501
windows 下如何将 二进制 bin 文件转换成 txt 文件，并对不同 txt 文件进行比对? Git Bash 文件比对工具：Beyond Compare 4 2 bin 文件转换为 txt 文件的方法 运行 Git Bash , 执行如下命令即可： xxd mode1.bin mode1.txt 3 txt 文件比对的方法 打开 Beyond Compare 4 工具，选择“文本比较” 添加需要比对的 txt 文件 ...
BIN和TXT转换
热门推荐
起步
05-16 2万+
     做了两个工具，BIN转TXT，和TXT转BIN     有时候需要把BIN文件中的内容，在代码中以数组的形式保存，这就需要把BIN先转为TXT，再复制到代码中，因为UltraEdit里面是不能直接复制出来的。     BIN转TXT， 例如BIN文件中两个字节： 11， 22，转为字符11和22，存在TXT文件中。     做这两个工具并不难，有下面几点注意的地方： 
Python 脚本实例-Bin文件转Txt文件（附源码）
qq_26226375的博客
02-16 1326
在平时的嵌入式开发中，经常需要看bin文件，但是平时的bin文件无法通过文件查看器查看（例如nodpad++）。打开后，是一堆乱码，如下图：这种就给我们的工作带来了不便。当然，通过一些软件也是可以打开的，例如VSCODE中的hex editor。那有没有一些软件是可以将bin文件直接转换成txt文件呢？这玩意不是在网上一抓一大把吗？我也是这么想的，所以我立刻打开了百度搜索了一下。令我吃惊的是，找了半天居然找不到。我这暴脾气，找不到，那我们就自己写一个脚本。这里就将脚本的源码公开。
bin文件转bin文件转换工具
04-14
功能： --检测原bin文件数据长度，增加至第1-4个字节 --将AM335X的内部地址0x402F0400，增加至第5-8个字节 --将原bin文件的数据以4个字节为单位进行顺序转换 运行脚本前，需要修改脚本里面的文件名： 第1步：拷贝原bin文件至该文件夹下，例如原bin文件名称为“old.bin” 第2步：修改.bat文件为：bin2bin.exe old.bin new.bin 第3步：保存，运行.bat文件即可生成名称为“old.bin”的bin文件
bin txt互转工具.exe
09-22
本工具为bin转txt和txt转bin工具，自测自用完全没有问题。
binhex:将二进制文件转换为其十六进制表示形式（反之亦然）
05-14
将二进制文件转换/转换为十六进制表示（反之亦然：bin2hex hex2bin） Copyright (c) 2003-2011 Adrian H, Ray AF & Raisa NF of PT SOFTINDO, Jakarta. Email: aa _AT_ softindo.net All rights reserved. Version...
转换点云格式：bin批量转txt；[转换nuscenes数据集不乱码]
qq_56233492的博客
04-10 63
本文为CSDN原创，转载请表明原文出处。
百度apollo_Basemap.bin转.txt的教程
GOLDMINDER的博客
03-18 419
1.创建一个 `.proto` 文件，定义用于读取 `basemap.bin` 文件的消息结构。假设您已经有了适当的 `.proto` 文件，假设为 `basemap.proto`。在代码中使用生成的代码来读取 `basemap.bin` 文件并将其输出为文本消息。请将 `/path/to/basemap.bin` 替换为实际的 `basemap.bin` 文件路径。将生成的代码（`.h` 和 `.cc` 文件）添加到您的项目中，并根据需要进行适当的修改。// 定义消息的字段。// 输出消息到文本。
BIN文件和HEX文件互转合并
hyhsandy1803的博客
10-26 5747
因需要使用阿莫脱机下载器制作STM32脱机下载文件，而配置文件部分只有bin格式的，整合不了，所以需要把bin文件转化为hex文件。源代码很简单，不介绍了，直接上对话框图和代码，需要者自取。的代码，写了个对话框的程序。共享出来，给有需要的人。
matlab bin格式转txt输出
zhanghanqmx的博客
10-21 1168
【代码】matlab bin格式转txt输出。
点云格式转换
Q_Outsider的博客
02-02 1077
点云格式转换（学习记录）
【C++】 bin文件转换成txt文件
海獭的小爱情の博客
09-30 1万+
因学习需要，现要将二进制bin文件转化成十六进制格式并保存于txt文件中。 使用C语言编写该程序较为简单，定义FILE指针，在合适的地方运用getc()，fprintf()函数即可。这里主要讲使用C++文件流方法。 一直以来对C++文件和流都不是太熟，遇到文件读写使用的都是C的方式。因此这次使用C++的方式编写该程序，记录编写过程中的一些细节和问题，防止今后再出错。 一、 什么是bin文件...
Qt lambda 表达式
最新发布
github_37290846的博客
05-29 481
在 Qt 中，lambda 表达式经常用于定义槽函数，特别是在需要快速响应信号而无需编写单独的成员函数时。Lambda 表达式在 C++11 中被引入，它允许你定义一个匿名函数（即没有名字的函数）并直接在代码中捕获和使用它。当按钮被点击时，lambda 表达式中的代码将被执行，输出一条消息到调试控制台。总之，lambda 表达式在 Qt 中为信号和槽的连接提供了一种灵活且强大的方式，使得你可以在不定义额外成员函数的情况下快速响应信号。
CMake是怎么找到Qt相关模块的
FUHAILIANG_2015的博客
05-28 304
一般我们不会在CMakeLists里面硬编码CMAKE_PREFIX_PATH，推荐通过环境变量找到模块。深入了解find_package之后，我们就明白COMPONENTS其实是一个选项，列出来了必选的模块。当我们使用QT创建了一个CMake项目后，我们尝试使用CMake编译时，会遇到找不到Qt的模块的问题，Qt的模块是放在Qt/5.15.2/clang_64/lib/cmake，所以我们只需要配置。记得将QT_DIR环境变量放到PATH中，因为find_package会从PATH中寻找。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值