标签: clock

我正在做一个24小时.我有下面的代码.我的问题是int[]时间等于[0, 0, 0]并在每次迭代时打印出来.
一些可能对您有帮助的信息.我有Array TimeCounteras [hours, minutes, seconds].reset方法将选择的int值设置为零,保持不变或增加1.嵌套的while循环用于通过时钟.

public static int hours;
public static int minutes;
public static int seconds;
public static int [] TimeCounter = {hours, minutes, seconds};

//End of day
public static void reset(int [] midNight){
    hours = 0;
    minutes = 0;
    seconds = 0;
}

//End of a minute
public static void resetSeconds(int [] endOfMin){
    minutes++;
    seconds = 0;
}

//End of a Hour
public static void resetMinutes(int [] endOfHour){ …

是否有在时间更改时获取通知的最佳实践？

我使用的是NSTimer每 0,002 秒检查一次时间是否更改（小时和分钟，而不是秒和毫秒），以保持应用程序中的标签每分钟与手机时钟同步。

我希望有更好的解决方案。

谢谢

我刚开始使用各种不同的模块创建 FPGA 系统来驱动 I2C 总线（尽管我认为这个问题适用于任何 FPGA 系统），并且所有模块都使用同步复位。

这些模块使用时钟分频器模块进行计时，该模块获取系统时钟并向系统的其余部分输出较低的频率。

我遇到的问题是，当复位信号变低时，时钟分频器复位，因此其他模块依赖的时钟停止 - 因此其他模块不会注册复位

一个明显的解决方案是进行异步复位，但是，在 Xilinx ISE 中，它似乎不喜欢它们，并抛出警告，指出这与 Spartan-6 FPGA 不兼容（特别是当异步代码之后的代码是同步代码时） ，这是因为 I2C 总线使用总线时钟将位放入总线上）。

另一种解决方案是时钟分频器根本不可重置，因此时钟永远不会停止并且所有模块都会正确重置。然而，这意味着时钟分频器寄存器无法初始化/重新初始化为已知状态 - 有人告诉我这将是一个大问题，尽管我知道您可以 := '0'/'1'; 在模拟中使用该运算符，但这一旦编程就不起作用实际的 FPGA（？）。

同步复位的约定是什么？时钟发生器一般不复位吗？或者它们仅在复位信号的瞬时边沿复位？或者我的建议都不是真正的解决方案！

我放入了时序图和代码来说明我的意思，并显示我一直在使用的代码。

非常感谢！

大卫

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
library UNISIM;
use UNISIM.VComponents.all;
ENTITY CLK_DIVIDER IS
    GENERIC(INPUT_FREQ : INTEGER;
            OUT1_FREQ  : INTEGER;
            OUT2_FREQ  : INTEGER
    );
    PORT(SYSCLK  : IN  STD_LOGIC;
         RESET_N : IN  STD_LOGIC;
         OUT1    : OUT STD_LOGIC;
         OUT2    : OUT STD_LOGIC);
END CLK_DIVIDER;
architecture Behavioral of Clk_Divider is
    constant divider1 …

假设我有一个程序,其中包含添加两个数字的指令,该操作需要10纳秒(常数,由门制造商强制执行).
现在我有3个不同的处理器A,B和C(其中A <B <C就时钟周期而言).

A的一个时钟周期为15纳秒,B为10纳秒,C为7纳秒.

首先,我是按照以下假设纠正的:
1.添加操作需要1个完整的处理器A循环(慢速处理器),并且浪费剩余的5 ns循环.
2.添加操作需要1个完整周期的处理器B浪费时间.
3.添加操作需要2个完整周期(20 ns)的处理器C(快速处理器),浪费20-14 = 7 ns的其余部分.

如果上述假设是正确的,那么这与具有高时钟周期的处理器更快的常规假设不矛盾.
这里最快的处理器C实际上需要2个周期并且浪费7ns,而较慢的处理器A仅需要1个周期.

我正在尝试在 verilog 中创建一个计数器，我想知道如何将连续部分与组合部分分开。

我有这个模块，它工作正常，但我不知道如何拆分它？

module counter4bits(
    input clk_i,
    input rst_n_i,
    input enable_i,
    input   up_down_i,
    output reg[3:0] val_o);

    always@(posedge clk_i) begin
        if (rst_n_i == 1)
            val_o <= 0;
        else if(enable_i == 1)
            val_o <= val_o + 1;
        end

endmodule

我想在我的 Qt 程序中创建一个简单的时钟：QLabel，每秒更新一次。

Q标签名称：label_clock

我的时钟“脚本”：

while (true)
{
   QString time1 = QTime::currentTime().toString();
   ui->label_clock->setText(time1);
}

但是当我将它粘贴到我的程序中时，您已经知道它将在该脚本处停止执行 - while 总是给出 true，因此脚本下的其余代码永远不会执行 -> 程序崩溃。

我应该怎么做才能使这个脚本工作？我想创建一个简单的时钟，每秒更新一次。

所以我使用一个名为timebuilder 的包来重建我的小部件。对于 DateFormat 类，我使用了这个包。

 final String currentTime = getSystemTime();

 static String getSystemTime() {
   var now = new DateTime.now();
   return new DateFormat("H:m:s").format(now);
 }

 @override
 Widget build(BuildContext context) {
   return TimerBuilder.periodic(Duration(seconds: 1), builder: (context) {
     print("$currentTime");
     return Text(
       "$currentTime",
       style: TextStyle(
           color: Color(0xff2d386b),
           fontSize: 30,
           fontWeight: FontWeight.w700),
     );
   });
 }
}

然后我将显示 ClockWidget。我的小部件重建得很好。但 currentTime 的值仍然是我构建项目时最初的值。关于为什么 currentTime 不更新的任何线索？

我必须在多个线程期间消耗测量时间。我必须得到这样的输出：

Starting Time | Thread Number

00000000000   |   1

00000000100   |   2

00000000200   |   3

首先，我使用了 gettimeofday 但我看到有一些负数，然后我做了一些研究并了解到 gettimeofday 无法可靠地测量经过的时间。然后我决定使用clock_gettime(CLOCK_MONOTONIC)。

然而，有一个问题。当我用秒来测量时间时，我无法精确地测量时间。当我使用纳秒时， end.tv_nsec 变量的长度不能超过 9 位数字（因为它是一个长变量）。这意味着，当它必须移动到第 10 位时，它仍然保持在 9 位，并且实际上数字变小，导致经过的时间为负数。

这是我的代码：

long elapsedTime;
struct timespec end;
struct timespec start2;
//gettimeofday(&start2, NULL);
clock_gettime(CLOCK_MONOTONIC,&start2);

while(c <= totalCount)
{   
    if(strcmp(algorithm,"FCFS") == 0)
    {
        printf("In SErunner count=%d \n",count);
        if(count > 0)
        {
            printf("Count = %d \n",count);
        
            it = deQueue();
            c++;
            tid = it->tid;

            clock_gettime(CLOCK_MONOTONIC,&end);
            
            usleep( 1000*(it->value));
            elapsedTime = ( end.tv_sec - start2.tv_sec);
            
            printf("Process of thread …

我知道clock()不提供挂钟时间，并且CLOCKS_PER_SEC是系统相关值。假设我不关心系统相关问题，我可以假设下面的代码在GNU/Linux和Windows 中总是等待 1 秒，因为我测试过它对我来说似乎没问题。还是我应该坚持使用依赖于系统的sleep()/usleep()函数？

void wait_a_sec()
{
    clock_t start = clock();
    do
    {
        // wait 1 sec
        /**
         * Second call to clock() gives the processor time in clock ticks
         * since first call to it.
         * CLOCKS_PER_SEC: clock ticks per sec.
         */
    } while ( clock() < (start + CLOCKS_PER_SEC) );
}

我很难理解处理器的时间.该计划的结果:

#include <iostream>
#include <chrono>

// the function f() does some time-consuming work
void f()
{
    volatile long double d;
    int size = 10000;
    for(int n=0; n<size; ++n)
       for(int m=0; m<size; ++m)
           d = n*m;
}

int main()
{
    std::clock_t start = std::clock();
    f();
    std::clock_t end = std::clock();

    std::cout << "CPU time used: "
              << (end - start)
              << "\n";
}

似乎在210 000,220 000和230 000之间随机波动.起初我很惊讶,为什么这些离散值.然后我发现std::clock()只返回大约处理器时间.因此,返回的值可能std::clock()会舍入到10 000的倍数.这也可以解释为什么CPU时间之间的最大差异为20 000(第一次调用时为10 000 ==舍入误差,第二次调用为std::clock()10 000).

但是,如果我换到int …