Compiler errors 错误10818-Can'；t推断寄存器，因为它的值不在时钟边缘之外_Compiler Errors_Vhdl_Fpga_Intel Fpga_Quartus

Compiler errors 错误10818-Can'；t推断寄存器，因为它的值不在时钟边缘之外

compiler-errors vhdl

Compiler errors 错误10818-Can'；t推断寄存器，因为它的值不在时钟边缘之外,compiler-errors,vhdl,fpga,intel-fpga,quartus,Compiler Errors,Vhdl,Fpga,Intel Fpga,Quartus,我正在研究一个改进的高斯-乔丹消除器的代码，我得到了错误： LIBRARY ieee; USE ieee.std_logic_1164.all; USE ieee.std_logic_unsigned.all; USE ieee.numeric_std.all; USE IEEE.STD_LOGIC_ARITH.ALL; PACKAGE matriz IS TYPE matrix IS ARRAY (NATURAL RANGE <>) OF STD_LOGIC_VECTOR

我正在研究一个改进的高斯-乔丹消除器的代码，我得到了错误：

LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.all;
USE IEEE.STD_LOGIC_ARITH.ALL;

PACKAGE matriz IS
    TYPE matrix IS ARRAY (NATURAL RANGE <>) OF STD_LOGIC_VECTOR(1 TO 7);
    TYPE vector IS ARRAY (NATURAL RANGE <>) OF INTEGER;
END matriz;

USE work.matriz.all;
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.all;
USE IEEE.STD_LOGIC_ARITH.ALL;

ENTITY bloco2 IS
    GENERIC (m: integer:= 4;
                n: integer:= 7;
                k: integer:= 3);
    PORT (clk,rst: IN STD_LOGIC;
            s: IN vector(1 TO n);
            G: IN matrix(1 TO m);
            Gr0, Gr: OUT matrix(1 TO m));
END bloco2;

ARCHITECTURE bloco2 OF bloco2 IS

SIGNAL Grt: matrix(1 TO m):= (OTHERS=>(OTHERS=>'0'));
SIGNAL Gr0t: matrix(1 TO m):= (OTHERS =>(OTHERS=>'0'));
SIGNAL st: vector(1 TO n):= (OTHERS=>0);

SIGNAL temp1: STD_LOGIC_VECTOR(1 TO n):= (OTHERS=>'0');
SIGNAL temp2: STD_LOGIC_VECTOR(1 TO n):= (OTHERS=>'0');
SIGNAL verify: STD_LOGIC:= '0';

BEGIN

    PROCESS(clk, rst, G, Grt, Gr0t, st, s, verify, temp1, temp2)
    VARIABLE L: INTEGER:= 1;
    VARIABLE c: INTEGER:= 1;
    VARIABLE count: INTEGER:= 0;
    BEGIN

        Grt<=G;
        st<=s;

        IF rst='0' THEN
            IF (rising_edge(clk))THEN
                IF count <= 3 THEN
                    IF Grt(L)(st(c))='1' THEN
                                Gr0t(L)(st(c))<='1';
                                FOR i IN 1 TO m LOOP
                                    verify <= Grt(i)(st(c));
                                    FOR j IN 1 TO n LOOP
                                        IF ((i/=L) and (verify/='0')) THEN
                                            Grt(i)(j)<= Grt(L)(j) xor Grt(i)(j);
                                        END IF;
                                    END LOOP;
                                END LOOP;
                                count:=count+1;
                                L:=L+1;
                                c:=c+1;
                    END IF;

                    IF Grt(L)(st(c))='0' THEN
                        FOR i IN 1 TO m LOOP
                                IF i > L THEN
                                    IF Grt(i)(st(c)) ='1' THEN
                                     temp1<= Grt(L)(1 TO n);
                                     temp2<= Grt(i)(1 TO n);
                                     Grt(i)(1 TO n)<= temp1;
                                     Grt(L)(1 TO n)<= temp2;
                                     exit;
                                    END IF;
                                END IF;
                        END LOOP;   

                        IF Grt(L)(st(c)) /='1' THEN
                            c:=c+1;
                        END IF;
                    END IF;

                END IF;
            END IF;

        END IF;

        IF rst='1' THEN
            Gr0t <= (OTHERS=>(OTHERS=>'0'));
            Grt <= (OTHERS => (OTHERS =>'0'));

        END IF;
    Gr<=Grt;
    Gr0<=Gr0t;
END PROCESS;
END bloco2;

ieee库；
使用ieee.std_logic_1164.all；
使用ieee.std_logic_unsigned.all；
使用ieee.numeric_std.all；
使用IEEE.STD_LOGIC_ARITH.ALL；
包矩阵是
类型矩阵是标准逻辑向量（1到7）的数组（自然范围）；
类型向量是整数的数组（自然范围）；
末端矩阵；
使用work.matriz.all；
图书馆ieee；
使用ieee.std_logic_1164.all；
使用ieee.std_logic_unsigned.all；
使用ieee.numeric_std.all；
使用IEEE.STD_LOGIC_ARITH.ALL；
实体bloco2是
通用（m：整数：=4；
n：整数：=7；
k：整数=3）；
端口（时钟，rst：标准逻辑中；
s：在向量中（1到n）；
G：在矩阵中（1到m）；
Gr0，Gr:OUT矩阵（1到m））；
终末二氧化碳；
bloco2的体系结构bloco2是
信号Grt：矩阵（1到m）：=（其他=>（其他=>'0'）；
信号Gr0t：矩阵（1到m）：=（其他=>（其他=>'0'）；
信号st：向量（1到n）：=（其他=>0）；
信号temp1:STD_逻辑_向量（1到n）：=（其他=>'0'）；
信号temp2:STD_逻辑_向量（1到n）：=（其他=>'0'）；
信号验证：标准逻辑：='0'；
开始
过程（时钟、rst、G、Grt、Gr0t、st、s、验证、temp1、temp2）
变量L：整数：=1；
变量c：整数：=1；
变量计数：整数：=0；
开始
Grt需要了解的一些基本情况

信号仅在进程挂起时更新。这将出现在流程敏感度列表（您的案例）或等待语句（通常在测试台中）
合成工具只理解语言的一个非常有限的子集，并且特别挑剔WRT触发器
如果您的流程通过合成工具进行了适当的可移植性结构，那么您只需要在敏感度列表中使用时钟和异步控件（以及异步加载的数据，但不需要）

让我们以1076.6-1999的方式重新编写代码
因为您的进程没有wait语句，所以所有代码都在相同的增量周期中执行。在处理的时钟/复位部分之外进行的任何信号分配都可以同时进行。因此，我们将在设计的架构（architecture）代码区域（而非流程）中编写以下代码：
您的代码更接近下面的模板。一个我喜欢的，但它的便携性稍差。注意：在此分支中，时钟分支不以重置为条件，重置分支中的任何分配都将覆盖时钟分支中的设置。我建议首先从上面的一个开始，让它在模拟和合成中正常工作，然后如果你真的想切换回来
PROCESS(clk, rst)
BEGIN
    if (rising_edge(clk))THEN
      .  .  .

    END IF;
    IF rst='1' THEN
      . . . 
    END IF;
END PROCESS;

下面是考虑了并发信号的代码。我没有对其他可能存在问题的问题进行任何更改
PROCESS(clk, rst)
VARIABLE L: INTEGER:= 1;
VARIABLE c: INTEGER:= 1;
VARIABLE count: INTEGER:= 0;
BEGIN
    IF rst='1' THEN
        Gr0t <= (OTHERS=>(OTHERS=>'0'));
        Grt <= (OTHERS => (OTHERS =>'0'));

    elsif (rising_edge(clk))THEN
            IF count <= 3 THEN
                IF Grt(L)(st(c))='1' THEN
                            Gr0t(L)(st(c))<='1';
                            FOR i IN 1 TO m LOOP
                                verify <= Grt(i)(st(c));
                                FOR j IN 1 TO n LOOP
                                    IF ((i/=L) and (verify/='0')) THEN
                                        Grt(i)(j)<= Grt(L)(j) xor Grt(i)(j);
                                    END IF;
                                END LOOP;
                            END LOOP;
                            count:=count+1;
                            L:=L+1;
                            c:=c+1;
                END IF;

                IF Grt(L)(st(c))='0' THEN
                    FOR i IN 1 TO m LOOP
                            IF i > L THEN
                                IF Grt(i)(st(c)) ='1' THEN
                                 temp1<= Grt(L)(1 TO n);
                                 temp2<= Grt(i)(1 TO n);
                                 Grt(i)(1 TO n)<= temp1;
                                 Grt(L)(1 TO n)<= temp2;
                                 exit;
                                END IF;
                            END IF;
                    END LOOP;   

                    IF Grt(L)(st(c)) /='1' THEN
                        c:=c+1;
                    END IF;
                END IF;
            END IF;
    END IF;
END PROCESS;

过程（时钟、rst）
变量L：整数：=1；
变量c：整数：=1；
变量计数：整数：=0；
开始
如果rst='1'，则
Gr0t（其他=>'0'）；
Grt（其他=>'0'）；
elsif（上升沿（clk））然后
如果计算一些基本的事情要知道

信号仅在进程挂起时更新。这将出现在流程敏感度列表（您的案例）或等待语句（通常在测试台中）
合成工具只理解语言的一个非常有限的子集，并且特别挑剔WRT触发器
如果您的流程通过合成工具进行了适当的可移植性结构，那么您只需要在敏感度列表中使用时钟和异步控件（以及异步加载的数据，但不需要）

让我们以1076.6-1999的方式重新编写代码
因为您的进程没有wait语句，所以所有代码都在相同的增量周期中执行。在处理的时钟/复位部分之外进行的任何信号分配都可以同时进行。因此，我们将在设计的架构（architecture）代码区域（而非流程）中编写以下代码：
您的代码更接近下面的模板。一个我喜欢的，但它的便携性稍差。注意：在此分支中，时钟分支不以重置为条件，重置分支中的任何分配都将覆盖时钟分支中的设置。我建议首先从上面的一个开始，让它在模拟和合成中正常工作，然后如果你真的想切换回来
PROCESS(clk, rst)
BEGIN
    if (rising_edge(clk))THEN
      .  .  .

    END IF;
    IF rst='1' THEN
      . . . 
    END IF;
END PROCESS;

下面是考虑了并发信号的代码。我没有对其他可能存在问题的问题进行任何更改
PROCESS(clk, rst)
VARIABLE L: INTEGER:= 1;
VARIABLE c: INTEGER:= 1;
VARIABLE count: INTEGER:= 0;
BEGIN
    IF rst='1' THEN
        Gr0t <= (OTHERS=>(OTHERS=>'0'));
        Grt <= (OTHERS => (OTHERS =>'0'));

    elsif (rising_edge(clk))THEN
            IF count <= 3 THEN
                IF Grt(L)(st(c))='1' THEN
                            Gr0t(L)(st(c))<='1';
                            FOR i IN 1 TO m LOOP
                                verify <= Grt(i)(st(c));
                                FOR j IN 1 TO n LOOP
                                    IF ((i/=L) and (verify/='0')) THEN
                                        Grt(i)(j)<= Grt(L)(j) xor Grt(i)(j);
                                    END IF;
                                END LOOP;
                            END LOOP;
                            count:=count+1;
                            L:=L+1;
                            c:=c+1;
                END IF;

                IF Grt(L)(st(c))='0' THEN
                    FOR i IN 1 TO m LOOP
                            IF i > L THEN
                                IF Grt(i)(st(c)) ='1' THEN
                                 temp1<= Grt(L)(1 TO n);
                                 temp2<= Grt(i)(1 TO n);
                                 Grt(i)(1 TO n)<= temp1;
                                 Grt(L)(1 TO n)<= temp2;
                                 exit;
                                END IF;
                            END IF;
                    END LOOP;   

                    IF Grt(L)(st(c)) /='1' THEN
                        c:=c+1;
                    END IF;
                END IF;
            END IF;
    END IF;
END PROCESS;

过程（时钟、rst）
变量L：整数：=1；
变量c：整数：=1；
变量计数：整数：=0；
开始
如果rst='1'，则
Gr0t（其他=>'0'）；
Grt（其他=>'0'）；
elsif（上升沿（clk））然后
如果最后单独的异步重置让synth感到困惑，那么它毕竟是时钟进程之外的一个赋值。在同一if/then/elsit语句中，使用一种结合复位和上升沿（时钟）的标准形式。（顺便说一句，“提示”是垃圾）请阅读供应商的HDL开发人员指南，了解如何描述同步和异步电路的正确VHDL代码模式。最后单独的异步重置可能会让synth感到困惑，毕竟这是时钟进程之外的分配。在同一if/then/elsit语句中，使用一种结合复位和上升沿（时钟）的标准形式。（顺便说一句，“提示”是垃圾）请阅读供应商的HDL开发人员指南，了解如何描述同步和异步电路的正确VHDL代码模式。