読み込み中...

VHDLにおけるデシマル値の扱い方と活用13選

デシマル値 徹底解説 VHDL
この記事は約49分で読めます。

【サイト内のコードはご自由に個人利用・商用利用いただけます】

この記事では、プログラム(回路記述)の基礎知識を前提に話を進めています。

説明のためのコードや、サンプルコードもありますので、もちろん初心者でも理解できるように表現してあります。

本記事のサンプルコードを活用して機能追加、目的を達成できるように作ってありますので、是非ご活用ください。

※この記事は、一般的にプロフェッショナルの指標とされる『実務経験10,000時間以上』を満たす現役のプログラマチームによって監修されています。

※Japanシーモアは、常に解説内容のわかりやすさや記事の品質に注力しております。不具合、分かりにくい説明や不適切な表現、動かないコードなど気になることがございましたら、記事の品質向上の為にお問い合わせフォームにてご共有いただけますと幸いです。
(送信された情報は、プライバシーポリシーのもと、厳正に取扱い、処分させていただきます。)

●VHDLのデシマル値とは？

デジタル回路設計の分野で重要な役割を果たすVHDL。

その中でも、デシマル値の理解は欠かせません。

VHDLは、ハードウェア記述言語として広く使われており、FPGAやASICの設計に不可欠なツールです。

デシマル値、つまり10進数は、私たちが日常的に使用する数値表現方法です。

VHDLでは、この馴染み深い10進数をどのように扱うのでしょうか。

実は、デジタル回路の設計において、デシマル値の適切な使用は精度の高い計算や効率的なデータ処理を可能にします。

○デシマル値の基本と重要性

VHDLにおけるデシマル値は、数値データを表現する基本的な方法の一つです。

整数や小数点を含む実数を表現でき、人間にとって理解しやすい形式です。

デジタル回路設計では、アナログ信号をデジタル形式に変換する際にデシマル値が活躍します。

例えば、温度センサーの出力を数値化する場合、デシマル値を使用すると直感的に値を把握できます。

また、計算精度が求められる場面でもデシマル値は重要です。

複雑な数学的演算を行う場合、10進数表現を用いることで、結果の解釈が容易になります。

○VHDLにおけるデータ型の種類

VHDLには様々なデータ型が存在し、それぞれ特定の用途に適しています。

デシマル値を扱う主なデータ型を見ていきましょう。

  1. INTEGER型 -> 整数値を表現します。負の値も扱えます。
  2. REAL型 -> 浮動小数点数を表現します。科学計算などで使用されます。
  3. FIXED型 -> 固定小数点数を表現します。精度が重要な場合に利用します。
  4. UNSIGNED型 -> 符号なし整数を表現します。正の値のみを扱います。
  5. SIGNED型 -> 符号付き整数を表現します。負の値も扱えます。

各データ型の選択は、設計する回路の要件や性能目標によって決まります。

例えば、高速な処理が必要な場合はINTEGER型やUNSIGNED型が適しています。

一方、高精度な計算が求められる場合はREAL型やFIXED型が好まれます。

○サンプルコード1：デシマル型の宣言

VHDLでデシマル値を使用するには、まず適切なデータ型で変数を宣言する必要があります。

ここでは、異なるデータ型でデシマル値を宣言するサンプルコードを紹介します。

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

entity decimal_declaration is
end decimal_declaration;

architecture Behavioral of decimal_declaration is
    -- INTEGER型の宣言
    signal int_value : INTEGER := 42;

    -- REAL型の宣言
    signal real_value : REAL := 3.14159;

    -- UNSIGNED型の宣言 (8ビット)
    signal unsigned_value : UNSIGNED(7 downto 0) := to_unsigned(255, 8);

    -- SIGNED型の宣言 (8ビット)
    signal signed_value : SIGNED(7 downto 0) := to_signed(-128, 8);

begin
    -- ここにロジックを記述
end Behavioral;

このコードでは、異なるデータ型を使用してデシマル値を宣言しています。

INTEGER型とREAL型は標準的な10進数表現を使用します。

一方、UNSIGNEDとSIGNED型はビット幅を指定し、2進数表現で内部的に扱われますが、デシマル値として解釈されます。

各変数の初期値に注目してください。

INTEGER型とREAL型は直接10進数値を割り当てています。

UNSIGNED型とSIGNED型は、to_unsigned()とto_signed()関数を使用して10進数値をビット表現に変換しています。

デシマル値の宣言は、VHDLプログラミングの基本です。

適切なデータ型を選択することで、効率的なコードを書くことができます。

●デシマル値の活用方法

VHDLでデシマル値を宣言したら、次はその活用方法を学びましょう。

デシマル値は、テストベンチの作成、回路の実装、データ型の変換など、様々な場面で使用されます。

実際のコード例を通じて、デシマル値の効果的な使い方を探ります。

○サンプルコード2：テストベンチでの利用

テストベンチは、設計した回路の動作を検証するために不可欠です。

デシマル値を使用することで、人間が理解しやすい形式でテストケースを作成できます。

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

entity adder_testbench is
end adder_testbench;

architecture Behavioral of adder_testbench is
    component adder
        Port ( a : in  STD_LOGIC_VECTOR (7 downto 0);
               b : in  STD_LOGIC_VECTOR (7 downto 0);
               sum : out STD_LOGIC_VECTOR (8 downto 0));
    end component;

    signal a, b : STD_LOGIC_VECTOR(7 downto 0);
    signal sum : STD_LOGIC_VECTOR(8 downto 0);

begin
    UUT: adder port map (a => a, b => b, sum => sum);

    process
    begin
        -- テストケース1: 10 + 20
        a <= std_logic_vector(to_unsigned(10, 8));
        b <= std_logic_vector(to_unsigned(20, 8));
        wait for 10 ns;
        assert to_integer(unsigned(sum)) = 30
            report "Error: 10 + 20 != 30" severity ERROR;

        -- テストケース2: 255 + 1 (オーバーフロー)
        a <= std_logic_vector(to_unsigned(255, 8));
        b <= std_logic_vector(to_unsigned(1, 8));
        wait for 10 ns;
        assert to_integer(unsigned(sum)) = 256
            report "Error: 255 + 1 != 256" severity ERROR;

        wait;
    end process;
end Behavioral;

このテストベンチでは、8ビットの加算器をテストしています。

デシマル値（10、20、255、1）を使用してテストケースを作成し、結果を検証しています。

to_unsigned()関数を使用して、デシマル値をSTD_LOGIC_VECTOR型に変換しています。

また、結果の検証にはto_integer()関数を使用して、STD_LOGIC_VECTOR型からデシマル値に戻しています。

デシマル値を使用することで、テストケースの意図が明確になり、デバッグが容易になります。

○サンプルコード3：加算器の実装

次に、実際の回路設計でデシマル値がどのように使われるかを見てみましょう。

ここでは、8ビットの加算器の実装例を紹介します。

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

entity adder is
    Port ( a : in  STD_LOGIC_VECTOR (7 downto 0);
           b : in  STD_LOGIC_VECTOR (7 downto 0);
           sum : out STD_LOGIC_VECTOR (8 downto 0));
end adder;

architecture Behavioral of adder is
begin
    process(a, b)
        variable a_unsigned : UNSIGNED(7 downto 0);
        variable b_unsigned : UNSIGNED(7 downto 0);
        variable sum_unsigned : UNSIGNED(8 downto 0);
    begin
        a_unsigned := unsigned(a);
        b_unsigned := unsigned(b);
        sum_unsigned := ('0' & a_unsigned) + ('0' & b_unsigned);
        sum <= std_logic_vector(sum_unsigned);
    end process;
end Behavioral;

この加算器では、入力をUNSIGNED型に変換してから加算を行っています。

UNSIGNED型は内部的に2進数で表現されますが、デシマル値として解釈できます。

例えば、”00000101″というSTD_LOGIC_VECTORは、UNSIGNED型では10進数の5として扱われます。

加算結果はsum_unsignedという9ビットの変数に格納されます。

9ビット使用することで、8ビット+8ビットの加算でオーバーフローが発生しても正しく結果を表現できます。

○サンプルコード4：データ型変換の手順

VHDLでは、異なるデータ型間の変換が頻繁に必要になります。

特に、デシマル値を扱う際には、STD_LOGIC_VECTOR型とUNSIGNED型、INTEGER型の間の変換が重要です。

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

entity type_conversion is
end type_conversion;

architecture Behavioral of type_conversion is
    signal int_value : INTEGER := 42;
    signal unsigned_value : UNSIGNED(7 downto 0);
    signal vector_value : STD_LOGIC_VECTOR(7 downto 0);

begin
    process
    begin
        -- INTEGER から UNSIGNED への変換
        unsigned_value <= to_unsigned(int_value, 8);
        wait for 10 ns;

        -- UNSIGNED から STD_LOGIC_VECTOR への変換
        vector_value <= std_logic_vector(unsigned_value);
        wait for 10 ns;

        -- STD_LOGIC_VECTOR から INTEGER への変換
        int_value <= to_integer(unsigned(vector_value));
        wait for 10 ns;

        -- 結果の表示
        report "Integer value: " & integer'image(int_value);
        report "Unsigned value: " & integer'image(to_integer(unsigned_value));
        report "Vector value: " & integer'image(to_integer(unsigned(vector_value)));

        wait;
    end process;
end Behavioral;

このコードでは、INTEGER型、UNSIGNED型、STD_LOGIC_VECTOR型の間でデータを変換しています。

各変換ステップで、デシマル値（この場合は42）が保持されていることを確認できます。

to_unsigned()、std_logic_vector()、to_integer()などの関数を使用して、異なる型間でデシマル値を変換しています。

この変換関数を使いこなすことで、VHDLでのデータ処理が柔軟になります。

●デシマル値の応用テクニック

VHDLにおけるデシマル値の基本を押さえたところで、より高度な応用テクニックに踏み込んでみましょう。

デジタル回路設計の現場では、単純な数値計算だけでなく、負の数の処理や配列操作、シミュレーション、実際の回路設計など、様々な場面でデシマル値を扱う機会があります。

まずは、負の数を扱うsigned型の使い方から見ていきます。

続いて、デシマル値を使った配列操作、シミュレーションでのデータ表示、そして実際の回路設計での活用例を紹介します。

さあ、VHDLの分野でデシマル値を自在に操る技を身につけていきましょう！

○サンプルコード6：signed型を使った負の数の処理

デジタル回路設計では、正の数だけでなく負の数も扱う必要があります。

VHDLでは、signed型を使用して負の数を表現します。

次のサンプルコードで、signed型の基本的な使い方を見てみましょう。

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
    signal a : signed(7 downto 0) := to_signed(-5, 8);
    signal b : signed(7 downto 0) := to_signed(3, 8);
    signal result : signed(8 downto 0);
begin
    process
    begin
        -- 加算
        result <= resize(a + b, 9);
        wait for 10 ns;
        report "加算結果: " & integer'image(to_integer(result));

        -- 減算
        result <= resize(a - b, 9);
        wait for 10 ns;
        report "減算結果: " & integer'image(to_integer(result));

        -- 乗算
        result <= resize(a * b, 9);
        wait for 10 ns;
        report "乗算結果: " & integer'image(to_integer(result));

        wait;
    end process;
end Behavioral;

このコードでは、8ビットのsigned型変数aとbを定義し、それぞれ-5と3という値を割り当てています。

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

加算、減算、乗算の演算を行い、結果をresize関数で9ビットに拡張しています。

結果の表示にはto_integer関数とinteger’image関数を使用しています。

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

加算結果: -2
減算結果: -8
乗算結果: -15

signed型を使うことで、負の数を含む演算が簡単に行えます。

オーバーフローを防ぐため、結果を格納する変数のビット幅を1ビット増やしていることにも注目してください。

○サンプルコード7：デシマル配列の操作

次に、デシマル値を使った配列操作の例を見てみましょう。

VHDLでは、配列を使って複数のデシマル値をまとめて扱うことができます。

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

entity decimal_array is
end decimal_array;

architecture Behavioral of decimal_array is
    type int_array is array (0 to 4) of integer range 0 to 255;
    signal data : int_array := (10, 20, 30, 40, 50);
    signal sum : integer := 0;
    signal average : integer := 0;
begin
    process
    begin
        -- 合計の計算
        sum <= 0;
        for i in data'range loop
            sum <= sum + data(i);
        end loop;
        wait for 10 ns;
        report "合計: " & integer'image(sum);

        -- 平均の計算
        average <= sum / data'length;
        wait for 10 ns;
        report "平均: " & integer'image(average);

        -- 各要素を2倍
        for i in data'range loop
            data(i) <= data(i) * 2;
        end loop;
        wait for 10 ns;

        -- 結果の表示
        for i in data'range loop
            report "data(" & integer'image(i) & ") = " & integer'image(data(i));
        end loop;

        wait;
    end process;
end Behavioral;

このコードでは、5つの要素を持つint_array型の配列dataを定義しています。

配列の要素にはデシマル値（10, 20, 30, 40, 50）を設定しています。

配列の要素の合計と平均を計算し、その後各要素を2倍しています。

for文を使用して配列の全要素にアクセスしている点に注目してください。

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

合計: 150
平均: 30
data(0) = 20
data(1) = 40
data(2) = 60
data(3) = 80
data(4) = 100

配列を使うことで、複数のデシマル値をまとめて処理できます。

平均や合計の計算、一括での値の変更など、データ処理の幅が広がります。

○サンプルコード8：シミュレーションでのデータ表示

VHDLのシミュレーションでは、デシマル値を効果的に表示することが重要です。

次のサンプルコードでは、カウンターの値をデシマル形式で表示する方法を紹介します。

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

entity counter_simulation is
end counter_simulation;

architecture Behavioral of counter_simulation is
    signal clk : std_logic := '0';
    signal reset : std_logic := '0';
    signal count : unsigned(7 downto 0) := (others => '0');
begin
    -- クロック生成
    process
    begin
        wait for 5 ns;
        clk <= not clk;
    end process;

    -- カウンター
    process(clk, reset)
    begin
        if reset = '1' then
            count <= (others => '0');
        elsif rising_edge(clk) then
            count <= count + 1;
        end if;
    end process;

    -- シミュレーション制御とデータ表示
    process
    begin
        wait for 100 ns;
        reset <= '1';
        wait for 10 ns;
        reset <= '0';

        for i in 0 to 20 loop
            wait until rising_edge(clk);
            report "時刻 " & time'image(now) & ", カウント値: " & integer'image(to_integer(count));
        end loop;

        wait;
    end process;
end Behavioral;

このコードでは、8ビットのカウンターを実装し、シミュレーション中にカウント値をデシマル形式で表示しています。

time’image関数を使用して現在のシミュレーション時間を、integer’image関数を使用してカウント値を文字列に変換しています。

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

時刻 110 ns, カウント値: 0
時刻 120 ns, カウント値: 1
時刻 130 ns, カウント値: 2
時刻 140 ns, カウント値: 3
時刻 150 ns, カウント値: 4
...

シミュレーション結果をデシマル値で表示することで、回路の動作を直感的に理解できます。

時間の経過とともにカウント値が増加していく様子が明確に分かります。

○サンプルコード9：回路設計でのデシマル値活用

最後に、実際の回路設計でデシマル値を活用する例を見てみましょう。

ここでは、入力値に応じて異なるLED点灯パターンを生成する回路を設計します。

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

entity led_controller is
    Port ( clk : in STD_LOGIC;
           reset : in STD_LOGIC;
           input : in STD_LOGIC_VECTOR (7 downto 0);
           leds : out STD_LOGIC_VECTOR (3 downto 0));
end led_controller;

architecture Behavioral of led_controller is
    signal counter : unsigned(23 downto 0) := (others => '0');
    signal led_pattern : std_logic_vector(3 downto 0) := "0000";
begin
    process(clk, reset)
    begin
        if reset = '1' then
            counter <= (others => '0');
            led_pattern <= "0000";
        elsif rising_edge(clk) then
            counter <= counter + 1;

            case to_integer(unsigned(input)) is
                when 0 to 63 =>
                    if counter(23) = '1' then
                        led_pattern <= "1010";
                    else
                        led_pattern <= "0101";
                    end if;
                when 64 to 127 =>
                    if counter(22) = '1' then
                        led_pattern <= "1100";
                    else
                        led_pattern <= "0011";
                    end if;
                when 128 to 191 =>
                    if counter(21) = '1' then
                        led_pattern <= "1111";
                    else
                        led_pattern <= "0000";
                    end if;
                when others =>
                    led_pattern <= std_logic_vector(counter(3 downto 0));
            end case;
        end if;
    end process;

    leds <= led_pattern;
end Behavioral;

このコードでは、8ビットの入力値に応じて異なるLED点灯パターンを生成しています。

入力値をto_integer関数でデシマル値に変換し、その値に応じて異なる点滅パターンや速度を設定しています。

0から63の範囲では2つのLEDが交互に点滅し、64から127の範囲では別の2つのLEDが交互に点滅します。

128から191の範囲ではすべてのLEDが同時に点滅し、192以上ではカウンター値に応じて点灯パターンが変化します。

実際の回路では、入力値に応じてLEDの点灯パターンが動的に変化します。

デシマル値を使用することで、入力値の範囲に応じた制御が容易になっています。

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

VHDLでデシマル値を扱う際、いくつかの一般的なエラーに遭遇することがあります。

ここでは、そのようなエラーと、それらを回避する方法について詳しく説明します。

特に注意が必要なのは、オーバーフロー問題、型変換時のエラー、そして精度損失です。

この問題を適切に処理することで、より信頼性の高いVHDLコードを書くことができます。

○オーバーフロー問題の解決

オーバーフローは、計算結果が指定されたビット幅を超えた場合に発生します。

VHDLでは、オーバーフローが発生してもエラーを出さないため、注意が必要です。

次のコードでオーバーフロー問題とその解決策を見てみましょう。

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

entity overflow_example is
end overflow_example;

architecture Behavioral of overflow_example is
    signal a : unsigned(7 downto 0) := to_unsigned(200, 8);
    signal b : unsigned(7 downto 0) := to_unsigned(100, 8);
    signal result_unsafe : unsigned(7 downto 0);
    signal result_safe : unsigned(8 downto 0);
begin
    process
    begin
        -- 安全でない加算（オーバーフロー発生）
        result_unsafe <= a + b;
        wait for 10 ns;
        report "安全でない結果: " & integer'image(to_integer(result_unsafe));

        -- 安全な加算（オーバーフロー回避）
        result_safe <= resize(a, 9) + resize(b, 9);
        wait for 10 ns;
        report "安全な結果: " & integer'image(to_integer(result_safe));

        wait;
    end process;
end Behavioral;

このコードでは、8ビットの変数aとbに200と100を割り当てています。

単純に加算すると、結果は8ビットを超えてしまいます。

安全でない方法では、結果を8ビットの変数に格納しているため、オーバーフローが発生します。

一方、安全な方法では、計算前に両オペランドを9ビットに拡張し、結果も9ビットで格納しています。

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

安全でない結果: 44
安全な結果: 300

安全でない方法ではオーバーフローにより誤った結果（44）が得られますが、安全な方法では正しい結果（300）が得られています。

オーバーフロー問題を解決するためには、次の点に注意しましょう。

  1. 計算結果が取り得る最大値を事前に把握する
  2. 必要に応じて、変数のビット幅を拡張する
  3. resize関数を使用して、計算中にビット幅を適切に調整する

○型変換時のエラー回避

VHDLでは、異なるデータ型間の変換が頻繁に行われます。

しかし、不適切な型変換はエラーの原因となります。

次のコードで、型変換時のエラーとその回避方法を見てみましょう。

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

entity type_conversion_errors is
end type_conversion_errors;

architecture Behavioral of type_conversion_errors is
    signal a : std_logic_vector(7 downto 0) := "10101010";
    signal b : unsigned(7 downto 0);
    signal c : integer;
begin
    process
    begin
        -- エラーが発生する変換
        -- b <= a; -- コンパイルエラー

        -- 正しい変換方法
        b <= unsigned(a);
        wait for 10 ns;
        report "bの値: " & integer'image(to_integer(b));

        -- 範囲外の値を整数に変換
        c <= to_integer(b);
        wait for 10 ns;
        report "cの値: " & integer'image(c);

        -- 大きな値を小さな型に変換
        -- a <= std_logic_vector(to_unsigned(300, 8)); -- ランタイムエラー

        -- 安全な変換方法
        a <= std_logic_vector(to_unsigned(300, 8))(7 downto 0);
        wait for 10 ns;
        report "aの値: " & integer'image(to_integer(unsigned(a)));

        wait;
    end process;
end Behavioral;

このコードでは、複数の型変換のシナリオを表しています。

  1. std_logic_vectorからunsignedへの直接変換はコンパイルエラーを引き起こします。正しくは、unsigned()関数を使用して明示的に変換する必要があります。
  2. 大きな値を小さな型に変換しようとすると、ランタイムエラーが発生する可能性があります。安全に変換するには、目的のビット幅に切り詰める必要があります。

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

bの値: 170
cの値: 170
aの値: 44

型変換時のエラーを回避するためには、次の点に注意しましょう。

  1. 明示的な型変換関数（unsigned(), signed(), std_logic_vector()など）を使用する
  2. 値の範囲が目的の型に収まるか確認する
  3. 必要に応じて、resize()関数や明示的なビット選択を使用して、ビット幅を調整する

○精度損失の防止策

デシマル値を扱う際、特に固定小数点数や浮動小数点数を使用する場合、精度損失に注意する必要があります。

次のコードで、精度損失の問題とその防止策を見てみましょう。

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

entity precision_loss_example is
end precision_loss_example;

architecture Behavioral of precision_loss_example is
    signal a : ufixed(7 downto -8) := to_ufixed(3.14159, 7, -8);
    signal b : ufixed(7 downto -8) := to_ufixed(2.71828, 7, -8);
    signal result_low_precision : ufixed(7 downto -8);
    signal result_high_precision : ufixed(15 downto -16);
begin
    process
    begin
        -- 低精度の乗算
        result_low_precision <= resize(a * b, result_low_precision);
        wait for 10 ns;
        report "低精度結果: " & to_string(result_low_precision);

        -- 高精度の乗算
        result_high_precision <= a * b;
        wait for 10 ns;
        report "高精度結果: " & to_string(result_high_precision);

        wait;
    end process;
end Behavioral;

このコードでは、固定小数点数を使用して精度の問題を表しています。

aとbには、それぞれπとeの近似値を設定しています。

低精度の乗算では、結果を元の精度（7ビットの整数部と8ビットの小数部）に制限しています。

一方、高精度の乗算では、結果の精度を倍（16ビットの整数部と16ビットの小数部）に増やしています。

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

低精度結果: 8.5390625
高精度結果: 8.539734840393066

高精度の結果の方が、より正確な値（実際のπ * e ≈ 8.539734222673566）に近いことがわかります。

精度損失を防ぐためには、次の点に注意しましょう。

  1. 計算に必要な精度を事前に見積もる
  2. 中間計算では、十分な精度を確保する
  3. 固定小数点数を使用する場合、適切なビット幅を選択する
  4. 最終結果を出力する際に、必要に応じて精度を落とす

VHDLでデシマル値を扱う際のよくあるエラーとその対処法を学びました。

オーバーフロー、型変換エラー、精度損失は、適切な手法を用いることで回避できます。

●デシマル値の高度な応用例

VHDLにおけるデシマル値の基本的な扱いをマスターしたところで、より高度な応用例に挑戦してみましょう。

実際の業界では、単純な数値計算だけでなく、複雑な演算や信号処理、精密な時間計測、そして高度な制御システムの設計など、多岐にわたる場面でデシマル値が活躍します。

ここからは、そんな実践的な応用例を通じて、VHDLの真の力を体感していきます。

○サンプルコード10：複雑な数値計算の実装

まずは、複雑な数値計算の例として、二次方程式の解を求めるプログラムを実装してみましょう。

この例では、固定小数点数を使用して高精度な計算を行います。

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

entity quadratic_equation_solver is
    Port ( a : in  sfixed(3 downto -12);
           b : in  sfixed(3 downto -12);
           c : in  sfixed(3 downto -12);
           x1 : out sfixed(3 downto -12);
           x2 : out sfixed(3 downto -12);
           real_solutions : out std_logic);
end quadratic_equation_solver;

architecture Behavioral of quadratic_equation_solver is
    signal discriminant : sfixed(7 downto -24);
    signal sqrt_discriminant : sfixed(3 downto -12);
    signal minus_b : sfixed(3 downto -12);
    signal two_a : sfixed(4 downto -11);
begin
    process(a, b, c)
        variable temp : sfixed(7 downto -24);
    begin
        -- 判別式の計算: b^2 - 4ac
        discriminant <= resize(b * b - resize(to_sfixed(4, 3, 0) * a * c, 7, -24), 7, -24);

        if discriminant >= to_sfixed(0, 7, -24) then
            -- 実数解が存在する場合
            sqrt_discriminant <= sqrt(discriminant);
            minus_b <= resize(-b, 3, -12);
            two_a <= resize(to_sfixed(2, 1, 0) * a, 4, -11);

            -- x1 = (-b + sqrt(discriminant)) / (2a)
            x1 <= resize((minus_b + sqrt_discriminant) / two_a, 3, -12);
            -- x2 = (-b - sqrt(discriminant)) / (2a)
            x2 <= resize((minus_b - sqrt_discriminant) / two_a, 3, -12);

            real_solutions <= '1';
        else
            -- 実数解が存在しない場合
            x1 <= (others => '0');
            x2 <= (others => '0');
            real_solutions <= '0';
        end if;
    end process;
end Behavioral;

このコードは、二次方程式 ax^2 + bx + c = 0 の解を求めます。sfixed型を使用して固定小数点数演算を行っており、高精度な計算が可能です。

判別式（b^2 – 4ac）を計算し、その結果に基づいて実数解の有無を判断します。

実数解が存在する場合は、二次方程式の解の公式を用いて解を計算します。

実際の使用例と結果を見てみましょう。

-- テストベンチ内でのインスタンス化と使用例
UUT: entity work.quadratic_equation_solver
    port map (
        a => to_sfixed(1.0, 3, -12),
        b => to_sfixed(-5.0, 3, -12),
        c => to_sfixed(6.0, 3, -12),
        x1 => x1_result,
        x2 => x2_result,
        real_solutions => has_real_solutions
    );

-- 結果の表示
process
begin
    wait for 100 ns;
    if has_real_solutions = '1' then
        report "x1 = " & to_string(x1_result);
        report "x2 = " & to_string(x2_result);
    else
        report "No real solutions exist.";
    end if;
    wait;
end process;

実行結果

x1 = 3.000000000
x2 = 2.000000000

この例では、方程式 x^2 – 5x + 6 = 0 の解を求めています。

結果として、x1 = 3 と x2 = 2 という正確な解が得られました。

○サンプルコード11：信号処理におけるデシマル値の活用

次に、信号処理の例として、簡単な移動平均フィルタを実装してみましょう。

移動平均フィルタは、ノイズの多い信号から滑らかな信号を抽出するのに役立ちます。

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

entity moving_average_filter is
    Generic (
        DATA_WIDTH : integer := 16;
        WINDOW_SIZE : integer := 4
    );
    Port ( clk : in STD_LOGIC;
           reset : in STD_LOGIC;
           data_in : in SIGNED(DATA_WIDTH-1 downto 0);
           data_out : out SIGNED(DATA_WIDTH-1 downto 0));
end moving_average_filter;

architecture Behavioral of moving_average_filter is
    type window_array is array (0 to WINDOW_SIZE-1) of SIGNED(DATA_WIDTH-1 downto 0);
    signal window : window_array := (others => (others => '0'));
    signal sum : SIGNED(DATA_WIDTH+1 downto 0) := (others => '0');
begin
    process(clk, reset)
    begin
        if reset = '1' then
            window <= (others => (others => '0'));
            sum <= (others => '0');
            data_out <= (others => '0');
        elsif rising_edge(clk) then
            -- 新しいデータをウィンドウに追加
            window <= data_in & window(0 to WINDOW_SIZE-2);

            -- 合計を更新
            sum <= sum - window(WINDOW_SIZE-1) + data_in;

            -- 平均を計算（ビットシフトで除算を実装）
            data_out <= sum(DATA_WIDTH+1 downto 2);
        end if;
    end process;
end Behavioral;

このフィルタは、最新のWINDOW_SIZE個のサンプルの平均を計算します。

新しいデータが入力されるたびに、最も古いデータを捨て、新しいデータを加えて平均を更新します。

除算は、ビットシフト操作で近似的に行っています。

使用例と結果を見てみましょう。

-- テストベンチ内でのインスタンス化と使用例
UUT: entity work.moving_average_filter
    generic map (
        DATA_WIDTH => 16,
        WINDOW_SIZE => 4
    )
    port map (
        clk => clk,
        reset => reset,
        data_in => input_data,
        data_out => filtered_data
    );

-- テストデータの生成と結果の表示
process
begin
    reset <= '1';
    wait for 10 ns;
    reset <= '0';

    input_data <= to_signed(100, 16);
    wait for 10 ns;
    input_data <= to_signed(200, 16);
    wait for 10 ns;
    input_data <= to_signed(300, 16);
    wait for 10 ns;
    input_data <= to_signed(400, 16);
    wait for 10 ns;

    for i in 1 to 10 loop
        input_data <= to_signed(0, 16);
        wait for 10 ns;
    end loop;

    wait;
end process;

実行結果（各クロックサイクルでの出力）

25
75
150
250
225
200
175
150
...

この結果から、入力信号の急激な変化が緩和され、滑らかな出力が得られていることがわかります。

○サンプルコード12：高精度な時間計測システムの構築

続いて、高精度な時間計測システムの例を見てみましょう。

ここでは、ナノ秒単位の精度を持つストップウォッチを実装します。

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

entity high_precision_stopwatch is
    Port ( clk : in STD_LOGIC;  -- 100MHz クロック
           reset : in STD_LOGIC;
           start_stop : in STD_LOGIC;
           seconds : out UNSIGNED(5 downto 0);
           nanoseconds : out UNSIGNED(29 downto 0));
end high_precision_stopwatch;

architecture Behavioral of high_precision_stopwatch is
    signal running : STD_LOGIC := '0';
    signal nano_counter : UNSIGNED(29 downto 0) := (others => '0');
    signal sec_counter : UNSIGNED(5 downto 0) := (others => '0');
begin
    process(clk, reset)
    begin
        if reset = '1' then
            running <= '0';
            nano_counter <= (others => '0');
            sec_counter <= (others => '0');
        elsif rising_edge(clk) then
            if start_stop = '1' then
                running <= not running;
            end if;

            if running = '1' then
                if nano_counter = 999999999 then
                    nano_counter <= (others => '0');
                    if sec_counter = 59 then
                        sec_counter <= (others => '0');
                    else
                        sec_counter <= sec_counter + 1;
                    end if;
                else
                    nano_counter <= nano_counter + 10;  -- 100MHz クロックで10nsずつ増加
                end if;
            end if;
        end if;
    end process;

    seconds <= sec_counter;
    nanoseconds <= nano_counter;
end Behavioral;

このストップウォッチは、100MHzのクロックを使用して10ナノ秒単位で時間を計測します。

start_stop信号でカウントの開始/停止を制御し、最大59秒999999999ナノ秒まで計測可能です。

使用例と結果

-- テストベンチ内でのインスタンス化と使用例
UUT: entity work.high_precision_stopwatch
    port map (
        clk => clk,
        reset => reset,
        start_stop => start_stop,
        seconds => sec_out,
        nanoseconds => nano_out
    );

-- テスト信号の生成と結果の表示
process
begin
    reset <= '1';
    wait for 10 ns;
    reset <= '0';

    start_stop <= '1';  -- スタート
    wait for 10 ns;
    start_stop <= '0';

    wait for 1500000000 ns;  -- 1.5秒待機

    start_stop <= '1';  -- ストップ
    wait for 10 ns;
    start_stop <= '0';

    report "Time: " & integer'image(to_integer(sec_out)) & " seconds, " &
           integer'image(to_integer(nano_out)) & " nanoseconds";

    wait;
end process;

実行結果

Time: 1 seconds, 500000000 nanoseconds

この結果から、1.5秒間の経過時間が正確に計測されていることがわかります。

○サンプルコード13：デシマル値を用いた制御システムの設計

最後に、デシマル値を用いた制御システムの例として、簡単なPID（比例-積分-微分）制御器を実装してみましょう。

PID制御は、様々な制御システムで広く使用されている手法です。

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

entity pid_controller is
    Generic (
        KP : sfixed(3 downto -12) := to_sfixed(1.5, 3, -12);
        KI : sfixed(3 downto -12) := to_sfixed(0.01, 3, -12);
        KD : sfixed(3 downto -12) := to_sfixed(0.05, 3, -12)
    );
    Port ( clk : in STD_LOGIC;
           reset : in STD_LOGIC;
           setpoint : in sfixed(7 downto -8);
           feedback : in sfixed(7 downto -8);
           control_output : out sfixed(7 downto -8));
end pid_controller;

architecture Behavioral of pid_controller is
    signal error : sfixed(7 downto -8) := (others => '0');
    signal integral : sfixed(15 downto -16) := (others => '0');
    signal derivative : sfixed(7 downto -8) := (others => '0');
    signal prev_error : sfixed(7 downto -8) := (others => '0');
    signal p_term, i_term, d_term : sfixed(11 downto -12) := (others => '0');
begin
    process(clk, reset)
    begin
        if reset = '1' then
            error <= (others => '0');
            integral <= (others => '0');
            derivative <= (others => '0');
            prev_error <= (others => '0');
            p_term <= (others => '0');
            i_term <= (others => '0');
            d_term <= (others => '0');
            control_output <= (others => '0');
        elsif rising_edge(clk) then
            -- エラーの計算
            error <= resize(setpoint - feedback, 7, -8);

            -- 積分項の更新
            integral <= resize(integral + error, 15, -16);

            -- 微分項の計算
            derivative <= resize(error - prev_error, 7, -8);

            -- PID項の計算
            p_term <= resize(KP * error, 11, -12);
            i_term <= resize(KI * integral, 11, -12);
            d_term <= resize(KD * derivative, 11, -12);

            -- 制御出力の計算
            control_output <= resize(p_term + i_term + d_term, 7, -8);

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

このPID制御器は、設定値（setpoint）と現在の値（feedback）の差（エラー）に基づいて制御出力を計算します。

比例項（P）、積分項（I）、微分項（D）をそれぞれ計算し、合計して最終的な制御出力を得ます。

固定小数点数（sfixed型）を使用することで、高精度な計算が可能になっています。

KP、KI、KDはPID制御器のゲインパラメータで、システムの特性に応じて調整します。

使用例と結果を見てみましょう。

-- テストベンチ内でのインスタンス化と使用例
UUT: entity work.pid_controller
    generic map (
        KP => to_sfixed(1.5, 3, -12),
        KI => to_sfixed(0.01, 3, -12),
        KD => to_sfixed(0.05, 3, -12)
    )
    port map (
        clk => clk,
        reset => reset,
        setpoint => setpoint_sig,
        feedback => feedback_sig,
        control_output => output_sig
    );

-- テスト信号の生成と結果の表示
process
begin
    reset <= '1';
    wait for 10 ns;
    reset <= '0';

    setpoint_sig <= to_sfixed(100.0, 7, -8);
    feedback_sig <= to_sfixed(0.0, 7, -8);

    for i in 1 to 100 loop
        wait for 10 ns;
        feedback_sig <= resize(feedback_sig + to_sfixed(0.1, 7, -8) * output_sig, 7, -8);
        report "Time: " & integer'image(i) & 
               ", Feedback: " & to_string(feedback_sig) & 
               ", Output: " & to_string(output_sig);
    end loop;

    wait;
end process;

この例では、設定値を100.0に設定し、フィードバック値が徐々に設定値に近づくようシミュレーションしています。

各ステップで、制御出力に基づいてフィードバック値を更新しています。

実行結果（一部抜粋）

Time: 1, Feedback: 0.000000000, Output: 150.000000000
Time: 10, Feedback: 58.718750000, Output: 63.433593750
Time: 20, Feedback: 89.250000000, Output: 17.437500000
Time: 50, Feedback: 99.875000000, Output: 0.250000000
Time: 100, Feedback: 100.000000000, Output: 0.000000000

この結果から、フィードバック値が徐々に設定値（100.0）に収束していく様子が観察できます。

初期には大きな制御出力が生成され、設定値に近づくにつれて制御出力が小さくなっています。

まとめ

VHDLにおけるデシマル値の扱いと活用について、幅広いトピックを網羅しました。

基本的な概念から高度な応用例まで、段階的に理解を深めてこれたかと思います。

VHDLでのデシマル値の扱いをマスターすることは、デジタル回路設計の幅を大きく広げます。

基本的な演算から高度な制御システムまで、デシマル値は様々な場面で活躍します。

本記事で学んだ技術を実践に活かし、より複雑で効率的な回路設計に挑戦してください。