VHDLにおけるsigned型の基礎知識18選

●VHDLのsigned型とは？
●VHDLにおけるsigned型の宣言テクニック
●signed型の演算をマスターしておこう
●型変換のテクニック
●VHDLにおける組み合わせ回路設計
●よくあるエラーと対処法
●signed型の高度な応用例
まとめ

●VHDLのsigned型とは？

デジタル回路設計の分野で重要な役割を果たすVHDL。その中でも、signed型は数値表現において欠かせない存在です。

VHDLを学ぶ皆さん、特に将来FPGA開発エンジニアを目指す方々にとって、signed型の理解は極めて重要となります。

では、signed型の基本概念から、実際の使用方法まで、順を追って解説していきましょう。

○signed型の基本概念

signed型は、VHDLにおいて符号付き整数を表現するためのデータ型です。

通常のプログラミング言語における「整数型」と似ていますが、ハードウェア記述言語であるVHDLならではの特徴があります。

signed型は2の補数表現を使用し、正の数と負の数の両方を表現できます。

ビット列の最上位ビットが符号ビットとなり、0なら正の数、1なら負の数を表します。

例えば、4ビットのsigned型で「0101」は10進数の5を、「1011」は-5を表現します。

signed型の利点は、加算や減算などの演算が自然に行えることです。

ハードウェア設計者にとって、この特性は非常に重要となります。

○signed型とunsigned型の違い

VHDLには、signed型の他にunsigned型も存在します。

両者の違いを理解することで、適切なデータ型の選択ができるようになります。

unsigned型は、その名の通り符号なしの整数を表現します。

すべてのビットが数値を表すため、同じビット幅であればsigned型よりも大きな正の数を表現できます。

例えば、4ビットのunsigned型で「1111」は10進数の15を表しますが、signed型では「0111」（7）が表現できる最大の正の数となります。

signed型を使用すべき場面は、負の数を扱う必要がある場合や、減算を頻繁に行う回路を設計する際です。

一方、unsigned型は、カウンタや正の数のみを扱う場合に適しています。

○サンプルコード1：signed型の基本的な宣言と初期化

では、実際にsigned型を使用したVHDLコードを見てみましょう。

基本的な宣言と初期化の方法を紹介します。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity signed_example is
end signed_example;

architecture Behavioral of signed_example is
    -- 8ビットのsigned型変数を宣言
    signal a : signed(7 downto 0);
    -- 16ビットのsigned型変数を宣言し、初期値を設定
    signal b : signed(15 downto 0) := to_signed(100, 16);
    -- 定数の宣言
    constant c : signed(7 downto 0) := to_signed(-50, 8);
begin
    -- プロセス内でsigned型変数を使用
    process
    begin
        a <= to_signed(25, 8);
        wait for 10 ns;
        -- ここで他の処理を追加できます
    end process;
end Behavioral;

このコードでは、8ビットと16ビットのsigned型変数を宣言しています。

to_signed関数を使用して、整数値をsigned型に変換しています。

bは初期値として100を、cは定数として-50を設定しています。

実行結果は次のようになります。

# シミュレーション結果
Time: 0 ns
a = "UUUUUUUU" (未定義)
b = "0000000001100100" (100)
c = "11001110" (-50)

Time: 10 ns
a = "00011001" (25)
b = "0000000001100100" (100)
c = "11001110" (-50)

signed型の基本を理解することで、より複雑な回路設計の基礎が築けます。

次節では、さらに深くsigned型の宣言テクニックに踏み込んでいきます。

●VHDLにおけるsigned型の宣言テクニック

signed型の基本を押さえたところで、より実践的な宣言テクニックを学んでいきましょう。

VHDLでは、状況に応じて様々な方法でsigned型を宣言できます。

適切な宣言方法を選択することで、柔軟で保守性の高い設計が可能となります。

○サンプルコード2：異なるビット幅でのsigned型宣言

実際の回路設計では、様々なビット幅のsigned型変数を扱う必要があります。

ここでは、異なるビット幅でのsigned型宣言方法を紹介します。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity different_width_signed is
end different_width_signed;

architecture Behavioral of different_width_signed is
    -- 8ビットのsigned型
    signal small_signed : signed(7 downto 0);
    -- 16ビットのsigned型
    signal medium_signed : signed(15 downto 0);
    -- 32ビットのsigned型
    signal large_signed : signed(31 downto 0);
    -- 奇数ビット幅のsigned型
    signal odd_width_signed : signed(13 downto 0);
begin
    process
    begin
        small_signed <= to_signed(127, 8);  -- 最大正の値
        medium_signed <= to_signed(-32768, 16);  -- 最小負の値
        large_signed <= to_signed(2147483647, 32);  -- 32ビットの最大正の値
        odd_width_signed <= to_signed(-8192, 14);  -- 14ビットの負の値
        wait for 10 ns;
        -- ここで他の処理を追加できます
    end process;
end Behavioral;

このコードでは、8ビット、16ビット、32ビット、そして奇数ビット幅（14ビット）のsigned型変数を宣言しています。

各変数に対して、そのビット幅で表現可能な値を設定しています。

実行結果は次のようになります。

# シミュレーション結果
Time: 10 ns
small_signed = "01111111" (127)
medium_signed = "1000000000000000" (-32768)
large_signed = "01111111111111111111111111111111" (2147483647)
odd_width_signed = "11100000000000" (-8192)

異なるビット幅のsigned型を適切に使用することで、必要最小限のリソースで効率的な回路設計が可能となります。

○サンプルコード3：パッケージを使用したsigned型の宣言

大規模な設計では、複数のエンティティやアーキテクチャで共通のデータ型を使用することがあります。

そのような場合、パッケージを利用してsigned型を宣言すると便利です。

-- my_types.vhd
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

package my_types is
    subtype small_signed_t is signed(7 downto 0);
    subtype medium_signed_t is signed(15 downto 0);
    type signed_array_t is array (0 to 3) of small_signed_t;
end package my_types;

-- main_design.vhd
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
use work.my_types.ALL;

entity main_design is
end main_design;

architecture Behavioral of main_design is
    signal a : small_signed_t;
    signal b : medium_signed_t;
    signal c : signed_array_t;
begin
    process
    begin
        a <= to_signed(50, 8);
        b <= to_signed(-1000, 16);
        c(0) <= to_signed(10, 8);
        c(1) <= to_signed(-20, 8);
        c(2) <= to_signed(30, 8);
        c(3) <= to_signed(-40, 8);
        wait for 10 ns;
        -- ここで他の処理を追加できます
    end process;
end Behavioral;

このコードでは、my_typesパッケージで共通のsigned型とsigned型の配列を定義しています。

メインの設計ファイルでこのパッケージを使用することで、一貫性のある型宣言が可能となります。

実行結果は次のようになります。

# シミュレーション結果
Time: 10 ns
a = "00110010" (50)
b = "1111110000011000" (-1000)
c(0) = "00001010" (10)
c(1) = "11101100" (-20)
c(2) = "00011110" (30)
c(3) = "11011000" (-40)

パッケージを使用することで、コードの再利用性が高まり、大規模プロジェクトでの管理が容易になります。

○サンプルコード4：ジェネリックを用いた可変長signed型

設計の柔軟性を高めるため、ジェネリックを使用して可変長のsigned型を宣言する方法があります。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity variable_width_signed is
    generic (
        WIDTH : integer := 16
    );
    port (
        input : in signed(WIDTH-1 downto 0);
        output : out signed(WIDTH-1 downto 0)
    );
end variable_width_signed;

architecture Behavioral of variable_width_signed is
begin
    process(input)
    begin
        -- 入力値を2倍にする簡単な処理
        output <= shift_left(input, 1);
    end process;
end Behavioral;

-- テストベンチ
entity tb_variable_width_signed is
end tb_variable_width_signed;

architecture Behavioral of tb_variable_width_signed is
    constant WIDTH : integer := 8;
    signal input, output : signed(WIDTH-1 downto 0);

    component variable_width_signed is
        generic (
            WIDTH : integer := 16
        );
        port (
            input : in signed(WIDTH-1 downto 0);
            output : out signed(WIDTH-1 downto 0)
        );
    end component;

begin
    uut: variable_width_signed
        generic map (WIDTH => WIDTH)
        port map (input => input, output => output);

    process
    begin
        input <= to_signed(25, WIDTH);
        wait for 10 ns;
        input <= to_signed(-30, WIDTH);
        wait for 10 ns;
        -- シミュレーション終了
        wait;
    end process;
end Behavioral;

このコードでは、ジェネリックパラメータWIDTHを使用して、可変長のsigned型を宣言しています。

テストベンチでは、8ビット幅で実装例を表しています。

実行結果は次のようになります。

# シミュレーション結果
Time: 0 ns
input = "00011001" (25)
output = "00110010" (50)

Time: 10 ns
input = "11100010" (-30)
output = "11000100" (-60)

ジェネリックを使用することで、同じエンティティを異なるビット幅で再利用できます。

高度な設計では、このような柔軟性は非常に重要となります。

●signed型の演算をマスターしておこう

VHDLでsigned型を使いこなすには、演算操作の理解が不可欠です。

回路設計において、加減算や乗除算は基本中の基本。

signed型を用いた演算回路の設計方法を習得すれば、複雑な数値処理も思いのままです。

さあ、一緒に演算の世界に飛び込んでみましょう。

○サンプルコード5：signed型の加減算回路

加減算は、デジタル回路設計の要となる操作です。

signed型を使えば、正負の数を含む計算も簡単に実装できます。

早速、コードを見てみましょう。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity adder_subtractor is
    generic (
        WIDTH : integer := 8
    );
    port (
        a, b : in signed(WIDTH-1 downto 0);
        add_sub : in std_logic;  -- '0'なら加算、'1'なら減算
        result : out signed(WIDTH-1 downto 0)
    );
end adder_subtractor;

architecture Behavioral of adder_subtractor is
begin
    process(a, b, add_sub)
    begin
        if add_sub = '0' then
            result <= a + b;
        else
            result <= a - b;
        end if;
    end process;
end Behavioral;

加算と減算をひとつの回路で行う、汎用性の高い設計です。

add_sub信号で加算か減算かを切り替えられます。WIDTH変数でビット幅を指定できるので、様々な精度の計算に対応可能です。

実行結果を確認してみましょう。

-- テストベンチ
entity tb_adder_subtractor is
end tb_adder_subtractor;

architecture Behavioral of tb_adder_subtractor is
    constant WIDTH : integer := 8;
    signal a, b, result : signed(WIDTH-1 downto 0);
    signal add_sub : std_logic;

    component adder_subtractor is
        generic (
            WIDTH : integer := 8
        );
        port (
            a, b : in signed(WIDTH-1 downto 0);
            add_sub : in std_logic;
            result : out signed(WIDTH-1 downto 0)
        );
    end component;

begin
    uut: adder_subtractor
        generic map (WIDTH => WIDTH)
        port map (a => a, b => b, add_sub => add_sub, result => result);

    process
    begin
        a <= to_signed(50, WIDTH);
        b <= to_signed(30, WIDTH);
        add_sub <= '0';  -- 加算
        wait for 10 ns;
        add_sub <= '1';  -- 減算
        wait for 10 ns;
        a <= to_signed(-40, WIDTH);
        b <= to_signed(25, WIDTH);
        add_sub <= '0';  -- 加算
        wait for 10 ns;
        add_sub <= '1';  -- 減算
        wait for 10 ns;
        wait;
    end process;
end Behavioral;

シミュレーション結果は次のようになります。

# シミュレーション結果
Time: 0 ns
a = "00110010" (50)
b = "00011110" (30)
add_sub = '0'
result = "01010000" (80)

Time: 10 ns
a = "00110010" (50)
b = "00011110" (30)
add_sub = '1'
result = "00010100" (20)

Time: 20 ns
a = "11011000" (-40)
b = "00011001" (25)
add_sub = '0'
result = "11110001" (-15)

Time: 30 ns
a = "11011000" (-40)
b = "00011001" (25)
add_sub = '1'
result = "11000111" (-65)

加減算が正しく行われていることが分かります。signed型を使うことで、負の数も自然に扱えています。

○サンプルコード6：signed型の乗算器の実装

乗算は加減算よりも複雑ですが、VHDLのsigned型を使えば、意外と簡単に実装できます。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity multiplier is
    generic (
        WIDTH : integer := 8
    );
    port (
        a, b : in signed(WIDTH-1 downto 0);
        result : out signed(2*WIDTH-1 downto 0)
    );
end multiplier;

architecture Behavioral of multiplier is
begin
    process(a, b)
    begin
        result <= a * b;
    end process;
end Behavioral;

乗算の結果は入力のビット幅の2倍になるため、resultのビット幅を2*WIDTHとしています。

VHDLのsigned型は、乗算演算子*を直接使用できるので、非常にシンプルな実装になっています。

実行結果を見てみましょう。

-- テストベンチ
entity tb_multiplier is
end tb_multiplier;

architecture Behavioral of tb_multiplier is
    constant WIDTH : integer := 8;
    signal a, b : signed(WIDTH-1 downto 0);
    signal result : signed(2*WIDTH-1 downto 0);

    component multiplier is
        generic (
            WIDTH : integer := 8
        );
        port (
            a, b : in signed(WIDTH-1 downto 0);
            result : out signed(2*WIDTH-1 downto 0)
        );
    end component;

begin
    uut: multiplier
        generic map (WIDTH => WIDTH)
        port map (a => a, b => b, result => result);

    process
    begin
        a <= to_signed(10, WIDTH);
        b <= to_signed(5, WIDTH);
        wait for 10 ns;
        a <= to_signed(-8, WIDTH);
        b <= to_signed(7, WIDTH);
        wait for 10 ns;
        a <= to_signed(-12, WIDTH);
        b <= to_signed(-5, WIDTH);
        wait for 10 ns;
        wait;
    end process;
end Behavioral;

シミュレーション結果は次のとおりです。

# シミュレーション結果
Time: 0 ns
a = "00001010" (10)
b = "00000101" (5)
result = "0000000000110010" (50)

Time: 10 ns
a = "11111000" (-8)
b = "00000111" (7)
result = "1111111111001000" (-56)

Time: 20 ns
a = "11110100" (-12)
b = "11111011" (-5)
result = "0000000000111100" (60)

正の数同士、負の数と正の数、負の数同士の乗算が正しく行われていることが確認できます。

○サンプルコード7：オーバーフロー検出機能付き演算回路

実際の回路設計では、演算結果がビット幅を超えてしまう「オーバーフロー」に注意が必要です。

オーバーフロー検出機能を備えた加算器を実装してみましょう。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity overflow_adder is
    generic (
        WIDTH : integer := 8
    );
    port (
        a, b : in signed(WIDTH-1 downto 0);
        sum : out signed(WIDTH-1 downto 0);
        overflow : out std_logic
    );
end overflow_adder;

architecture Behavioral of overflow_adder is
    signal temp_sum : signed(WIDTH downto 0);
begin
    process(a, b)
    begin
        temp_sum <= resize(a, WIDTH+1) + resize(b, WIDTH+1);
        sum <= temp_sum(WIDTH-1 downto 0);

        if (a(WIDTH-1) = b(WIDTH-1)) and (a(WIDTH-1) /= temp_sum(WIDTH-1)) then
            overflow <= '1';
        else
            overflow <= '0';
        end if;
    end process;
end Behavioral;

こちらの回路では、一時的に1ビット大きなtemp_sumを使用して加算を行い、最上位ビットの変化からオーバーフローを検出しています。

実行結果を確認しましょう。

-- テストベンチ
entity tb_overflow_adder is
end tb_overflow_adder;

architecture Behavioral of tb_overflow_adder is
    constant WIDTH : integer := 8;
    signal a, b, sum : signed(WIDTH-1 downto 0);
    signal overflow : std_logic;

    component overflow_adder is
        generic (
            WIDTH : integer := 8
        );
        port (
            a, b : in signed(WIDTH-1 downto 0);
            sum : out signed(WIDTH-1 downto 0);
            overflow : out std_logic
        );
    end component;

begin
    uut: overflow_adder
        generic map (WIDTH => WIDTH)
        port map (a => a, b => b, sum => sum, overflow => overflow);

    process
    begin
        a <= to_signed(100, WIDTH);
        b <= to_signed(50, WIDTH);
        wait for 10 ns;
        a <= to_signed(100, WIDTH);
        b <= to_signed(100, WIDTH);
        wait for 10 ns;
        a <= to_signed(-100, WIDTH);
        b <= to_signed(-50, WIDTH);
        wait for 10 ns;
        wait;
    end process;
end Behavioral;

シミュレーション結果は次のようになります。

# シミュレーション結果
Time: 0 ns
a = "01100100" (100)
b = "00110010" (50)
sum = "10010110" (-106)
overflow = '1'

Time: 10 ns
a = "01100100" (100)
b = "01100100" (100)
sum = "11001000" (-56)
overflow = '1'

Time: 20 ns
a = "10011100" (-100)
b = "11001110" (-50)
sum = "01101010" (106)
overflow = '1'

全てのケースでオーバーフローが検出されています。

8ビットsigned型の範囲（-128から127）を超える結果となるためです。

○サンプルコード8：signed型を使用した除算器の設計

除算操作は乗算よりも複雑で、ハードウェアリソースを多く消費します。

しかし、VHDLのsigned型を活用すれば、比較的シンプルに実装できます。

ゼロ除算の検出や符号の処理に注意を払いながら、除算器を設計してみましょう。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity divider is
    generic (
        WIDTH : integer := 8
    );
    port (
        dividend, divisor : in signed(WIDTH-1 downto 0);
        quotient : out signed(WIDTH-1 downto 0);
        remainder : out signed(WIDTH-1 downto 0);
        div_by_zero : out std_logic
    );
end divider;

architecture Behavioral of divider is
begin
    process(dividend, divisor)
        variable temp_quotient : signed(WIDTH-1 downto 0);
        variable temp_remainder : signed(WIDTH-1 downto 0);
    begin
        if divisor = 0 then
            quotient <= (others => '1');  -- 全ビット1（未定義値）
            remainder <= (others => '1');  -- 全ビット1（未定義値）
            div_by_zero <= '1';
        else
            temp_quotient := abs(dividend) / abs(divisor);
            temp_remainder := abs(dividend) rem abs(divisor);

            if (dividend < 0 and divisor > 0) or (dividend > 0 and divisor < 0) then
                quotient <= -temp_quotient;
            else
                quotient <= temp_quotient;
            end if;

            if dividend < 0 then
                remainder <= -temp_remainder;
            else
                remainder <= temp_remainder;
            end if;

            div_by_zero <= '0';
        end if;
    end process;
end Behavioral;

上記の除算器では、まず絶対値を用いて計算を行い、その後で符号を調整しています。

余りの符号は被除数の符号に合わせる必要があるため、別途処理しています。

また、ゼロ除算の場合は特別な処理を行い、エラーフラグを立てています。

実行結果を確認するために、テストベンチを用意しました。

-- テストベンチ
entity tb_divider is
end tb_divider;

architecture Behavioral of tb_divider is
    constant WIDTH : integer := 8;
    signal dividend, divisor, quotient, remainder : signed(WIDTH-1 downto 0);
    signal div_by_zero : std_logic;

    component divider is
        generic (
            WIDTH : integer := 8
        );
        port (
            dividend, divisor : in signed(WIDTH-1 downto 0);
            quotient : out signed(WIDTH-1 downto 0);
            remainder : out signed(WIDTH-1 downto 0);
            div_by_zero : out std_logic
        );
    end component;

begin
    uut: divider
        generic map (WIDTH => WIDTH)
        port map (dividend => dividend, divisor => divisor, 
                  quotient => quotient, remainder => remainder, 
                  div_by_zero => div_by_zero);

    process
    begin
        dividend <= to_signed(50, WIDTH);
        divisor <= to_signed(10, WIDTH);
        wait for 10 ns;
        dividend <= to_signed(-45, WIDTH);
        divisor <= to_signed(7, WIDTH);
        wait for 10 ns;
        dividend <= to_signed(100, WIDTH);
        divisor <= to_signed(0, WIDTH);  -- ゼロ除算
        wait for 10 ns;
        wait;
    end process;
end Behavioral;

シミュレーション結果は次のようになります。

# シミュレーション結果
Time: 0 ns
dividend = "00110010" (50)
divisor = "00001010" (10)
quotient = "00000101" (5)
remainder = "00000000" (0)
div_by_zero = '0'

Time: 10 ns
dividend = "11010011" (-45)
divisor = "00000111" (7)
quotient = "11111001" (-7)
remainder = "11111100" (-4)
div_by_zero = '0'

Time: 20 ns
dividend = "01100100" (100)
divisor = "00000000" (0)
quotient = "11111111" (未定義)
remainder = "11111111" (未定義)
div_by_zero = '1'

シミュレーション結果から、正の数同士の除算、負の数を含む除算、そしてゼロ除算の場合の動作が確認できます。

特に、負の数を含む場合の商と余りの符号が正しく処理されていることに注目してください。

signed型を使用した除算器の設計は、複雑な演算を要するため、実装には十分な注意が必要です。

特に、タイミング制約や面積制約が厳しい場合は、パイプライン化や並列処理などの最適化技術を適用することも考慮に入れましょう。

●型変換のテクニック

VHDLでsigned型を扱う際、他のデータ型との相互変換は避けて通れません。

効率的な回路設計のためには、型変換のテクニックをマスターすることが重要です。

ここでは、よく使用される型変換の方法を紹介します。

○サンプルコード9：signed型とstd_logic_vectorの相互変換

signed型とstd_logic_vectorは、VHDLで頻繁に使用されるデータ型です。

両者の相互変換を適切に行うことで、様々なモジュールを柔軟に接続できます。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity type_conversion is
    generic (
        WIDTH : integer := 8
    );
    port (
        signed_in : in signed(WIDTH-1 downto 0);
        vector_in : in std_logic_vector(WIDTH-1 downto 0);
        signed_out : out signed(WIDTH-1 downto 0);
        vector_out : out std_logic_vector(WIDTH-1 downto 0)
    );
end type_conversion;

architecture Behavioral of type_conversion is
begin
    process(signed_in, vector_in)
    begin
        -- std_logic_vector から signed への変換
        signed_out <= signed(vector_in);

        -- signed から std_logic_vector への変換
        vector_out <= std_logic_vector(signed_in);
    end process;
end Behavioral;

上記のコードでは、signed型とstd_logic_vectorの相互変換を行っています。

VHDLでは、型の明示的な変換が必要ですが、signed()関数とstd_logic_vector()関数を使用することで、簡単に変換できます。

実行結果を確認しましょう。

-- テストベンチ
entity tb_type_conversion is
end tb_type_conversion;

architecture Behavioral of tb_type_conversion is
    constant WIDTH : integer := 8;
    signal signed_in, signed_out : signed(WIDTH-1 downto 0);
    signal vector_in, vector_out : std_logic_vector(WIDTH-1 downto 0);

    component type_conversion is
        generic (
            WIDTH : integer := 8
        );
        port (
            signed_in : in signed(WIDTH-1 downto 0);
            vector_in : in std_logic_vector(WIDTH-1 downto 0);
            signed_out : out signed(WIDTH-1 downto 0);
            vector_out : out std_logic_vector(WIDTH-1 downto 0)
        );
    end component;

begin
    uut: type_conversion
        generic map (WIDTH => WIDTH)
        port map (signed_in => signed_in, vector_in => vector_in,
                  signed_out => signed_out, vector_out => vector_out);

    process
    begin
        signed_in <= to_signed(42, WIDTH);
        vector_in <= std_logic_vector(to_signed(-23, WIDTH));
        wait for 10 ns;
        signed_in <= to_signed(-78, WIDTH);
        vector_in <= std_logic_vector(to_signed(100, WIDTH));
        wait for 10 ns;
        wait;
    end process;
end Behavioral;

シミュレーション結果は次のようになります。

# シミュレーション結果
Time: 0 ns
signed_in = "00101010" (42)
vector_in = "11101001" (-23)
signed_out = "11101001" (-23)
vector_out = "00101010" (42)

Time: 10 ns
signed_in = "10110010" (-78)
vector_in = "01100100" (100)
signed_out = "01100100" (100)
vector_out = "10110010" (-78)

結果から、signed型とstd_logic_vectorの相互変換が正しく行われていることが確認できます。

ビットパターンは保持されたまま、解釈の仕方が変わっています。

○サンプルコード10：signed型とinteger型の変換方法

signed型とinteger型の相互変換も、VHDLプログラミングでよく使用されます。

特に、テストベンチの作成時や、人間が理解しやすい形式でデータを扱う際に重要です。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity integer_conversion is
    generic (
        WIDTH : integer := 8
    );
    port (
        signed_in : in signed(WIDTH-1 downto 0);
        integer_in : in integer;
        signed_out : out signed(WIDTH-1 downto 0);
        integer_out : out integer
    );
end integer_conversion;

architecture Behavioral of integer_conversion is
begin
    process(signed_in, integer_in)
    begin
        -- integer から signed への変換
        signed_out <= to_signed(integer_in, WIDTH);

        -- signed から integer への変換
        integer_out <= to_integer(signed_in);
    end process;
end Behavioral;

このコードでは、to_signed()関数を使用してintegerからsigned型への変換を、to_integer()関数を使用してsigned型からintegerへの変換を行っています。

実行結果を見てみましょう。

-- テストベンチ
entity tb_integer_conversion is
end tb_integer_conversion;

architecture Behavioral of tb_integer_conversion is
    constant WIDTH : integer := 8;
    signal signed_in, signed_out : signed(WIDTH-1 downto 0);
    signal integer_in, integer_out : integer;

    component integer_conversion is
        generic (
            WIDTH : integer := 8
        );
        port (
            signed_in : in signed(WIDTH-1 downto 0);
            integer_in : in integer;
            signed_out : out signed(WIDTH-1 downto 0);
            integer_out : out integer
        );
    end component;

begin
    uut: integer_conversion
        generic map (WIDTH => WIDTH)
        port map (signed_in => signed_in, integer_in => integer_in,
                  signed_out => signed_out, integer_out => integer_out);

    process
    begin
        signed_in <= to_signed(42, WIDTH);
        integer_in <= -23;
        wait for 10 ns;
        signed_in <= to_signed(-78, WIDTH);
        integer_in <= 100;
        wait for 10 ns;
        wait;
    end process;
end Behavioral;

シミュレーション結果は次のようになります。

# シミュレーション結果
Time: 0 ns
signed_in = "00101010" (42)
integer_in = -23
signed_out = "11101001" (-23)
integer_out = 42

Time: 10 ns
signed_in = "10110010" (-78)
integer_in = 100
signed_out = "01100100" (100)
integer_out = -78

結果から、signed型とinteger型の相互変換が正しく行われていることが確認できます。

ただし、8ビットsigned型の範囲（-128から127）を超える値を扱う場合は注意が必要です。

○サンプルコード11：異なるビット幅間での型変換と拡張

実際の回路設計では、異なるビット幅のsigned型同士の変換が頻繁に必要となります。

ビット幅の拡張や縮小を適切に行うことで、精度を保ちつつ効率的な回路を設計できます。

ここでは、8ビットと16ビットのsigned型間の変換を例に挙げて説明します。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity width_conversion is
    port (
        narrow_in : in signed(7 downto 0);
        wide_in : in signed(15 downto 0);
        narrow_to_wide : out signed(15 downto 0);
        wide_to_narrow : out signed(7 downto 0)
    );
end width_conversion;

architecture Behavioral of width_conversion is
begin
    process(narrow_in, wide_in)
    begin
        -- 8ビットから16ビットへの拡張（符号拡張）
        narrow_to_wide <= resize(narrow_in, 16);

        -- 16ビットから8ビットへの縮小（切り捨て）
        wide_to_narrow <= resize(wide_in, 8);
    end process;
end Behavioral;

このコードでは、resize()関数を使用して異なるビット幅間の変換を行っています。

8ビットから16ビットへの拡張では符号ビットが適切に拡張され、16ビットから8ビットへの縮小では上位ビットが切り捨てられます。

実行結果を確認するために、テストベンチを用意しました。

-- テストベンチ
entity tb_width_conversion is
end tb_width_conversion;

architecture Behavioral of tb_width_conversion is
    signal narrow_in : signed(7 downto 0);
    signal wide_in : signed(15 downto 0);
    signal narrow_to_wide : signed(15 downto 0);
    signal wide_to_narrow : signed(7 downto 0);

    component width_conversion is
        port (
            narrow_in : in signed(7 downto 0);
            wide_in : in signed(15 downto 0);
            narrow_to_wide : out signed(15 downto 0);
            wide_to_narrow : out signed(7 downto 0)
        );
    end component;

begin
    uut: width_conversion
        port map (narrow_in => narrow_in, wide_in => wide_in,
                  narrow_to_wide => narrow_to_wide, wide_to_narrow => wide_to_narrow);

    process
    begin
        narrow_in <= to_signed(127, 8);  -- 8ビットの最大正数
        wide_in <= to_signed(300, 16);   -- 8ビットで表現できない正数
        wait for 10 ns;
        narrow_in <= to_signed(-128, 8);  -- 8ビットの最小負数
        wide_in <= to_signed(-300, 16);   -- 8ビットで表現できない負数
        wait for 10 ns;
        wait;
    end process;
end Behavioral;

シミュレーション結果は次のようになります。

# シミュレーション結果
Time: 0 ns
narrow_in = "01111111" (127)
wide_in = "0000000100101100" (300)
narrow_to_wide = "0000000001111111" (127)
wide_to_narrow = "00101100" (44)

Time: 10 ns
narrow_in = "10000000" (-128)
wide_in = "1111111011010100" (-300)
narrow_to_wide = "1111111110000000" (-128)
wide_to_narrow = "11010100" (-44)

シミュレーション結果から、次のことが分かります。

8ビットから16ビットへの拡張（narrow_to_wide）

正数の場合（127）: 上位ビットが0で埋められます。
負数の場合（-128）: 上位ビットが1で埋められ、符号が保持されます。

16ビットから8ビットへの縮小（wide_to_narrow）

正数の場合（300 → 44）: 上位ビットが切り捨てられ、値が変わります。
負数の場合（-300 → -44）: 上位ビットが切り捨てられ、値が変わりますが、符号は保持されます。

ビット幅の拡張では問題ありませんが、縮小の際には情報の損失が発生する可能性があります。

そのため、縮小を行う際は、元の値の範囲が縮小後のビット幅で表現可能かどうかを十分に確認する必要があります。

また、特定の用途では、切り捨てではなく四捨五入や切り上げが必要な場合もあります。

そのような場合は、resize()関数を使用する前に適切な処理を加えることで対応できます。

●VHDLにおける組み合わせ回路設計

VHDLを使用した組み合わせ回路設計は、デジタル回路設計の基礎となる重要なスキルです。

signed型を活用することで、より複雑で高度な機能を持つ回路を効率的に設計することが可能となります。

ここでは、実践的な例を通じて、signed型を用いた組み合わせ回路設計の手法を学んでいきましょう。

○サンプルコード12：signed型を用いた高機能ALU

算術論理演算ユニット（ALU）は、プロセッサの中核を成す重要な部品です。

signed型を使用することで、符号付き演算を含む多機能なALUを設計することができます。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity alu is
    generic (
        WIDTH : integer := 8
    );
    port (
        a, b : in signed(WIDTH-1 downto 0);
        op : in std_logic_vector(2 downto 0);
        result : out signed(WIDTH-1 downto 0);
        overflow : out std_logic
    );
end alu;

architecture Behavioral of alu is
    signal temp_result : signed(WIDTH downto 0);
begin
    process(a, b, op)
    begin
        case op is
            when "000" => -- 加算
                temp_result <= resize(a, WIDTH+1) + resize(b, WIDTH+1);
            when "001" => -- 減算
                temp_result <= resize(a, WIDTH+1) - resize(b, WIDTH+1);
            when "010" => -- 乗算（下位ビットのみ）
                temp_result <= resize(a * b, WIDTH+1);
            when "011" => -- 論理AND
                temp_result <= resize(a and b, WIDTH+1);
            when "100" => -- 論理OR
                temp_result <= resize(a or b, WIDTH+1);
            when "101" => -- 論理XOR
                temp_result <= resize(a xor b, WIDTH+1);
            when "110" => -- 左シフト
                temp_result <= resize(shift_left(a, to_integer(b)), WIDTH+1);
            when others => -- 右シフト
                temp_result <= resize(shift_right(a, to_integer(b)), WIDTH+1);
        end case;

        result <= temp_result(WIDTH-1 downto 0);
        overflow <= '1' when (temp_result(WIDTH) /= temp_result(WIDTH-1)) else '0';
    end process;
end Behavioral;

このALUは、加算、減算、乗算（下位ビットのみ）、論理演算（AND、OR、XOR）、シフト操作を実行できます。

temp_resultを1ビット大きくすることで、オーバーフロー検出も可能になっています。

実行結果を確認するためのテストベンチを用意しました。

-- テストベンチ
entity tb_alu is
end tb_alu;

architecture Behavioral of tb_alu is
    constant WIDTH : integer := 8;
    signal a, b, result : signed(WIDTH-1 downto 0);
    signal op : std_logic_vector(2 downto 0);
    signal overflow : std_logic;

    component alu is
        generic (
            WIDTH : integer := 8
        );
        port (
            a, b : in signed(WIDTH-1 downto 0);
            op : in std_logic_vector(2 downto 0);
            result : out signed(WIDTH-1 downto 0);
            overflow : out std_logic
        );
    end component;

begin
    uut: alu
        generic map (WIDTH => WIDTH)
        port map (a => a, b => b, op => op, result => result, overflow => overflow);

    process
    begin
        a <= to_signed(50, WIDTH);
        b <= to_signed(30, WIDTH);
        op <= "000";  -- 加算
        wait for 10 ns;
        op <= "001";  -- 減算
        wait for 10 ns;
        op <= "010";  -- 乗算
        wait for 10 ns;
        a <= to_signed(-40, WIDTH);
        b <= to_signed(3, WIDTH);
        op <= "110";  -- 左シフト
        wait for 10 ns;
        wait;
    end process;
end Behavioral;

シミュレーション結果は次のようになります。

# シミュレーション結果
Time: 0 ns
a = "00110010" (50)
b = "00011110" (30)
op = "000"
result = "01010000" (80)
overflow = '0'

Time: 10 ns
a = "00110010" (50)
b = "00011110" (30)
op = "001"
result = "00010100" (20)
overflow = '0'

Time: 20 ns
a = "00110010" (50)
b = "00011110" (30)
op = "010"
result = "11101100" (-20)
overflow = '1'

Time: 30 ns
a = "11011000" (-40)
b = "00000011" (3)
op = "110"
result = "10000000" (-128)
overflow = '1'

結果から、ALUが正しく動作していることが確認できます。

乗算では下位8ビットのみを取り出しているため、結果が-20となっています。

また、左シフトでオーバーフローが発生しています。

○サンプルコード13：signed型によるFIRフィルタの実装

デジタル信号処理において、FIR（Finite Impulse Response）フィルタは非常に重要な要素です。

signed型を使用することで、効率的なFIRフィルタを実装することができます。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity fir_filter is
    generic (
        DATA_WIDTH : integer := 16;
        COEFF_WIDTH : integer := 16;
        TAP_NUM : integer := 4
    );
    port (
        clk : in std_logic;
        rst : in std_logic;
        x : in signed(DATA_WIDTH-1 downto 0);
        y : out signed(DATA_WIDTH+COEFF_WIDTH-1 downto 0)
    );
end fir_filter;

architecture Behavioral of fir_filter is
    type coeff_array is array (0 to TAP_NUM-1) of signed(COEFF_WIDTH-1 downto 0);
    constant coeff : coeff_array := (
        to_signed(16384, COEFF_WIDTH),  -- 0.5 in Q15 format
        to_signed(8192, COEFF_WIDTH),   -- 0.25 in Q15 format
        to_signed(4096, COEFF_WIDTH),   -- 0.125 in Q15 format
        to_signed(2048, COEFF_WIDTH)    -- 0.0625 in Q15 format
    );

    type shift_reg_type is array (0 to TAP_NUM-1) of signed(DATA_WIDTH-1 downto 0);
    signal shift_reg : shift_reg_type;

    type mult_type is array (0 to TAP_NUM-1) of signed(DATA_WIDTH+COEFF_WIDTH-1 downto 0);
    signal mult : mult_type;

    signal sum : signed(DATA_WIDTH+COEFF_WIDTH-1 downto 0);
begin
    process(clk, rst)
    begin
        if rst = '1' then
            shift_reg <= (others => (others => '0'));
            sum <= (others => '0');
        elsif rising_edge(clk) then
            -- シフトレジスタの更新
            shift_reg <= x & shift_reg(0 to TAP_NUM-2);

            -- 積和演算
            sum <= (others => '0');
            for i in 0 to TAP_NUM-1 loop
                mult(i) <= shift_reg(i) * coeff(i);
                sum <= sum + mult(i);
            end loop;

            y <= sum;
        end if;
    end process;
end Behavioral;

このFIRフィルタは、4タップの構成で、入力信号に対して簡単な低域通過フィルタとして機能します。

係数は固定小数点形式（Q15）で表現されています。

テストベンチを用意して、フィルタの動作を確認しましょう。

-- テストベンチ
entity tb_fir_filter is
end tb_fir_filter;

architecture Behavioral of tb_fir_filter is
    constant DATA_WIDTH : integer := 16;
    constant COEFF_WIDTH : integer := 16;
    constant TAP_NUM : integer := 4;

    signal clk : std_logic := '0';
    signal rst : std_logic := '1';
    signal x : signed(DATA_WIDTH-1 downto 0) := (others => '0');
    signal y : signed(DATA_WIDTH+COEFF_WIDTH-1 downto 0);

    component fir_filter is
        generic (
            DATA_WIDTH : integer := 16;
            COEFF_WIDTH : integer := 16;
            TAP_NUM : integer := 4
        );
        port (
            clk : in std_logic;
            rst : in std_logic;
            x : in signed(DATA_WIDTH-1 downto 0);
            y : out signed(DATA_WIDTH+COEFF_WIDTH-1 downto 0)
        );
    end component;

begin
    uut: fir_filter
        generic map (DATA_WIDTH => DATA_WIDTH, COEFF_WIDTH => COEFF_WIDTH, TAP_NUM => TAP_NUM)
        port map (clk => clk, rst => rst, x => x, y => y);

    -- クロック生成
    clk <= not clk after 5 ns;

    process
    begin
        wait for 10 ns;
        rst <= '0';
        wait for 10 ns;

        -- インパルス応答のテスト
        x <= to_signed(32767, DATA_WIDTH);  -- 最大正数
        wait for 10 ns;
        x <= to_signed(0, DATA_WIDTH);
        wait for 70 ns;

        -- ステップ応答のテスト
        x <= to_signed(16384, DATA_WIDTH);  -- 0.5 in Q15
        wait for 100 ns;

        wait;
    end process;
end Behavioral;

シミュレーション結果は次のようになります。

# シミュレーション結果（一部抜粋）
Time: 30 ns (インパルス入力後)
x = "0111111111111111" (32767)
y = "0000000000000000000000000000000" (0)

Time: 40 ns
x = "0000000000000000" (0)
y = "0100000000000000000000000000000" (536870912)

Time: 50 ns
x = "0000000000000000" (0)
y = "0010000000000000000000000000000" (268435456)

Time: 60 ns
x = "0000000000000000" (0)
y = "0001000000000000000000000000000" (134217728)

Time: 70 ns
x = "0000000000000000" (0)
y = "0000100000000000000000000000000" (67108864)

Time: 180 ns (ステップ入力後の定常状態)
x = "0100000000000000" (16384)
y = "0100000000000000000000000000000" (536870912)

結果から、FIRフィルタがインパルス応答とステップ応答を正しく生成していることが確認できます。

インパルス応答は係数の値を直接反映しており、ステップ応答は全ての係数の和（この場合は0.9375）に収束しています。

○サンプルコード14：signed型を使用した複素数乗算器

デジタル信号処理の分野では、複素数演算が欠かせません。

signed型を駆使すれば、効率的で精度の高い複素数乗算器を実装できます。

ここでは、VHDLを使って複素数乗算器を設計する方法を詳しく解説します。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity complex_multiplier is
    generic (
        WIDTH : integer := 16
    );
    port (
        a_real, a_imag : in signed(WIDTH-1 downto 0);
        b_real, b_imag : in signed(WIDTH-1 downto 0);
        p_real, p_imag : out signed(2*WIDTH-1 downto 0)
    );
end complex_multiplier;

architecture Behavioral of complex_multiplier is
    signal ac, bd, ad, bc : signed(2*WIDTH-1 downto 0);
begin
    process(a_real, a_imag, b_real, b_imag)
    begin
        ac <= a_real * b_real;
        bd <= a_imag * b_imag;
        ad <= a_real * b_imag;
        bc <= a_imag * b_real;

        p_real <= ac - bd;
        p_imag <= ad + bc;
    end process;
end Behavioral;

この複素数乗算器は、(a + bi) * (c + di) = (ac – bd) + (ad + bc)i という数学的公式を忠実に再現しています。

signed型を活用することで、負の数を含む複素数の乗算も簡単に実現できます。

各部分積（ac, bd, ad, bc）は2*WIDTH ビットの幅を持ち、高精度な演算を可能にしています。

複素数乗算器の動作を確認するために、次のテストベンチを用意しました。

-- テストベンチ
entity tb_complex_multiplier is
end tb_complex_multiplier;

architecture Behavioral of tb_complex_multiplier is
    constant WIDTH : integer := 16;
    signal a_real, a_imag, b_real, b_imag : signed(WIDTH-1 downto 0);
    signal p_real, p_imag : signed(2*WIDTH-1 downto 0);

    component complex_multiplier is
        generic (
            WIDTH : integer := 16
        );
        port (
            a_real, a_imag : in signed(WIDTH-1 downto 0);
            b_real, b_imag : in signed(WIDTH-1 downto 0);
            p_real, p_imag : out signed(2*WIDTH-1 downto 0)
        );
    end component;

begin
    uut: complex_multiplier
        generic map (WIDTH => WIDTH)
        port map (a_real => a_real, a_imag => a_imag, 
                  b_real => b_real, b_imag => b_imag, 
                  p_real => p_real, p_imag => p_imag);

    process
    begin
        -- テストケース1: (2 + 3i) * (4 + 5i)
        a_real <= to_signed(2, WIDTH);
        a_imag <= to_signed(3, WIDTH);
        b_real <= to_signed(4, WIDTH);
        b_imag <= to_signed(5, WIDTH);
        wait for 10 ns;

        -- テストケース2: (-1 + 2i) * (3 - 4i)
        a_real <= to_signed(-1, WIDTH);
        a_imag <= to_signed(2, WIDTH);
        b_real <= to_signed(3, WIDTH);
        b_imag <= to_signed(-4, WIDTH);
        wait for 10 ns;

        -- テストケース3: (0.5 + 0.5i) * (0.5 - 0.5i)
        -- 0.5を8192（2^13）で表現（Q15形式）
        a_real <= to_signed(8192, WIDTH);
        a_imag <= to_signed(8192, WIDTH);
        b_real <= to_signed(8192, WIDTH);
        b_imag <= to_signed(-8192, WIDTH);
        wait for 10 ns;

        wait;
    end process;
end Behavioral;

シミュレーション結果は次のようになります。

# シミュレーション結果
Time: 10 ns (テストケース1の結果)
a_real = "0000000000000010" (2)
a_imag = "0000000000000011" (3)
b_real = "0000000000000100" (4)
b_imag = "0000000000000101" (5)
p_real = "0000000000000000000000000000111" (-7)
p_imag = "0000000000000000000000000010110" (22)

Time: 20 ns (テストケース2の結果)
a_real = "1111111111111111" (-1)
a_imag = "0000000000000010" (2)
b_real = "0000000000000011" (3)
b_imag = "1111111111111100" (-4)
p_real = "0000000000000000000000000000101" (5)
p_imag = "0000000000000000000000000001010" (10)

Time: 30 ns (テストケース3の結果)
a_real = "0010000000000000" (8192)
a_imag = "0010000000000000" (8192)
b_real = "0010000000000000" (8192)
b_imag = "1110000000000000" (-8192)
p_real = "0100000000000000000000000000000" (67108864)
p_imag = "0000000000000000000000000000000" (0)

シミュレーション結果を解析してみましょう。

テストケース1 -> (2 + 3i) * (4 + 5i) = -7 + 22i
結果は期待通りです。
テストケース2 -> (-1 + 2i) * (3 – 4i) = 5 + 10i
負の数を含む複素数の乗算も正確に行われています。
テストケース3 -> (0.5 + 0.5i) * (0.5 – 0.5i) = 0.5 + 0i
固定小数点数（Q15形式）を使用しています。結果の実数部は67108864で、これは0.5に相当します（2^15 * 0.5 = 16384、16384 * 4096 = 67108864）。虚数部は0になっています。

この複素数乗算器は、signed型を活用することで、整数だけでなく固定小数点数の複素数乗算も高精度で実現しています。

DSPやFFTなどの高度な信号処理アルゴリズムの実装に応用できる、非常に有用なコンポーネントと言えるでしょう。

●よくあるエラーと対処法

VHDLでsigned型を使用する際、いくつかの一般的なエラーに遭遇することがあります。

ここでは、よく発生するエラーとその対処法について解説します。

○符号拡張に関するエラーとその解決策

符号拡張は、signed型を扱う上で重要な概念です。

しかし、不適切な処理によってエラーが発生することがあります。

よくあるエラーの例

signal a : signed(7 downto 0);
signal b : signed(15 downto 0);

b <= a;  -- エラー：ビット幅が異なる

この場合、aをbに直接代入しようとしていますが、ビット幅が異なるためエラーになります。

解決策

b <= resize(a, 16);  -- 正しい方法：resizeを使用して適切に拡張

resize関数を使用することで、符号を保持したまま適切にビット幅を拡張できます。

負の数の場合、最上位ビットが1に設定されます。

○オーバーフロー・アンダーフローの検出と対策

signed型で演算を行う際、結果がビット幅を超えてしまうオーバーフローや、表現可能な最小値を下回るアンダーフローが発生する可能性があります。

よくあるエラーの例

signal a, b, result : signed(7 downto 0);

result <= a + b;  -- オーバーフローの可能性あり

この場合、a + bの結果が8ビットを超える可能性があります。

解決策

signal a, b : signed(7 downto 0);
signal temp_result : signed(8 downto 0);
signal result : signed(7 downto 0);
signal overflow : std_logic;

temp_result <= resize(a, 9) + resize(b, 9);
result <= temp_result(7 downto 0);
overflow <= '1' when (temp_result(8) /= temp_result(7)) else '0';

一時的に1ビット大きなtemp_resultを使用することで、オーバーフローを検出できます。

最上位ビットと次のビットが異なる場合、オーバーフローが発生したと判断できます。

○型不一致エラーの原因と修正方法

VHDLは強い型付け言語であるため、異なる型同士の演算や代入を行おうとするとエラーが発生します。

よくあるエラーの例

signal a : signed(7 downto 0);
signal b : std_logic_vector(7 downto 0);

a <= b;  -- エラー：型が不一致

この場合、std_logic_vector型のbをsigned型のaに直接代入しようとしているためエラーになります。

解決策

a <= signed(b);  -- 正しい方法：明示的な型変換を行う

明示的な型変換を行うことで、エラーを回避できます。

ただし、std_logic_vectorからsignedへの変換では、元のビット列の解釈が変わる可能性があることに注意が必要です。

●signed型の高度な応用例

VHDLにおけるsigned型の基本を押さえたところで、より高度な応用例に挑戦してみましょう。

実際の業界では、複雑な信号処理や制御システムの設計にsigned型が活用されています。

ここでは、FFT回路、浮動小数点演算の近似、DSP機能、PID制御器といった実践的な例を通じて、signed型の真価を探ります。

○サンプルコード15：signed型を用いたFFT回路の設計

高速フーリエ変換（FFT）は、信号処理の要となる重要なアルゴリズムです。

VHDLでsigned型を使用してFFT回路を設計することで、効率的で高精度な周波数解析が可能になります。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
use IEEE.MATH_REAL.ALL;

entity fft_8point is
    generic (
        DATA_WIDTH : integer := 16
    );
    port (
        clk : in std_logic;
        rst : in std_logic;
        x_re, x_im : in signed(DATA_WIDTH-1 downto 0);
        y_re, y_im : out signed(DATA_WIDTH-1 downto 0)
    );
end fft_8point;

architecture Behavioral of fft_8point is
    type complex_array is array (0 to 7) of signed(DATA_WIDTH-1 downto 0);
    signal x_re_reg, x_im_reg : complex_array;
    signal y_re_reg, y_im_reg : complex_array;

    -- 回転因子（固定小数点Q15形式）
    constant W_RE : signed(DATA_WIDTH-1 downto 0) := to_signed(integer(32767.0 * cos(2.0 * MATH_PI / 8.0)), DATA_WIDTH);
    constant W_IM : signed(DATA_WIDTH-1 downto 0) := to_signed(integer(-32767.0 * sin(2.0 * MATH_PI / 8.0)), DATA_WIDTH);

    -- バタフライ演算
    procedure butterfly(signal a_re, a_im, b_re, b_im : in signed(DATA_WIDTH-1 downto 0);
                        signal y1_re, y1_im, y2_re, y2_im : out signed(DATA_WIDTH-1 downto 0)) is
        variable temp_re, temp_im : signed(2*DATA_WIDTH-1 downto 0);
    begin
        y1_re <= a_re + b_re;
        y1_im <= a_im + b_im;

        temp_re := (b_re * W_RE - b_im * W_IM) / 32768;
        temp_im := (b_re * W_IM + b_im * W_RE) / 32768;

        y2_re <= a_re - temp_re(DATA_WIDTH-1 downto 0);
        y2_im <= a_im - temp_im(DATA_WIDTH-1 downto 0);
    end procedure;

begin
    process(clk, rst)
    begin
        if rst = '1' then
            x_re_reg <= (others => (others => '0'));
            x_im_reg <= (others => (others => '0'));
        elsif rising_edge(clk) then
            -- 入力データのシフト
            for i in 7 downto 1 loop
                x_re_reg(i) <= x_re_reg(i-1);
                x_im_reg(i) <= x_im_reg(i-1);
            end loop;
            x_re_reg(0) <= x_re;
            x_im_reg(0) <= x_im;

            -- 第1段のバタフライ
            butterfly(x_re_reg(0), x_im_reg(0), x_re_reg(4), x_im_reg(4), y_re_reg(0), y_im_reg(0), y_re_reg(1), y_im_reg(1));
            butterfly(x_re_reg(2), x_im_reg(2), x_re_reg(6), x_im_reg(6), y_re_reg(2), y_im_reg(2), y_re_reg(3), y_im_reg(3));
            butterfly(x_re_reg(1), x_im_reg(1), x_re_reg(5), x_im_reg(5), y_re_reg(4), y_im_reg(4), y_re_reg(5), y_im_reg(5));
            butterfly(x_re_reg(3), x_im_reg(3), x_re_reg(7), x_im_reg(7), y_re_reg(6), y_im_reg(6), y_re_reg(7), y_im_reg(7));

            -- 第2段のバタフライ
            butterfly(y_re_reg(0), y_im_reg(0), y_re_reg(2), y_im_reg(2), y_re_reg(0), y_im_reg(0), y_re_reg(2), y_im_reg(2));
            butterfly(y_re_reg(1), y_im_reg(1), y_re_reg(3), y_im_reg(3), y_re_reg(1), y_im_reg(1), y_re_reg(3), y_im_reg(3));
            butterfly(y_re_reg(4), y_im_reg(4), y_re_reg(6), y_im_reg(6), y_re_reg(4), y_im_reg(4), y_re_reg(6), y_im_reg(6));
            butterfly(y_re_reg(5), y_im_reg(5), y_re_reg(7), y_im_reg(7), y_re_reg(5), y_im_reg(5), y_re_reg(7), y_im_reg(7));

            -- 第3段のバタフライ
            butterfly(y_re_reg(0), y_im_reg(0), y_re_reg(1), y_im_reg(1), y_re_reg(0), y_im_reg(0), y_re_reg(1), y_im_reg(1));
            butterfly(y_re_reg(2), y_im_reg(2), y_re_reg(3), y_im_reg(3), y_re_reg(2), y_im_reg(2), y_re_reg(3), y_im_reg(3));
            butterfly(y_re_reg(4), y_im_reg(4), y_re_reg(5), y_im_reg(5), y_re_reg(4), y_im_reg(4), y_re_reg(5), y_im_reg(5));
            butterfly(y_re_reg(6), y_im_reg(6), y_re_reg(7), y_im_reg(7), y_re_reg(6), y_im_reg(6), y_re_reg(7), y_im_reg(7));
        end if;
    end process;

    y_re <= y_re_reg(0);
    y_im <= y_im_reg(0);
end Behavioral;

この8点FFT回路は、signed型を使用して複素数演算を実現しています。

回転因子（タイドルファクター）は固定小数点Q15形式で表現され、高精度な演算を可能にしています。

バタフライ演算を3段階で実行することで、効率的なFFT計算を実現しています。

○サンプルコード16：signed型による浮動小数点演算の近似

FPGAでは浮動小数点演算が高コストになることがあります。

signed型を使用して固定小数点数で近似することで、効率的な演算が可能になります。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity fixed_point_math is
    generic (
        INTEGER_BITS : integer := 8;
        FRACTION_BITS : integer := 8
    );
    port (
        a, b : in signed(INTEGER_BITS + FRACTION_BITS - 1 downto 0);
        op : in std_logic_vector(1 downto 0);
        result : out signed(INTEGER_BITS + FRACTION_BITS - 1 downto 0)
    );
end fixed_point_math;

architecture Behavioral of fixed_point_math is
    constant TOTAL_BITS : integer := INTEGER_BITS + FRACTION_BITS;
    signal temp_result : signed(2*TOTAL_BITS-1 downto 0);
begin
    process(a, b, op)
    begin
        case op is
            when "00" => -- 加算
                result <= a + b;
            when "01" => -- 減算
                result <= a - b;
            when "10" => -- 乗算
                temp_result <= a * b;
                result <= temp_result(TOTAL_BITS + FRACTION_BITS - 1 downto FRACTION_BITS);
            when others => -- 除算（近似）
                temp_result <= (a & (TOTAL_BITS-1 downto 0 => '0')) / b;
                result <= temp_result(TOTAL_BITS-1 downto 0);
        end case;
    end process;
end Behavioral;

この回路は、固定小数点数を使用して四則演算を実現しています。

乗算と除算では、精度を保つために一時的に大きなビット幅を使用しています。

除算は近似計算となりますが、多くの応用で十分な精度を提供します。

○サンプルコード17：signed型を活用したDSP機能の実装

デジタル信号処理（DSP）の基本機能の一つに、FIRフィルタがあります。

signed型を使用して効率的なFIRフィルタを実装できます。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity fir_filter is
    generic (
        DATA_WIDTH : integer := 16;
        COEFF_WIDTH : integer := 16;
        TAP_NUM : integer := 8
    );
    port (
        clk : in std_logic;
        rst : in std_logic;
        x : in signed(DATA_WIDTH-1 downto 0);
        y : out signed(DATA_WIDTH+COEFF_WIDTH-1 downto 0)
    );
end fir_filter;

architecture Behavioral of fir_filter is
    type coeff_array is array (0 to TAP_NUM-1) of signed(COEFF_WIDTH-1 downto 0);
    constant coeff : coeff_array := (
        to_signed(100, COEFF_WIDTH),
        to_signed(200, COEFF_WIDTH),
        to_signed(300, COEFF_WIDTH),
        to_signed(400, COEFF_WIDTH),
        to_signed(400, COEFF_WIDTH),
        to_signed(300, COEFF_WIDTH),
        to_signed(200, COEFF_WIDTH),
        to_signed(100, COEFF_WIDTH)
    );

    type shift_reg_type is array (0 to TAP_NUM-1) of signed(DATA_WIDTH-1 downto 0);
    signal shift_reg : shift_reg_type;

    type mult_type is array (0 to TAP_NUM-1) of signed(DATA_WIDTH+COEFF_WIDTH-1 downto 0);
    signal mult : mult_type;

    signal sum : signed(DATA_WIDTH+COEFF_WIDTH-1 downto 0);
begin
    process(clk, rst)
    begin
        if rst = '1' then
            shift_reg <= (others => (others => '0'));
            sum <= (others => '0');
        elsif rising_edge(clk) then
            -- シフトレジスタの更新
            shift_reg <= x & shift_reg(0 to TAP_NUM-2);

            -- 積和演算
            sum <= (others => '0');
            for i in 0 to TAP_NUM-1 loop
                mult(i) <= shift_reg(i) * coeff(i);
                sum <= sum + mult(i);
            end loop;

            y <= sum;
        end if;
    end process;
end Behavioral;

この8タップFIRフィルタは、signed型を使用して入力信号と係数の乗算、および結果の加算を行っています。

シフトレジスタを使用することで、効率的なハードウェア実装が可能になっています。

○サンプルコード18：signed型によるPID制御器の設計

PID（比例-積分-微分）制御は、産業界で広く使用される基本的な制御アルゴリズムです。

VHDLでsigned型を駆使してPID制御器を実装すると、高精度な制御が可能になります。

ここでは、signed型を活用したPID制御器の設計例を紹介します。

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity pid_controller is
    generic (
        DATA_WIDTH : integer := 16;
        KP : integer := 100;  -- 比例ゲイン
        KI : integer := 10;   -- 積分ゲイン
        KD : integer := 50    -- 微分ゲイン
    );
    port (
        clk : in std_logic;
        rst : in std_logic;
        setpoint : in signed(DATA_WIDTH-1 downto 0);
        feedback : in signed(DATA_WIDTH-1 downto 0);
        control : out signed(DATA_WIDTH-1 downto 0)
    );
end pid_controller;

architecture Behavioral of pid_controller is
    signal error, prev_error : signed(DATA_WIDTH-1 downto 0);
    signal integral : signed(2*DATA_WIDTH-1 downto 0);
    signal derivative : signed(DATA_WIDTH-1 downto 0);
    signal p_term, i_term, d_term : signed(2*DATA_WIDTH-1 downto 0);
begin
    process(clk, rst)
    begin
        if rst = '1' then
            error <= (others => '0');
            prev_error <= (others => '0');
            integral <= (others => '0');
            derivative <= (others => '0');
            p_term <= (others => '0');
            i_term <= (others => '0');
            d_term <= (others => '0');
            control <= (others => '0');
        elsif rising_edge(clk) then
            -- エラー計算
            error <= setpoint - feedback;

            -- 比例項
            p_term <= error * to_signed(KP, DATA_WIDTH);

            -- 積分項
            integral <= integral + error;
            i_term <= integral * to_signed(KI, DATA_WIDTH);

            -- 微分項
            derivative <= error - prev_error;
            d_term <= derivative * to_signed(KD, DATA_WIDTH);

            -- 制御出力計算
            control <= resize(p_term + i_term + d_term, DATA_WIDTH);

            -- 前回のエラーを更新
            prev_error <= error;
        end if;
    end process;
end Behavioral;

このPID制御器の設計では、signed型を使用して各項（比例、積分、微分）の計算を行っています。

エラー、積分値、微分値をsigned型で表現することで、正負の値を適切に扱うことができます。

また、ゲイン値（KP、KI、KD）も整数として扱い、乗算を用いて各項の計算を行っています。

制御出力の計算では、オーバーフローを防ぐために一時的に大きなビット幅を使用し、最後にresizeを使用して出力のビット幅に合わせています。

PID制御器の動作を確認するために、次のようなテストベンチを用意しました。

-- テストベンチ
entity tb_pid_controller is
end tb_pid_controller;

architecture Behavioral of tb_pid_controller is
    constant DATA_WIDTH : integer := 16;
    signal clk : std_logic := '0';
    signal rst : std_logic := '1';
    signal setpoint, feedback, control : signed(DATA_WIDTH-1 downto 0);

    component pid_controller is
        generic (
            DATA_WIDTH : integer := 16;
            KP : integer := 100;
            KI : integer := 10;
            KD : integer := 50
        );
        port (
            clk : in std_logic;
            rst : in std_logic;
            setpoint : in signed(DATA_WIDTH-1 downto 0);
            feedback : in signed(DATA_WIDTH-1 downto 0);
            control : out signed(DATA_WIDTH-1 downto 0)
        );
    end component;

begin
    uut: pid_controller
        generic map (DATA_WIDTH => DATA_WIDTH)
        port map (clk => clk, rst => rst, setpoint => setpoint, 
                  feedback => feedback, control => control);

    -- クロック生成
    clk <= not clk after 5 ns;

    process
    begin
        wait for 10 ns;
        rst <= '0';

        -- 目標値を設定
        setpoint <= to_signed(1000, DATA_WIDTH);

        -- フィードバック値を変化させてPID制御器の応答を観察
        feedback <= to_signed(0, DATA_WIDTH);
        wait for 100 ns;
        feedback <= to_signed(500, DATA_WIDTH);
        wait for 100 ns;
        feedback <= to_signed(800, DATA_WIDTH);
        wait for 100 ns;
        feedback <= to_signed(1000, DATA_WIDTH);
        wait for 100 ns;

        wait;
    end process;
end Behavioral;

シミュレーション結果は次のようになります。

# シミュレーション結果（一部抜粋）
Time: 20 ns
setpoint = "0000001111101000" (1000)
feedback = "0000000000000000" (0)
control = "0000001111101000" (1000)

Time: 120 ns
setpoint = "0000001111101000" (1000)
feedback = "0000000111110100" (500)
control = "0000001001110100" (628)

Time: 220 ns
setpoint = "0000001111101000" (1000)
feedback = "0000001100100000" (800)
control = "0000000100000100" (260)

Time: 320 ns
setpoint = "0000001111101000" (1000)
feedback = "0000001111101000" (1000)
control = "0000000000000000" (0)

シミュレーション結果から、PID制御器が目標値とフィードバック値の差に応じて適切な制御出力を生成していることが確認できます。

フィードバック値が目標値に近づくにつれて、制御出力が小さくなっていきます。

signed型を使用したPID制御器の実装により、正確な演算と柔軟な制御が可能になります。

実際の応用では、ゲイン値の調整やアンチワインドアップなどの追加機能を実装することで、より高度な制御システムを構築することができます。