Category: Betting

The logical operators NOT, AND, OR, NAND, NOR, and XOR can be used with any bit type or bit_vector. When used as operators on bits they have their usual meaning. When used with bit_vectors, the bit_vectors must have the same number of elements, and the operation is performed bitwise. For example, "00101001" xor "11100101" results in "11001100".

*note: just as '0' and '1' represent constant bit values, constant bit_vectors can be written in VHDL as a list of bit values in double quotes. For example, if d is a bit_vector(1 to 4) the following statement gives d the permanent values d(1)='1', d(2)='1', d(3)='0', and d(4)='0'. *

* Hexadecimal can also be used as a shortcut as in the following example. *

* Since C is the hexadecimal number 12, which in binary is 1100, this statement is equivalent to the one preceeding it. The X in the front indicates that the number is in hexadecimal instead of the normal binary.*

The typical algebraic operators are available for integers, such as +,-,* (multilication), and / (division). Although these operations are not built-in for bit_vectors, they are often provided in libraries that come with your VHDL software. They are used with bit_vectors by interpreting them as a binary representation of integers, which may be added, subtracted, multiplied, or divided.

Also predefined are the normal relational operators. They are =, /=, <, <=, > and >= and have their usual meanings (/= denotes the not equal operator). The result of all these operators is a boolean value (TRUE or FALSE). The arguments to the = and /= operators may be of any type. The arguments of the <, <=, > and >= operators may be any scalar type (integer, real, and physical types) or the bit_vector type. If the arguments are bit_vectors, then the arguments must be the same length and the result is TRUE only if the relation is true for each corresponding element of the array arguments.

The & operator is a built-in VHDL operator that performs the concatenation of bit_vectors. For example, with the following declarations: The following statement would connect *a* to the right half of *b* and make the left half of *b* constant '0'. The & appends the *a* to the end of the "0000" to form a result that contains 8 bits.

The next section is Behavioral Descriptions - The Process Statement. Copyright 1995, Green Mountain Computing Systems.

Copying this document is strictly prohibited. Making any non-volatile or semi-permanent copies of this document is a violation of international copyright laws.

Created on: 19 February 2013

Adding two unsigned 4-bit numbers in VHDL using the VHDL addition operator (+) – a 4-bit binary adder is written in VHDL and implemented on a CPLD.

There are many examples on the Internet that show how to create a 4-bit adder in VHDL out of logic gates (which boils down to using logical operators in VHDL). A full adder adds only two bits and a carry in bit. It also has a sum bit and a carry out bit. The idea is that a number of these 1-bit adders are linked together to form an adder of the desired length.

It may not be necessary to implement an adder in this way, as VHDL can use the addition operator (+) to add two numbers. We will look at adding two STD_LOGIC_VECTOR data types together.

The design is implemented on a CPLD on the home built CPLD board. Half of the switch bank on the board (4 switches) is used to input one of the values to be added, the other half of the switch bank is used to input the second value to be added. The result (sum) of the addition of the two 4-bit numbers is displayed on 5 LEDs.

This video shows the binary adder in operation:

From the previous tutorial, we know that we can add two numbers together that are of the STD_LOGIC_VECTOR data type if we use the STD_LOGIC_SIGNED or the STD_LOGIC_UNSIGNED package from the IEEE library, e.g.:

This enables us to use inputs connected to switches and outputs connected to LEDs of the STD_LOGIC_VECTOR type defined in the Ports section of the ENTITY part of the VHDL.

Adding two numbers in the ARCHITECTURE part of the VHDL is as simple as this:

We will be using two 4-bit inputs connected to 4 switches each as our numbers that will be added together. So the size of these numbers will be 4 bits each (3 downto 0).

The biggest output number (sum) generated by adding two 4-bit numbers together will be 1111b + 1111b = 11110b. So the vector used for our sum needs to be 5 bits in length (4 downto 0).

The only problem with adding two 4 bit numbers in VHDL and then putting the result in a 5 bit vector is that the highest bit (or carry) will be truncated. In other words, even if the size of the sum vector is 5 bits, a 4 bit sum will be placed in it.

We will now look at two ways of implementing the same 4-bit binary adder and solve the problem of adding two 4-bit numbers and displaying the 5-bit result.

The first way of solving the problem of adding two 4-bit numbers and displaying the 5-bit result is to make the two 4-bit input numbers 5 bits in length, but keep the MSB of each number at 0.

This code shows how to implement the adder in VHDL:

The code makes all the vectors to be 5 bits wide. The two input vectors are initialized with a value of 00000b so that the MSB is always 0.

To implement the above code on the home built CPLD board, we need to compensate for the inverting inputs and outputs connected to the switches and LEDs by inverting all inputs and outputs:

In the above code, the inputs are initialized to 11111b because they will be inverted to 00000b by the code at the bottom of the ARCHITECTURE implementation.

The inputs from the switches (NUM1 and NUM2) are inverted before doing the addition. The result of the addition is inverted before displaying it on the LEDs (SUM).

This is a better solution to the problem of adding two 4-bit numbers and displaying the result in a 5-bit vector. The VHDL concatenation operator (&) is used to put a 0 in front of each of the the two 4-bit numbers before adding them.

The concatenation operator can be used to join extra data to the left or the right of the vector:

VHDL code for the second adder example:

Again, we need to compensate for the inverting inputs and outputs of the home built CPLD board. The VHDL code below works the same way as the code above, but inverts all inputs and outputs:

VHDL CPLD Course

© 2012 – 2017, Starting Electronics

Get via App Store Read this post in our app!

I am trying to make a binary divider to be part of a calculator using VHDL, I have written the code that I think should work but have been stuck for hours, can someone please help me.

In the iteration part of the divide process, when Ain > Bin , the assign Atemp <= (Ain - Bin) is always performed, even if the iteration should be completed. Process that assign to a signal also in the sensitivity list, is hard to get right.

The code may be updated with Atemp as a variable instead, some other simplifications with removal of unrequired code, and adding value for remainder when Ain = Bin , resulting in architecture as:

The inner process statements may actually be reduced to:

Whether this will synthesize to the required frequency with the unrolled while is another question, that depends on the target frequency and technology.

An alternative solution, given the short Ain and Bin , is to implement the divider using a constant lookup table, with address as Ain & Bin and output of Q & R . This will evaluate in fixed time, and synthesis is very likely to reduce considerably if made as combinatorial logic.

Last comment is that you may also want to handle division by zero, when Bin is zero.

To prevent mistakes, it is advisable to use explicitly the type unsigned or signed when implementing arithmetic circuits. The numeric_std package contains the following arithmetic operators for these types: +, -, *, /, abs, rem, mod.

Below is a suggested code (for unsigned division). Note that some lines in the arch can be eliminated, but were used to make the code more "didactic".

Get via App Store Read this post in our app!

Whats the difference between using:

What are the limitations of using BIT over STD_LOGIC and vice-versa? Are they completely interchange able? I understand that if I've define STD_LOGIC I can't use it with a BIT_Vector to access the elements in the array. But I can't seem to see the difference.

Bit is a predefined type and only can only have the value 0 or 1 . The Bit type is an idealized value.

std_logic is part of the std_logic_1164 package and provides more realistic modeling of signals within a digital system. It is capable of having nine different values. Typically within your code you will only use 0 , 1 , and Z (High-Z). But U (Uninitialized) and X (Unknown) are also very useful when modeling the system in a testbench.

The std_logic_1164 package also provides conversion functions to convert std_logic to Bit .

Most people use std_logic . That allows for u (undefined), x (unknown) and z (high impedance), which bit doesn't. While you may never tristate in a chip and therefore don't need z , u is useful for finding missing resets. x is useful for finding multiple drivers.

*std_logic has a resolution function*

Not only does std_logic have more useful states besides 1 and 0 , it also has a resolution function defined.

A resolution function is a VHDL language concept. It is a function that is associated to a type, and it determines what happens when multiple values of that type are applied to a single signal. The syntax is:

where std_ulogic is the unresolved (and thus much less useful) version of std_logic .

In particular, this implies nice things like 0 and 1 leads to X :

This makes intuitive sense, as we understand X to be the state where multiple incompatible values are applied to a single wire.

std_logic also knows how to resolve every other possible pair of input signals according to a table present on the LRM.

bit on the other hand, does not have a resolution function, and if we had used it on the above example, it would lead to a simulation error on GHDL 0.34.

The possible values of std_logic are a good choice because they are standardized by IEEE 1164 and deal with many common use cases.

*std_logic* is richer than *bit*, and should basically be used most of the time.

There is also the *boolean* type, which, like *bit*, has two values. It is the result type of comparisons, the type expected after an IF *[bool]* or a WHEN *[bool]*, often used for selection constants : constant ENABLE_DEBUG_INTERFACE : boolean := true;

One place where *bit* can be preferred to *std_logic* is for large arrays, memories. On optimizing simulators, bit occupies less area in the simulator's memory than *std_logic*. And it may matter if your design instantiates one GB of RAM.

It can also be faster for very large designs, for example something automatically generated from post-synthesis gate-level netlist.

Of course, this performance aspect is not part of the language, and depends on the implementation of the VHDL simulator.

Counters are a principle part of nearly every FPGA design, facilitating time tracking in logic circuits by counting clock cycles. I’m going to discuss VHDL counter construction, and I also want to share a very practical counter tip that I picked up from a colleague many years back: count backwards.

This article will cover the following concepts:

- Counter Concepts
- VHDL Implementation
- Synthesis Considerations
- Typical Uses

For a Verilog counter, see our corresponding counter article with example code.

The general idea behind the counter is pretty simple:

Start at some initial count value and store it in a register.

Increment the counter.

Save the new count value back into the register.

The counters that I’m going to implement for you in this VHDL counter example count backwards and forwards from/to 12. It may sound strange, but I have a very good reason for counting backwards, and I’ll get into that in the Synthesis Considerations section. After all, it’s just as easy to compute x-1 as it is to compute x+1.

The code example implements a 5-bit counter that counts backwards, and two 4-bit counters that count forward–one of which is allowed to free run.

entity counter is

CLK : in std_logic;

RST : in std_logic;

F_COUNT_OUT : out unsigned(3 downto 0);

B_COUNT_OUT : out unsigned(3 downto 0);

FR_COUNT_OUT : out unsigned(3 downto 0)

architecture bhv of counter is

constant count_stop : unsigned(3 downto 0) := X”C”;

© Sports Betting 2018