1 бит ALU, чьи операции зависят от переноса в

Question

Я должен спроектировать 1-битный ALU для назначения, который затем будет повторно использован для создания 4-х блоков и 4-битного ALU.

1 бит ALU имеет 2 строки выбора и входы A, B и перенос.

Моя проблема в том, что строки выбора И флаг переноса выбирают, какую операцию выбрать. Я просто понятия не имею, как использовать строки выбора и флаг переноса одновременно для выбора операции.

Например, строки выбора "00" и Cin "0" - это операция сложения, тогда как Cin "1" - вычитание.

Могу ли я сделать то, что я сделал ниже? Спасибо за вашу помощь.

entity ALU1Bit is
port(
    A:  IN std_logic_vector;
    B:  IN std_logic; 
    carryIn:      IN std_logic;                                  
    operation: IN std_logic_vector(1 downto 0); 

    F:   OUT std_logic;
    carryOut: OUT std_logic
    );
end ALU1Bit;

architecture Behavioral of ALU1Bit is

component Adder1Bit
port(
    carryIn:  IN std_logic;
    A: IN std_logic;
    B: IN std_logic;

    output:  OUT std_logic;
    F: OUT std_logic
    );
end component;

begin
carryIn <= '0';
    case operation is
        when...
carryIn <= '1';
    case operation is
        when...

end Behavioral;

Answer 1

Похоже, что вам не хватает того, что вы можете иметь вложенные операторы case. Ваш код:

carryIn <= '0';
    case operation is
        when...
carryIn <= '1';
    case operation is
        when...

Находится на правильных строках, но оператор case должен находиться внутри процесса, и, как говорит Брайан, вы пытаетесь присвоить "0" и "1" входу carryIn, что недопустимо. Я думаю, что вы имели в виду с этими двумя строками, чтобы они работали как другое утверждение случая. Вы хотите что-то похожее на:

process (carryIn, operation, ...)
begin
    case carryIn is
        when '0' =>
            case operation is
                when "00" => ...
                when "01" => ..
            end case;
        when '1' =>
            case operation is =>
            ...
    end case;
end process;

Кажется вероятным, что у вас могут быть перекрывающиеся случаи, то есть два или более случаев в этой структуре, которые фактически делают одно и то же. Это плохо, потому что каждый раз, когда вам нужно изменить то, что происходит в этих случаях, вы должны изменить их дважды, что подвержено ошибкам.

В этом случае вы можете иметь один оператор case, подобный приведенному выше, который просто назначает рабочий режим, используя перечисляемый тип, например:

type ALU_OP_type is (ADD, SUBTRACT, ...);
signal aluOp : ALU_OP_type;

тогда в вашем процессе:

    case carryIn is
        when '0' =>
            case operation is
                when "00" => aluOp <= ADD;
                when "01" => aluOp <= SUBTRACT;

и т.д. Затем, наконец, еще один оператор case (возможно, в отдельном процессе), который использует эти простые читаемые операции, чтобы сделать что-то:

    case aluOp is
        when ADD => ...
        when SUBTRACT => ...

и т. д. Ваш код тогда хорошо разделен на "отрабатывать то, что мы собираемся делать" и "делать что-то". Если у вас нет повторяющихся комбинаций переноса / операции, то это, вероятно, не стоит усилий.