0

我编辑了这个线程以更新我的整个新项目并使其更具可读性：

--Propagate & generate team--
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.numeric_std.all;
ENTITY PG_team_1bit IS
    PORT(a, b:IN STD_LOGIC;
         p: OUT STD_LOGIC;
         g: OUT STD_LOGIC);
END PG_team_1bit;
ARCHITECTURE PG_team_1bit_arch OF PG_team_1bit IS
BEGIN
    p <= a XOR b;
    g <= a AND b;      
END PG_team_1bit_arch;       


--Grey Box--
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.numeric_std.all;
ENTITY Grey_box IS
    PORT(P, G, Gminus:IN STD_LOGIC;
         NewG: OUT STD_LOGIC);
END Grey_box;
ARCHITECTURE Grey_box_arch OF Grey_box IS
    SIGNAL temp: STD_LOGIC;
BEGIN
   temp <= P AND Gminus;
   NewG <= G OR temp;      
END Grey_box_arch;       


--Black Box--
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.numeric_std.all;
ENTITY Black_box IS
    PORT(P, G, Pminus, Gminus:IN STD_LOGIC;
         NewP, NewG: OUT STD_LOGIC);
END Black_box;
ARCHITECTURE Black_box_arch OF Black_box IS
    SIGNAL temp: STD_LOGIC;
BEGIN
   NewP <= P AND Pminus;
   temp <= P AND Gminus;  
   NewG <= G or temp;    
END Black_box_arch;   


--Full adder--
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.numeric_std.all;
ENTITY Full_Adder IS
    PORT(A, B, Cin:IN STD_LOGIC;
         S, Cout: OUT STD_LOGIC);
END Full_Adder;
ARCHITECTURE Full_Adder_arch OF Full_Adder IS
    SIGNAL p: STD_LOGIC;
BEGIN
   p <= A XOR B;
   S <= p XOR Cin;  
   Cout <= (A AND B) OR (A AND Cin) OR (B AND Cin);    
END Full_Adder_arch;  



--SKLANSKY SPARSE TREE ADDER 32 bit--
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.numeric_std.all;
ENTITY SSTA32 IS
    PORT(A, B:IN STD_LOGIC_VECTOR(31 downto 0);
         S: OUT STD_LOGIC_VECTOR(32 downto 0));
END SSTA32;
ARCHITECTURE SSTA32_arch of SSTA32 IS 
    SIGNAL con: STD_LOGIC;
    SIGNAL p: STD_LOGIC_VECTOR(31 downto 0);
    SIGNAL g: STD_LOGIC_VECTOR(31 downto 0);
    SIGNAL NewGG: STD_LOGIC_VECTOR(6 downto 0);
    SIGNAL NewP: STD_LOGIC_VECTOR(6 downto 0);
    SIGNAL NewBG: STD_LOGIC_VECTOR(6 downto 0);
    variable j : integer := 0;
    variable k : integer := 0;
    variable l : integer := 0;
    variable m : integer := 0;
    variable d : integer := 0;
    variable e : integer := 0;
COMPONENT PG_team_1bit
    PORT(a, b:IN STD_LOGIC;
         p: OUT STD_LOGIC;
         g: OUT STD_LOGIC);
END COMPONENT; 
COMPONENT Grey_box IS
    PORT(P, G, Gminus:IN STD_LOGIC;
         NewG: OUT STD_LOGIC);
END COMPONENT;
COMPONENT Black_box IS
    PORT(P, G, Pminus, Gminus:IN STD_LOGIC;
         NewP, NewG: OUT STD_LOGIC);
END COMPONENT;
COMPONENT Full_Adder IS
    PORT(A, B, Cin:IN STD_LOGIC;
         S, Cout: OUT STD_LOGIC);
END COMPONENT;
BEGIN 
   con <= '1';
   GENERATE_LABEL_1:
   FOR i IN 0 TO 31 GENERATE
      PG_team_1bit_i: PG_team_1bit PORT MAP(a(i), b(i), p(i), g(i));
   END GENERATE GENERATE_LABEL_1;   
   GENERATE_LABEL_2: 
   FOR i IN 0 TO 31 GENERATE
       BEGIN
          F0 : IF ((i=1) OR (i=5) OR (i=9) OR (i=13) OR (i=17) OR (i=21) OR (i=25) OR (i=29)) GENERATE
             BEGIN Grey_box_i: Grey_box PORT MAP(p(i), g(i), g(i-1), NewGG(j));--
             j := j+1;
             END GENERATE F0;
          F1 : IF ((i/=1) AND (i/=5) AND (i/=9) AND (i/=13) AND (i/=17) AND (i/=21) AND (i/=25) AND (i/=29)) GENERATE
             BEGIN Black_box_i: Black_box PORT MAP(p(i), g(i), p(i-1), g(i-1), NewP(k), NewBG(k));
             k := k+1;
             END GENERATE F1; 
       END GENERATE GENERATE_LABEL_2;
   GENERATE_LABEL_3:
   FOR i IN 0 TO 31 GENERATE
      BEGIN
         F2 : IF (i=3) GENERATE
            BEGIN Grey_box_i: Grey_box PORT MAP(NewP(m), NewBG(m), NewGG(m), DNewG);
            m := m+1;
            END GENERATE F2;
         F3 : IF ((i=7) OR (i=11) OR (i=15) OR (i=19) OR (i=23) OR (i=27) OR (i=31)) GENERATE
            BEGIN Black_box_i: Black_box PORT MAP(NewP(m), NewBG(m), con, NewBG(m), TNewP(l), TNewBG(l));
            l := l+1; 
            END GENERATE F3;
      END GENERATE GENERATE_LABEL_3;
   GENERATE_LABEL_4:
   FOR i IN 0 TO 31 GENERATE 
      BEGIN
         F4 : IF (i=3) GENERATE
            BEGIN C(d) <= '0';
            d := d+1;
            C(d) <= NOT DNewG;
            d := d+1;
            END GENERATE F4;
         F5 : IF (i=7) GENERATE
            BEGIN Grey_box_i: Grey_box PORT MAP(TNewP(e), TNewBG(e), DNewG, DNewG2);
            C(d) <= NOT DNewG2;
            d := d+1;
            e := e+1;
            END GENERATE F5;
         F6 : IF (i=11) GENERATE
            BEGIN Grey_box_i: Grey_box PORT MAP(NOT TNewP(e), NOT TNewBG(e), DNewG2, C(d));
            d := d+1;
            e := e+1;
            END GENERATE F6;
         F7 : IF (i=15) GENERATE
            BEGIN Black_box_i: Black_box PORT MAP(TNewP(e), TNewBG(e), TNewP(e-1), TNewBG(e-1), QNewP, QNewBG);
            Grey_box_i: Grey_box PORT MAP(QNewP, QNewBG, DNewG2, DNewG3);
            C(d) <= DNewG3;
            d := d+1;
            e := e+1;
            END GENERATE F7;
         F8 : IF (i=19) GENERATE
            BEGIN Grey_box_i: Grey_box PORT MAP(NOT TNewP(e), NOT TNewBG(e), DNewG3, C(d));
            d := d+1;
            e := e+1;
            END GENERATE F8;
         F9 : IF (i=23) GENERATE
            BEGIN Black_box_i: Black_box PORT MAP(TNewP(e), TNewBG(e), TNewP(e-1), TNewBG(e-1), PNewP, PNewBG);
            Grey_box_i: Grey_box PORT MAP(PNewP, PNewBG, DNewG3, C(d));
            d <= d+1;
            e <= e+1;
            END GENERATE F9;
         F10 : IF (i=27) GENERATE
            BEGIN Black_box_i: Black_box PORT MAP(NOT TNewP(e), NOT TNewBG(e), PNewP, PNewBG, HNewP, HNewBG);
            Grey_box_i: Grey_box PORT MAP(HNewP, HNewBG, DNewG3, C(d));
            END GENERATE F10;
      END GENERATE GENERATE_LABEL_4;
   d := 0;
   GENERATE_LABEL_5:
   FOR i IN 0 TO 31 GENERATE
      BEGIN
         F11 : IF ((i=0) AND (d=0)) GENERATE
            BEGIN Cin <= C(d);
            d := d+1;
            END GENERATE F11;
         F12 : IF ((i=4) AND (d=1)) GENERATE
            BEGIN Cin <= C(d);
            d := d+1;
            END GENERATE F12;
         F13 : IF ((i=8) AND (d=2)) GENERATE
            BEGIN Cin <= C(d);
            d := d+1;
            END GENERATE F13;
         F14 : IF ((i=12) AND (d=3)) GENERATE
            BEGIN Cin <= C(d);
            d := d+1;
            END GENERATE F14;
         F15 : IF ((i=16) AND (d=4)) GENERATE
            BEGIN Cin <= C(d); 
            d := d+1;
            END GENERATE F15;
         F16 : IF ((i=20) AND (d=5)) GENERATE
            BEGIN Cin <= C(d);
            d := d+1;
            END GENERATE F16;
         F17 : IF ((i=24) AND (d=6)) GENERATE
            BEGIN Cin <= C(d);
            d := d+1;
            END GENERATE F17;
         F18 : IF ((i=28) AND (d=7)) GENERATE
            BEGIN Cin <= C(d);
            d := d+1;
            END GENERATE F18; 
         Full_Adder_i: Full_Adder PORT MAP(a(i), b(i), Cin, S(i), Cout);
         Cin <= Cout;
         F19 : IF (i=31) GENERATE
            BEGIN S(32) <= Cout;
            END GENERATE F19;
      END GENERATE GENERATE_LABEL_5;
END SSTA32_arch;

我得到的错误如下： - 我使用的几乎所有信号都不是静态信号名称。- 我做的地方不允许变量声明。-未知标识符。- 信号分配的非法目标和 -Illegal concurent statement。

有什么技巧可以修复它们吗？如果现在正确，我的生成也是？我改变了它以避免进程。提前致谢

4

2 回答 2

1

退后一点；很明显你还不习惯 VHDL；它与其他语言有点不同，坦率地说（IMO）在许多（大多数？）书籍中都没有很好地教授这些差异。

修复语法错误不会让你通过这个；学会看到它们背后的概念错误。

一些文本强调 VHDL 是一种硬件描述语言而不是一种编程语言：虽然确实如此，但这并不是特别有用，并且可能会导致您陷入糟糕的低级设计实践。这里有不同的看法...

VHDL 实际上是两种不同的语言合二为一：一种像 Pascal 或 C 的顺序语言，以及一种像 ...在这一点上......）事情是并行发生的，而不是以任何特定的顺序发生的：VHDL 的真正优势在于它可以安全地执行！

在一个进程中，您可以将其视为一种顺序语言，具有函数、过程（对 C 程序员来说是无效函数！）、变量、循环、if/then/else 和熟悉的顺序语义 - 除了一个例外：信号具有不同的语义，因为它们是（通常是不同的）进程之间进行通信的手段。（典型的 C 程序是单个进程：如果您编写多线程 C 程序，您会知道您需要一个非常不同的学科和额外的支持，如线程库）。

VHDL 的另一个方面是并行方面，您可以在其中创建多个单元 - 基本上所有进程彼此独立运行，通过信号进行通信。在进程之外，您有一组不同的编程工具：

  • 实体/架构是一组流程的包装器。

  • 组件是相同的，因为它们只是映射到实体（通过配置，以允许您选择不同的实体或架构）。如果您不需要重新映射它们，您可以消除组件并直接在设计中实例化实体。

  • 简单的信号分配，例如 p <= A XOR B；流程之外是完成单个分配的完整流程的简写。

  • 还有条件信号分配和选定信号分配，例如

    p <= A when B = '1' else C;这些又是流程的简写。

  • 连接多个并行进程变得乏味：这些Generate语句是自动化该工作的工具。

混合这两个域是错误的：例如a := b;在进程外部使用 if/then/else 或变量赋值，或者在一个内部实例化组件或使用Generate。现在，在里面ARCHITECTURE SSTA32_arch of SSTA32你可以看到这样的错误......

我不会修复你的项目，我认为你不希望我这样做；但这里有几个指针：

  • 虽然您可以在进程之外使用变量和变量赋值，但这通常是一个错误：这些被称为“共享变量”并且（在 C 程序员术语中）不是线程安全的，并且通常不会按照您的期望进行。使用信号（并学习它们的语义）是这里的方法。

  • 虽然您不能if a then b else c;在进程外使用，但您可以使用if a generate b; end generate; if not a generate c; end generate;并且可以嵌套生成语句。

  • 更好的格式将使阅读更容易，错误更容易发现。

  • 我认为您可能希望在某些地方使用“elsif”而不是“else if”：这解决了很多缺失的“end if”问题

编辑：更新答案的更多指针...

  • 架构中的“不允许变量声明”仍然是一个问题……乍一看，我不明白您为什么不使用信号。

  • 乍一看：

     F2 : IF i=3 GENERATE
    BEGIN 
       Grey_box_i: Grey_box PORT MAP(NewP(m), NewBG(m), NewGG(m), DNewG);
       m := m+1;
    END GENERATE F2;

您不能在这样的 Generate 语句中使用变量（因为它们在进程之外）。我怀疑您打算将它们的价值本质上是静态的-（i）的确定性函数，而不是他们自己的状态持有者。

编译器不知道这一点 - 它看到更多可能在运行时发生变化的状态（并且你不能在运行时增加更多硬件！）所以它拒绝了这个想法。例如，通过最后生成“i=3”的情况生成的硬件没有排序Generate是完全合法的，并且您不能保证m 的值。你可能不喜欢这个结果！

解决方案很简单：将 m 作为变量消除并使其成为 (i) 的函数。

 function m(x : integer) return integer is
 begin
   case x is
      when 3      => return 0;
      when others => return 1;
   end case;
 end m;

 ... PORT MAP(NewP(m(i)), ...

这些函数与其他声明一起属于体系结构。因为i在生成语句的任何实例中都是固定的（静态的），所以 f(i) - 这里是 m(i) - 也是静态的，虽然我没有测试过这种方法，但我希望它可以工作。

  • 至于未知标识符，我在上面的代码片段中看到了各种名称，例如 DNEWG，但我找不到声明；这很容易解决。

  • 您可以在 if 表达式周围丢失不必要的括号；它们只是路过的 C 程序员留下的杂物

于 2013-10-05T11:52:25.220 回答
0

基于结构的缩进往往会暴露语法问题，所以我冒昧地美化了你的代码。正如您在最后一部分中看到的，许多 if语句没有适当的结束end if语句。必须修复该语法错误，您可以考虑使用elsif互斥条件。

关于你的问题：

  1. 我应该在敏感度列表中放入什么：对于描述触发器的过程，敏感度应该必须是时钟和任何异步复位信号。对于描述组合逻辑的过程，灵敏度列表必须包含组合逻辑中使用的所有源信号。通常，您编写的任何过程都应该是这两个中的任何一个，因此要么描述触发器，要么描述组合逻辑。问题后的流程不是这两个，存在多个问题：不允许在一个流程内部实例化模块，Grey_box和Black_box，一般不能将k用作变量，有:=assign，没有在此过程中声明它。

  2. 如何使 p 和 g 全局化；我做的还不够吗？ p 和 g 自体系结构中声明以来就可用，因此问题是由于尝试实例化模块 ia 进程，正如我上面提到的。

总体而言，您可能会考虑在开始这样的大型项目之前更好地了解 VHDL 概念，因为这样会更容易理解和纠正您遇到的任何语法错误消息。

一个很好的起点是Wikipedia VHDL 页面，您可以在此查看进一步阅读。为了获得良好的 VHDL 体验，我建议您深入研究一些资源来学习基本概念。

于 2013-10-05T11:52:11.413 回答