Built-in Attribute Example - EDA Playground
Warning! This exercise has been opened in another tab; autosave has been disabled. Close this tab or refresh to reactivate.

 Languages & Libraries

 Tools & Simulators

 Examples

209


144
 
1
-- THE EXAMPLES ARE DIRECTLY BELOW
2
                                                               library IEEE;
3
                                                               use IEEE.STD_LOGIC_1164.all;
4
                                                               use STD.TEXTIO.all;
5
                                                               use IEEE.STD_LOGIC_TEXTIO.all;
6
    
7
                                                               entity EX_ATTRIBUTE_NAME is
8
                                                               end EX_ATTRIBUTE_NAME;
9
  
10
                                                               architecture A1 of EX_ATTRIBUTE_NAME is
11
----------------------------------------
12
​
13
  -- VHDL-2008 EXAMPLE
14
15
  type myMem is array(POSITIVE range<>) of STD_LOGIC_VECTOR;
16
  subtype mem2_t is myMem(1 to 512)(15 downto 0);
17
  signal mem3 : mem2_t;
18
​
19
  /* mem2_t (512x16) */
20
  signal mem4 : mem3'subtype;
21
​
22
​
23
  -- PRE VHDL-2008 EXAMPLES
24
​
25
  type T is (A, B, C, D, E);
26
  subtype S is T range D downto B;
27
  signal V, W: STD_LOGIC_VECTOR(7 downto 0) := "10001010";
28
​
29
----------------------------------------
30
                                          begin
31
                                            Monitor: process
32
                                              file F: TEXT open WRITE_MODE is "STD_OUTPUT";
33
                                              variable L: LINE;
34
                                            begin
35
                                              WRITE (L, STRING'("type T is (A, B, C, D, E)"));
36
                                              WRITELINE (F, L);
37
                                              WRITE (L, STRING'("subtype S is T range D downto B"));
38
                                              WRITELINE (F, L);  
39
/* D */                                       WRITE (L, STRING'("S'LEFT = ")); WRITE (L, TO_STRING(
40
S'LEFT                                                           ));
41
                                              WRITELINE(F, L);
42
/* B */                                       WRITE (L, STRING'("S'RIGHT = ")); WRITE (L, TO_STRING(
43
S'RIGHT                                                          ));
44
                                              WRITELINE(F, L);
45
/* B */                                       WRITE (L, STRING'("S'LOW = ")); WRITE (L, TO_STRING(
46
S'LOW                                                            ));
47
                                              WRITELINE(F, L);
48
/* D */                                       WRITE (L, STRING'("S'HIGH = ")); WRITE (L, TO_STRING(
49
S'HIGH                                                           ));
50
                                              WRITELINE(F, L);
51
/* A */                                       WRITE (L, STRING'("S'BASE'LEFT = ")); WRITE (L, TO_STRING(
52
S'BASE'LEFT                                                      ));
53
                                              WRITELINE(F, L);
54
/* TRUE */                                    WRITE (L, STRING'("T'ASCENDING = ")); WRITE (L,
55
T'ASCENDING                                                      );
56
                                              WRITELINE(F, L);
57
/* FALSE */                                   WRITE (L, STRING'("S'ASCENDING = ")); WRITE (L,
58
S'ASCENDING                                                      );
59
                                              WRITELINE(F, L);
60
/* "a" */                                     WRITE (L, STRING'("T'IMAGE(A) = ")); WRITE (L,
61
T'IMAGE(A)                                                       );
62
                                              WRITELINE(F, L);
63
/* E */                                       WRITE (L, STRING'("T'VALUE(""E"") = ")); WRITE (L, TO_STRING(
64
T'VALUE("E")                                                     ));
65
                                              WRITELINE(F, L);
66
/* 0 */                                       WRITE (L, STRING'("T'POS(A) = ")); WRITE (L,
67
T'POS(A)                                                         );
68
                                              WRITELINE(F, L);
69
/* 1 */                                       WRITE (L, STRING'("S'POS(B) = ")); WRITE (L,
70
S'POS(B)                                                         );
71
                                              WRITELINE(F, L);
72
/* E */                                       WRITE (L, STRING'("T'VAL(4) = ")); WRITE (L, TO_STRING(
73
T'VAL(4)                                                         ));
74
                                              WRITELINE(F, L);
75
/* C */                                       WRITE (L, STRING'("S'SUCC(B) = ")); WRITE (L, TO_STRING(
76
S'SUCC(B)                                                        ));
77
                                              WRITELINE(F, L);
78
/* B */                                       WRITE (L, STRING'("S'PRED(C) = ")); WRITE (L, TO_STRING(
79
S'PRED(C)                                                        ));
80
                                              WRITELINE(F, L);
81
/* C */                                       WRITE (L, STRING'("S'LEFTOF(B) = ")); WRITE (L, TO_STRING(
82
S'LEFTOF(B)                                                      ));
83
                                              WRITELINE(F, L);
84
/* B */                                       WRITE (L, STRING'("S'RIGHTOF(C) = ")); WRITE (L, TO_STRING(
85
S'RIGHTOF(C)                                                     ));
86
                                              WRITELINE(F, L);
87
                                              WRITELINE(F, L);
88
                                              WRITE (L, STRING'("signal V: STD_LOGIC_VECTOR(7 downto 0)"));
89
                                              WRITELINE(F, L);
90
/* 7 */                                       WRITE (L, STRING'("V'LEFT = ")); WRITE (L,
91
V'LEFT                                                           );
92
                                              WRITELINE(F, L);
93
/* 0 */                                       WRITE (L, STRING'("V'RIGHT = ")); WRITE (L,
94
V'RIGHT                                                          );
95
                                              WRITELINE(F, L);
96
/* 0 */                                       WRITE (L, STRING'("V'LOW = ")); WRITE (L,
97
V'LOW                                                            );
98
                                              WRITELINE(F, L);
99
/* 7 */                                       WRITE (L, STRING'("V'HIGH = ")); WRITE (L,
100
V'HIGH                                                           );
101
                                              WRITELINE(F, L);
102
/* 8 */                                       WRITE (L, STRING'("V'LENGTH = ")); WRITE (L,
103
V'LENGTH                                                         );
104
                                              WRITELINE(F, L);
105
/* FALSE */                                   WRITE (L, STRING'("V'ASCENDING = ")); WRITE (L,
106
V'ASCENDING                                                      );
107
​
108
----------------------------------------
109
                                              WRITELINE(F, L);
110
                                             wait;
111
                                           end process Monitor;
112
​
113
​
114
                                           Count_Ones: process(V, W)
115
                                             file F: TEXT open WRITE_MODE is "STD_OUTPUT";
116
                                             variable L: LINE;
117
----------------------------------------
118
119
  -- EXAMPLE IN A FUNCTION
120
​
121
  function ONES (A: Std_logic_vector) return Integer is
122
    variable N: Integer range 0 to A'LENGTH := 0;
123
  begin
124
    for I in A'RANGE loop
125
      if A(I) = '1' then
126
        N := N + 1;
127
      end if;
128
    end loop;
129
    return N;
130
  end ONES;
131
132
----------------------------------------
133
                                           begin
134
                                             if ONES(V) > 2 then
135
                                              WRITELINE(F, L);
136
                                             WRITE(L, STRING'("ONES(V) + ONES(W) = "));
137
                                               WRITE(L, ONES(V) + ONES(W));
138
                                              WRITELINE(F, L);
139
                                              WRITELINE(F, L);
140
                                             end if;
141
                                           end process Count_Ones;
142
                                          
143
                                         end architecture A1;
144
​
xxxxxxxxxx
1
 
1
​
224 views and 0 likes     
 
# Built-in Attribute Example
An attribute gives extra information about a specific part of a VHDL description, and can be user defined or predefined. User defined attributes are constants, whereas predefined attributes can be constants, functions or signals.
​
The examples themselves are explained in the comments.

Built-in Attribute Example

An attribute gives extra information about a specific part of a VHDL description, and can be user defined or predefined. User defined attributes are constants, whereas predefined attributes can be constants, functions or signals.

The examples themselves are explained in the comments.

4460:0