Вопрос показывает мышление синтаксиса Python.
В массиве std_logic_vector преобразуется массив ограниченных целых чисел, которые преобразуются в двоичное представление.
Первый рабочий Пример минимального, завершенного и проверяемого значения для назначения одного элемента клева:
library ieee;
use ieee.std_logic_1164.all;
entity depython is
end entity;
architecture foo of depython is
type t_slave_24symbol is array (natural range <>) of integer range 0 to 2;
signal slave_24symbol: t_slave_24symbol (0 to 23);
type nibble_array is array (0 to 7) of std_logic_vector(3 downto 0);
signal nibble: nibble_array;
signal nibble_full: std_logic_vector(31 downto 0) := (others => '0');
subtype nyyblet is t_slave_24symbol (0 to 2);
begin
-- nibble(0) <= "0000" when slave_24symbol(012) = 120 else--
-- "0001" when slave_24symbol(012)= 200 else
-- "0010" when slave_24symbol(012)= 020 else
-- "1111";
-- BECOMES:
nibble(0) <= "0000" when slave_24symbol(0 to 2) = nyyblet'(1, 2, 0) else
"0001" when slave_24symbol(0 to 2) = nyyblet'(2, 0, 0) else
"0010" when slave_24symbol(0 to 2) = nyyblet'(0, 2, 0) else
"1111";
end architecture;
Тип t_slave_24symbol был изменен на определение неограниченного массива с объявлением сигнала slave_24symbol, предоставляющего подтип. (Это называется определением неограниченного массива в -2008).
Диапазон индекса фрагмента slave_24symbol изменен на синтаксис VHDL. Диапазон значений выражения, оцениваемого в каждом условии, был изменен на синтаксис VHDL с использованием агрегата, тип которого предоставляется квалифицированным выражением, требующим определения подтипа. Объявление подтипа требует определения неограниченного / неограниченного массива.
В квалифицированном выражении требуется указать подтип, потому что предопределенный оператор равенства для типа массива работает с неограниченными операндами - вы можете проверить равенство двух массивов различной длины, и они всегда будут неравными. (Пригодится при работе с нулевыми массивами).
Обратите внимание, что тип строкового литерала (например, "0010") определяется контекстом, а значения элемента ('0', '1') должны быть совместимы с типом элемента (здесь std_ulogic) типа массива (здесь std_logic_vector).
Это анализирует, разрабатывает и моделирует (используя значение по умолчанию (0, 0, 0) для каждого элемента slave_24symbol, каждый процесс будет выполняться один раз во время инициализации, оператор параллельного присваивания превращается в эквивалентный оператор последовательного присваивания, содержащийся в утверждение процесса).
Теперь мы рассмотрим, как преобразовать все элементы nibble в новую архитектуру:
architecture sequential of depython is
type t_slave_24symbol is array (natural range <>) of integer range 0 to 2;
signal slave_24symbol: t_slave_24symbol (0 to 23);
type nibble_array is array (0 to 7) of std_logic_vector(3 downto 0);
signal nibble: nibble_array;
signal nibble_full: std_logic_vector(31 downto 0) := (others => '0');
subtype nyyblet is t_slave_24symbol (0 to 2);
function nybble (nyb: nyyblet) return std_logic_vector is
-- retv: std_logic_vector(3 downto 0);
begin
if nyb = nyyblet'(1, 2, 0) then
return "0000";
elsif nyb = nyyblet'(2, 0, 0) then
return "0001";
elsif nyb = nyyblet'(0, 2, 0) then
return "0010";
else
return "1111";
end if;
end function;
begin
-- nibble(0) <= "0000" when slave_24symbol(0 to 2) = nyyblet'(1,2,0) else
-- "0001" when slave_24symbol(0 to 2) = nyyblet'(2,0,0) else
-- "0010" when slave_24symbol(0 to 2) = nyyblet'(0,2,0) else
-- "1111";
-- but later
--
-- nibble(3) <= "0000" when slave_24symbol(91011) = 012 else
--
-- . . .
--
-- and at the end
--
-- nibble_full <= nibble(0) & nibble(1) & nibble(2) & nibble(3) & nibble(4)
-- & nibble(5) & nibble(6) & nibble(7);
process (slave_24symbol)
begin
for i in nibble'range loop
nibble(i) <= nybble(slave_24symbol(3 * i to 2 + i * 3));
end loop;
end process;
end architecture;
Здесь вызов функции используется, чтобы скрыть некоторые сложности. Оператор последовательного присваивания в операторе цикла (сам последовательный оператор) использует арифметику смещения для адресации всех восьми срезов трех ограниченных целых чисел slave_24symbol, которые оцениваются.
И поскольку вопрос показал, что при условном назначении сигнала (в данном случае это одновременное назначение сигнала) был назначен полубайтовый элемент, версия параллельного назначения с использованием оператора generate:
architecture concurrent of depython is
type t_slave_24symbol is array (natural range <>) of integer range 0 to 2;
signal slave_24symbol: t_slave_24symbol (0 to 23);
type nibble_array is array (0 to 7) of std_logic_vector(3 downto 0);
signal nibble: nibble_array;
signal nibble_full: std_logic_vector(31 downto 0) := (others => '0');
subtype nyyblet is t_slave_24symbol (0 to 2);
function nybble (nyb: nyyblet) return std_logic_vector is
-- retv: std_logic_vector(3 downto 0);
begin
if nyb = nyyblet'(1, 2, 0) then
return "0000";
elsif nyb = nyyblet'(2, 0, 0) then
return "0001";
elsif nyb = nyyblet'(0, 2, 0) then
return "0010";
else
return "1111";
end if;
end function;
begin
-- process (slave_24symbol)
-- begin
-- for i in nibble'range loop
-- nibble(i) <= nybble(slave_24symbol(3 * i to 2 + i * 3));
-- end loop;
-- end process;
NIBBLE_IT:
for i in nibble'range generate
nibble(i) <= nybble(slave_24symbol(3 * i to 2 + i * 3));
end generate;
end architecture;
Все показанные архитектуры анализируют, разрабатывают и моделируют, демонстрируя, что все индексы и срезы попадают в границы подтипа.
Обратите внимание, что вы также можете вставить оператор цикла в функцию с типом параметра t_slave_24symbol и выполнить одно присваивание либо одновременно, либо последовательно. Это также позволило бы обнаружить значение параметра, которое не состоит из кратных 3 целых чисел (поскольку тип t_slave_24symbol объявлен неограниченным / неограниченным). Можно избежать обнаружения любого значения параметра, объявив новый тип и сделав подтипы t_slave_24symbol и nyyblet нового типа:
architecture all_in_one_function of depython is
type c_integer_array is array (natural range <>) of integer range 0 to 2;
subtype t_slave_24symbol is c_integer_array (0 to 23);
signal slave_24symbol: t_slave_24symbol := (
1,2,0, 2,0,0, 0,2,0, 0,0,0, 0,0,1, 0,0,2, 0,1,0, 0,1,1);
signal nibble_full: std_logic_vector (31 downto 0);
function nybble (slave: t_slave_24symbol) return std_logic_vector is
type nibble_array is array (0 to 7) of std_logic_vector(3 downto 0);
variable nib: nibble_array;
subtype nyyblet is c_integer_array (0 to 2);
begin
for i in nib'range loop
if slave(3 * i to 2 + i * 3) = nyyblet'(1, 2, 0) then
nib(i) := "0000";
elsif slave(3 * i to 2 + i * 3) = nyyblet'(2, 0, 0) then
nib(i) := "0001";
elsif slave(3 * i to 2 + i * 3) = nyyblet'(0, 2, 0) then
nib(i) := "0010";
else
nib(i) := "1111";
end if;
end loop;
return nib(0) & nib(1) & nib(2) & nib(3) &
nib(4) & nib(5) & nib(5) & nib(7);
end function;
function to_string (inp: std_logic_vector) return string is
variable image_str: string (1 to inp'length);
alias input_str: std_logic_vector (1 to inp'length) is inp;
begin
for i in input_str'range loop
image_str(i) := character'VALUE(std_ulogic'IMAGE(input_str(i)));
end loop;
return image_str;
end function;
begin
NIBBLE_IT:
nibble_full <= nybble(slave_24symbol);
process
begin
wait for 0 ns;
report "nibble_full = " & to_string (nibble_full);
wait;
end process;
end architecture;
Функция to_string добавлена для совместимости с версиями VHDL ранее, чем -2008. Сигнал _slave_24symbol инициализируется, чтобы продемонстрировать успешное преобразование:
/ usr / local / bin / ghdl -a depython1.vhdl
/ usr / local / bin / ghdl -e depython
/ usr / local / bin / ghdl -r depython
depython1.vhdl: 79: 9: @ 0ms: (примечание к отчету): nibble_full = 00000001001011111111111111111111