Андрей Солодовников's questions

有必要将模块的输出连接到其受控输入uvm_driver。在我看来是这样的：

                  -----       ---------------------
                 | MON |---->|uvm_tlm_analysis_fifo|
                  -----       ---------------------
                    ^                    |
                    |                    |
 -------------      |      -------       |
|             |---------->| slave |      v
|     DUT     |            -------    --------
|             |<---------------------| master |
 -------------                        --------

我尝试了以下方法：

typedef class seq_item extends uvm_sequence_item;
typedef class driver extends uvm_driver(seq_item);

class agent extends uvm_agent;
    `uvm_component_utils(agent)
    uvm_analysis_port#(seq_item) ap;
    uvm_tlm_analysis_fifo#(seq_item) fifo;
    driver                       drv;

    function new(string name, uvm_component parent);
        super.new(name,parent);
    endfunction: new

    function void build_phase(uvm_phase phase);
        super.build_phase(phase);
        ap  = new("ap", this);
        fifo= new("fifo",this); 
        drv = driver::type_id::create("driver", this);
    endfunction: build_phase

    function void connect_phase(uvm_phase phase);
        super.connect_phase(phase);
        ap.connect(fifo.analysis_export);
        drv.seq_item_port.connect(fifo.get_peek_export);
    endfunction: connect_phase

    task main_phase(uvm_phase phase);
        seq_item trans;
        phase.raise_objection(this);
        repeat(5) begin
            trans = seq_item::type_id::create("inTrans");
            assert(trans.randomize());
            ap.write(trans);
        end
        phase.drop_objection(this);
    endtask
endclass: agent

这是一个最小的、独立的、可重现的示例：

`include "uvm_macros.svh"
package t;
    import uvm_pkg::*;
    class seq_item extends uvm_sequence_item;
        `uvm_object_utils(seq_item)

        rand bit [31:0]            data;
        function new(string name = "seq_item");
            super.new(name);
        endfunction: new
    endclass: seq_item

    class driver extends uvm_driver#(seq_item);
        `uvm_component_utils(driver)
        function new (string name, uvm_component parent);
            super.new(name, parent);
        endfunction: new

        task main_phase(uvm_phase phase);
            fork
                super.main_phase(phase);
            join_none
            forever begin
                seq_item_port.get_next_item(req);
                `uvm_info(get_type_name(),$psprintf("Got item with data: %h",req.data),UVM_NONE);
                seq_item_port.item_done();
            end
        endtask: main_phase
    endclass: driver

    class test extends uvm_test;
        `uvm_component_utils(test)
        uvm_analysis_port#(seq_item) ap;
        uvm_tlm_analysis_fifo#(seq_item) fifo;

        driver                       drv;

        function new(string name, uvm_component parent);
            super.new(name,parent);
        endfunction: new
        function void build_phase(uvm_phase phase);
            super.build_phase(phase);
            ap  = new(.name("apb_ap"), .parent(this));
            fifo= new("fifo",this); 
            drv = driver        ::type_id::create(.name("driver"), .parent(this) );
        endfunction: build_phase

        function void connect_phase(uvm_phase phase);
            super.connect_phase(phase);
            ap.connect(fifo.analysis_export);
            drv.seq_item_port.connect(fifo.get_peek_export);
        endfunction: connect_phase

        task main_phase(uvm_phase phase);
            seq_item trans;
            phase.raise_objection(this);
            repeat(5) begin
                trans = seq_item::type_id::create("inTrans");
                assert(trans.randomize());
                ap.write(trans);
            end
            phase.drop_objection(this);
        endtask
    endclass: test
endpackage

module top();
    import uvm_pkg::*;
    import t::*;
    initial begin
        run_test();
    end
endmodule

这会产生以下错误：

 ** Error: (vsim-7065) 5.sv(51): Illegal assignment to class mtiUvm.uvm_pkg::uvm_port_base #(class mtiUvm.uvm_pkg::uvm_sqr_if_base #(class work.t::seq_item, class work.t::seq_item)) from class mtiUvm.uvm_pkg::uvm_get_peek_imp #(class work.t::seq_item, class mtiUvm.uvm_pkg::uvm_tlm_fifo_base #(class work.t::seq_item))
#    Time: 0 ns  Iteration: 0  Region: /t File: 5.sv
# ** Error: (vsim-8754) 5.sv(51): Actual input arg. of type 'class mtiUvm.uvm_pkg::uvm_get_peek_imp #(class work.t::seq_item, class mtiUvm.uvm_pkg::uvm_tlm_fifo_base #(class work.t::seq_item))' for formal 'provider' of 'connect' is not compatible with the formal's type 'class mtiUvm.uvm_pkg::uvm_port_base #(class mtiUvm.uvm_pkg::uvm_sqr_if_base #(class work.t::seq_item, class work.t::seq_item))'.

上述方案如何实施？

我正在尝试处理系统verilog中的dpi。到目前为止，我所发现的只是“一切都很简单：你将一个函数导入系统verilog并像直接用这种语言编写一样使用它”，但同时在C语言中使用了头文件-code，这绝对不在标准编译器中。
不清楚你需要在哪里编写 C 代码以便 CAD 可以看到它，这里是整个厨房，从不编写代码，但准备工作空间的角度来看：你需要额外下载什么，如何配置，什么跑步？

我开始学习System Verilog。从我见过的例子来看，在这里你可以做这样的事情：

logic [3:0] a;
always @(posedge reset)
    a <= 0;
always @(posedge clk)
    a <= a + 1'b1;

那些。在不同的 always 块中执行分配。
但是，当我尝试在 Vivado 中合成类似的代码时，我得到一个错误multiple drivers，一般来说，如果我用普通的 Verilog 编写，他们会告诉我同样的事情。

我希望在窗口关闭后，删除窗口对象并将指针强制转换为 nullptr。
有一个 Qt::WA_DeleteOnClose 标志可以在关闭后删除对象。但是，为了将指针设置为 nullptr，我需要发送一些信号，但令人惊讶的是找不到。
显然，有一定的QWidget::closeEvent，但说实话，我根本不知道如何准备这些事件。

我想使用跨平台的睡眠功能。在其中一个问题中，提出了这样的解决方案。由于 qt 有Q_OS_WIN32和Q_OS_LINUX这样的常量，我决定使用它们而不是自己定义一些。
问题是由于某种原因这些常量是不可见的（两个块都是灰色的），如果你写在 .pro 文件DEFINES += Q_OS_WIN32中，很多关于重新定义定义的错误都会出现，即 有时它仍然被定义，它只是在使用函数处理文件之后发生。
我试图将它包含在尽可能低的位置，但它没有帮助。
我尝试在主目录的最顶部包含 QtGlobal，因为常量在那里，但它也没有帮助。如何正确解决这个问题？

有以下代码片段：

QRegularExpression Reg("^\\[ABC=\\d+.?\\d*\\]\\n$");
if(line.contains(Reg))
{
    curABC = line.mid(5,line.length()-7);
}

在最后一行中，外人可能不清楚数字“5”和“7”的来源。
5是片段“[ABC=”
的长度，7是“[ABC=]\n”的长度。
好方法，最后一行应该带入表格中：
curABC = line.mid(QString("[ABC=").length(), line.length() - QString("[ABC=]\n).length())
但不是每次都计算值的愿望，这是已知的，创建变量似乎也不是最好的解决方案，另一方面，也许编译器本身会明白该方法将始终返回 5 和 7，然后您可以使用上面编写的选项。

项目结构如下：
device.h

#ifndef DEVICE_H
#define DEVICE_H

#include <QWidget>
class device : public QWidget
{
    Q_OBJECT
signals:
    void takeMidVal(int midVal);
public:
    device(QWidget *parent = nullptr);
public slots:
    void seek(int bin);

};

#endif // DEVICE_H

设备.cpp

#include "device.h"

device::device(QWidget *parent) :
    QWidget(parent)
{

}
void device::seek(int bin)
{
    int midVal = 800;
    emit(takeMidVal(midVal));
}

对话框.h

#ifndef DIALOG_H
#define DIALOG_H
#include <QApplication>
#include <QDialog>
#include <QPushButton>
#include <QVBoxLayout>
#include <math.h>
#include <windows.h>
#define ACCEPT_DIFF         100
#define SIZE_OF_SAMPLE      10
#define SIZE_OF_NOISE       10

#define MK_SILENCE             -2
#define MK_INCORRECT_RESPONSE  -1
#define MK_WAITING              0
#define MK_CORRECT_RESPONSE     1

class Dialog : public QDialog
{
    Q_OBJECT
signals:
    void sendCommand();
    void setBinToSeek(int bin);
public:
    int configRes;
    int result;
    int midCount;
    int midValue;
    bool waitFlag;
    QPushButton* btn;
    explicit Dialog(QWidget *parent = nullptr);
    ~Dialog();
public slots:
    void computeMid(int curVal);
private slots:
    void handleClick();


};

#endif // DIALOG_H

对话框.cpp

#include "dialog.h"

Dialog::Dialog(QWidget *parent) :
    QDialog(parent)
{
    QVBoxLayout *mainLayout = new QVBoxLayout;
    btn = new QPushButton();
    mainLayout->addWidget(btn);
    this->setLayout(mainLayout);
    connect(btn,SIGNAL(clicked()),this,SLOT(handleClick()));
}
void Dialog::handleClick()
{
    result = -1;
    int amplitude = 1000;
    int bin = 10;
    unsigned char min = 1;
    unsigned char max =static_cast<unsigned char>(255);
    unsigned char command = 0;
    bool success = false;
    while(max-min > 1)
    {
        command = (min + (max-min)/2);
        configRes = MK_WAITING;
        emit(sendCommand());
        while(configRes == MK_WAITING)
        {
            QApplication::instance()->processEvents();
            Sleep(100);
        }
        emit(setBinToSeek(bin));
        waitFlag = true;
        midCount = 0;
        midValue = 0;
        int sleepCount = 0;
        while(waitFlag)
        {
            if(sleepCount >= 50)
            {
                return;
            }
            QApplication::instance()->processEvents();
            Sleep(300); //wait untill get mid value of pick in other thread
            ++sleepCount;
        }
        int diff = amplitude - midValue;
        if(diff < 0)
        {
            if(-diff < ACCEPT_DIFF)
            {
                success = true;
                break;
            }
            else
            {
                min = static_cast<unsigned char>(command);
            }
        }
        else
        {
            if(diff < ACCEPT_DIFF)
            {
                success = true;
                break;
            }
            else
            {
                max = static_cast<unsigned char>(command);
            }
        }
    }
    if(success)
    {
        result = static_cast<int>(command);
        return;
    }
}

void Dialog::computeMid(int curVal)
{
    midValue += curVal;
    ++midCount;
    if(midCount >= SIZE_OF_SAMPLE)
    {
        midValue /= midCount;
        waitFlag = false;
    }
}
Dialog::~Dialog()
{
}

主窗口.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QTimer>
#include "dialog.h"
#include "device.h"
class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    QPushButton* btn;
    QTimer timer;
    Dialog* d;
    device* dev;
    explicit MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

private slots:
    void createDialog();
    void handleTimeOut();
    void sendCommand();
};

#endif // MAINWINDOW_H

主窗口.cpp：

#include "mainwindow.h"
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent)
{
    dev = new device(this);
    btn = new QPushButton();
    this->layout()->addWidget(btn);
    connect(btn,SIGNAL(clicked()),this,SLOT(createDialog()));
    connect(&timer,SIGNAL(timeout()),this,SLOT(handleTimeOut()));
}

void MainWindow::sendCommand()
{
    timer.start(5000);
}
void MainWindow::createDialog()
{
    d = new Dialog();
    connect(d,SIGNAL(sendCommand()),this,SLOT(sendCommand()));
    connect(dev,SIGNAL(takeMidVal(int)),d,SLOT(computeMid(int)));
    connect(d,SIGNAL(setBinToSeek(int)),dev,SLOT(seek(int)));
    d->exec();
}
void MainWindow::handleTimeOut()
{
    d->configRes = MK_CORRECT_RESPONSE;
}
MainWindow::~MainWindow()
{
}

主文件

#include <QApplication>
#include <QtCore>
#include <QtGui>
#include "mainwindow.h"
int main(int argc, char *argv[])
{

    QApplication a(argc, argv);
    MainWindow w;
    w.show();
    return a.exec();
}

示例项目本身
当我发送信号时，调用了 sendCommand 插槽，这没有问题。但是从槽返回后，当定时器到期时，处理程序不会被调用。计时器完成后如何跳转到处理程序？

如果我们从一个抽象的例子转移到一个真实的例子，那么会发生以下情况：从主窗口调用一个模式。在模态窗口执行代码期间，会向主机发送信号，以通过 COM 端口向设备发送命令。此外，有必要从设备接收响应并处理它的缺失或不正确。为此，使用了计时器。
据我了解，发出信号后，模态窗口代码的执行一刻也没有停过，于是我就把它无限循环，直到flag落下，表示所​​有处理完成。
但问题是定时器并没有以任何方式触发handler调用，退出slot后什么也没有发生，模态窗口代码的执行就陷入了死循环。

已添加以下内容。通过调用handleClick，生成一个命令，发送到device1，影响device2的输出。之后，向 device2 发送一个信号，以便它开始返回某个值。当收集到足够数量的这些值时，会计算它们的算术平均值，并估计接收到的值与期望值之间的差异。如果差值大于最小值，则球队的阵型会有调整，一切都重新开始。

我在设计器模式下向窗口添加了 10 个复选框。这些是checkbox1,checkbox2,...,checkbox10不是数组的对象。如何检查循环中每个复选框的状态？

是否可以将现有的物理磁盘与安装在 qemu 中的系统一起使用？假设有 2 个磁盘在 Linux 下被sda视为sdc. sda是安装 Windows 10 的系统驱动器，sdc它只是安装程序的文件存储。如何创建虚拟机以便它使用这些磁盘？

我希望通过双击 alt 来关闭窗口（模拟按 alt + f4）。
在 Windows 中，我对此有 ahk 。你能告诉我如何在这里实现吗？

我是这样看的：应该有某种点击处理程序可以捕获对 alt 的每次点击，然后它会运行一个脚本（我可以编写一个脚本，我宁愿需要一个处理程序），其中将描述自动机并按照哪个做我需要的。

PS 双击 alt 不是键盘快捷键，因此请不要提供它们（键盘组合）作为答案，除非您有明确的计划来实现我使用它们描述的目标。

configure.ac 文件中需要“XXX”变量。但是，它需要有一个默认值，并且能够在调用 ./configure 时设置该值。也就是说，能够做到这样：
如果./configure
调用XXX的默认值（让它是“aaa”）
如果./configure XXX="bbb"
调用XXX的值，它就变成了“bbb”

假设我想编写以下程序：

你好.h：

#include "stdio.h"
#define STR "some string like Hello World"

你好ç：

#include <hello.h>

int main()
{
    printf(STR);
    return 0;
}

现在，当我用自动工具构建这个程序时，我想控制这一行的值（定义中的那个）。那些。我想在 configure.ac 中编写一些变量，该变量将通过 Makefile 扩展到此标头。
如何做到这一点？

我需要编写一个shell脚本。其本质归结为驱动程序模块的循环加载，如果应用程序在三秒内没有崩溃，则启动一个测试应用程序，停止它然后卸载驱动程序。到目前为止，我已经写了以下内容：

#!/bin/sh
for((i=0; i<200; i++))
do
insmod /lib/modules/4.4.111.1/extra/ump.ko
insmod /lib/modules/4.4.111.1/extra/mali.ko
cd /opt/mali/cube
./cube &> log &
sleep 3
kill pid
rmmod mali
rmmod ump
done

据我了解，您需要使用 kill 命令，但是如何将进程 ID 传递给它？嗯，即 您需要通过进程名称“抓取”作业 -l，但 grep 将返回一个字符串，而不是一个数字。

下午好。
如果我在这个主题中游泳，我提前道歉 - 他们没有在大学教授傅里叶变换。
一般来说，我正在尝试用verilog编写一个吉他调音器。有一个音频编解码器可以以 8-96kHz 的采样率将声音数字化。有一个 FFT 块，您可以在其中配置它将需要多少点。我需要在 60-700Hz 的频率范围内获得 1Hz 的精度（或更好）。在这种情况下，希望具有最小延迟。据我了解，精度取决于采样率和 FFT 中的点数：error = fs/num_points。事实证明，为了使误差 <= 1 Hz，需要比采样频率多取点，即 从一秒钟开始仅用于采样。
这个过程可以加快吗？是的，我知道不确定性原理。

下午好。我正在尝试为另一台机器构建helloworld
模块。主机x86_64，目标armhf。 安装了交叉编译器/usr/bin/arm-linux-gnueabihf-gcc，下载了本机的内核源码~/projects/linux-3.4.113 / ): /usr/bin/arm-linux-gnueabihf-gcc -I~ /projects/linux-3.4.113/ -c ./helloworld.c

（以及类似命令的许多小的变体）
我一遍又一遍地发誓说没有找到linux/modules.h的事实。
有人可以解释我做错了什么以及如何做对吗？helloworld源代码：

/*
 *  hello-1.c - The simplest kernel module.
 */
#include <linux/module.h>   /* Needed by all modules */
#include <linux/kernel.h>   /* Needed for KERN_INFO */

int init_module(void)
{
    printk(KERN_INFO "Hello world 1.\n");

    /*
     * A non 0 return means init_module failed; module can't be loaded.
     */
    return 0;
}

void cleanup_module(void)
{
    printk(KERN_INFO "Goodbye world 1.\n");
}

模块尝试构建的 Makefile 的内容：

CC := g++
TOOLCHAIN := arm-linux-gnueabihf
PT :=
CFL := -Wextra -std=c++11
TPATH := /usr/bin/
LPATH := /usr/$(TOOLCHAIN)/
ARCH := arm
all: helloworld.c
    $(TPATH)$(TOOLCHAIN)-$(CC) $(CFL) $(ARCH) -o helloworld.c 

您可以将输出流和（或）错误重定向到具有覆盖的文件：
1>file将输出流中的数据输出到具有创建或覆盖的文件的文件中，或
2>file将错误流中的输出数据重定向到具有创建或覆盖的文件
1&>file（以及其他几个选项）从流输出数据以及输出和从错误流到创建和覆盖的文件。

您可以通过写入文件末尾来将输出流或错误流输出到文件：

1>>file 2>>file  

但是，如果您尝试执行类似的操作1&>>file，则会弹出语法错误。

如何从输出流和错误流写入文件末尾？

时不时会遇到这个词，但我还是不明白它是什么，某种与进程相关的概念，而且显然不仅在 Linux 中，在其他操作系统中也是如此。
假设在 KDE 的桌面上我有一个“新建活动”按钮。
在 Android 主题中，有时也会出现一些问题，例如“活动生命周期”。
我在网上找不到任何解释。

有一个容器map，我在其中循环

for (auto it = A.begin(); it != A.end(); ++it)

我遍历所有元素。
在某些时候，需要删除某些元素。同时，应该可以通过循环，即 迭代器it必须保留，并且在增量之后必须指向正确的元素（在被移除的元素旁边）。
如何实施？有人怀疑为此您需要重写循环本身，但我不知道如何以不同的方式遍历所有元素。

下午好。有必要实现一个汇编程序，它执行以下操作：
1. 创建一个名为 XXXXXXXX.LAB 的文件，其中 XXXXXXXX 是您的姓氏。
2. 写入文件行： - 姓、名、组号。
3. 读取文件并在屏幕上显示内容。
4.更改文件属性 - 使其隐藏。
5. 以直接寻址模式写入文件以代替元素 5 数字 8。
6. 从文件中读取编号为 3 - 10 的元素并将它们显示在屏幕上。

步骤 1-4 已完成，但最后 2 点无法完成。下面是程序的代码，在我看来，它应该满足第 1-5 点。

.model small

data segment
    cr      equ 0dh
    lf      equ 0ah
    string  db  'AndrewS-31',cr,lf      ;строка для записи
    strlnth equ $-string                ;ее длина
    handle  dw  ?                       ;ячейка для дескриптора
    fname   db  'Solodovnikov.LAB',0    ;имя файла в формате asciiz
    buffin  db  12 dup ('')             ;буфер ввода
    replace db  '8'
  replength equ $-replace
data ends
code segment
    assume cs:code, ds:data
main:
    mov ax, data
    mov ds, ax
    ;создадние файла

    mov ah, 3ch                      ;функция создания файла
    mov cx, 0                        ;без аттрибутов
    mov dx, offset fname             ;адрес имени файла
    int 21h
    mov handle, ax                   ;сохраним дескриптор файла

    ;запись в файл строкиs

    mov ah, 40h                      ;функция записи
    mov bx, handle                   ;дескриптор
    mov cx, strlnth                  ;длина строки
    mov dx, offset string            ;адрес строки
    int 21h

    ;закрытие файла
    mov ah, 3eh                      ;функция закрытия
    mov bx, handle                   ;дескриптор
    int 21h

    ;открытие файла
    mov ah, 3dh
    mov al, 2h
    mov dx, offset fname
    int 21h
    mov handle, ax

    ;чтение из файла строки
    mov ah, 3fh
    mov bx, handle
    mov cx, strlnth
    mov dx, offset buffin
    int 21h


    ;вывод строки на консоль
    mov ah, 40h
    mov bx, 1h
    mov cx, 0ch
    mov dx, offset buffin
    int 21h

    ;изменение атрибута файла
    mov dx, offset fname
    mov cl, 2h
    mov al, 1h
    mov ah, 43h
    int 21h

    mov ah, 42h                      ;функция перемещения указателя
    mov al, 0                        ;выбор смещения: относительно начала файла
    mov cx, 0                        ;
    mov dx, 5h                       ;смещение на 5 позиций
    mov bx, handle
    int 21h

    mov ah, 40h                      ;функция записи
    mov bx, handle                   ;дескриптор
    mov cx, replength                ;длина строки
    mov dx, offset replace           ;адрес строки
    int 21h

    mov ah,4ch
    int 21h

code ends
end main

但结果是，最后两块代码似乎不见了。需要解决什么问题才能使程序做它想做的事？

下午好。
我刚刚开始使用 opencv 库，它提出了一个问题：
声明 Mat 指针还是对象本身更好？即：

Mat* a = new Mat();

或者

Mat a = Mat(); 

乍一看，在堆上分配内存似乎更合理，因为对象通常比较大，在工作过程中我们可以增加矩阵的大小，并且存在堆栈溢出的威胁。
另一方面，在我看到的那些代码示例中，在任何地方都没有使用运算符new，我发现了以下语句：

当您使用它（Mat 类）时，您可以从内存管理的烦恼中解脱出来：分配和释放。该类实现了一个引用计数器，并且仅在不再需要时才释放内存。