VHDLにおけるseverityタイプの使い分け方と活用18選

architecture Behavioral of MyEntity is
begin
    process
    begin
        report "プロセスが開始されました" severity NOTE;
        wait;
    end process;
end Behavioral;

architecture Behavioral of CounterEntity is
    signal counter : integer range 0 to 100 := 0;
begin
    process(clk)
    begin
        if rising_edge(clk) then
            if counter = 50 then
                report "カウンターが50に到達しました" severity NOTE;
            end if;
            counter <= counter + 1;
        end if;
    end process;
end Behavioral;

architecture Behavioral of InputChecker is
    signal input_value : integer;
begin
    process(input_value)
    begin
        if input_value < 0 or input_value > 100 then
            report "入力値が予想範囲外です: " & integer'image(input_value) severity WARNING;
        end if;
    end process;
end Behavioral;

architecture Behavioral of ParameterChecker is
    constant REQUIRED_PARAM : integer := 0;  -- 0は未設定を示す
begin
    process
    begin
        if REQUIRED_PARAM = 0 then
            report "必須パラメータが設定されていません" severity ERROR;
        end if;
        wait;
    end process;
end Behavioral;

architecture Behavioral of ConfigChecker is
    type Config_Type is (VALID, INVALID);
    signal current_config : Config_Type := INVALID;
begin
    process
    begin
        if current_config = INVALID then
            report "無効な設定が検出されました。プログラムを終了します。" severity FAILURE;
        end if;
        wait;
    end process;
end Behavioral;

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

entity TimingChecker is
    Port ( clk : in STD_LOGIC;
           data_in : in STD_LOGIC_VECTOR(7 downto 0);
           data_out : out STD_LOGIC_VECTOR(7 downto 0));
end TimingChecker;

architecture Behavioral of TimingChecker is
    signal processing_time : time := 0 ns;
    constant MAX_ALLOWED_TIME : time := 10 ns;
begin
    process(clk)
    begin
        if rising_edge(clk) then
            data_out <= data_in;  -- 仮の処理
            processing_time <= now - processing_time;

            -- タイミング違反のチェック
            assert processing_time <= MAX_ALLOWED_TIME
                report "タイミング違反: 処理時間が" & time'image(processing_time) & "で、許容時間" & time'image(MAX_ALLOWED_TIME) & "を超えています。"
                severity ERROR;

            processing_time <= now;
        end if;
    end process;
end Behavioral;

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

entity DataIntegrityChecker is
    Port ( data_in : in STD_LOGIC_VECTOR(7 downto 0);
           parity : in STD_LOGIC);
end DataIntegrityChecker;

architecture Behavioral of DataIntegrityChecker is
    function calculate_parity(data : STD_LOGIC_VECTOR) return STD_LOGIC is
        variable p : STD_LOGIC := '0';
    begin
        for i in data'range loop
            p := p xor data(i);
        end loop;
        return p;
    end function;
begin
    process(data_in, parity)
        variable calculated_parity : STD_LOGIC;
    begin
        calculated_parity := calculate_parity(data_in);

        -- パリティチェック
        assert calculated_parity = parity
            report "データ整合性エラー: 計算されたパリティ " & STD_LOGIC'image(calculated_parity) & 
                   " が受信したパリティ " & STD_LOGIC'image(parity) & " と一致しません。"
            severity WARNING;
    end process;
end Behavioral;

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

entity RangeChecker is
    Port ( value : in INTEGER);
end RangeChecker;

architecture Behavioral of RangeChecker is
    constant MIN_VALUE : INTEGER := 0;
    constant MAX_VALUE : INTEGER := 100;
begin
    process(value)
    begin
        -- 範囲チェック
        assert (value >= MIN_VALUE and value <= MAX_VALUE)
            report "範囲外の値: " & INTEGER'image(value) & " が検出されました。許容範囲は " &
                   INTEGER'image(MIN_VALUE) & " から " & INTEGER'image(MAX_VALUE) & " です。"
            severity ERROR;
    end process;
end Behavioral;

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

entity DynamicSeverityChecker is
    Port ( value : in INTEGER;
           mode : in STD_LOGIC);
end DynamicSeverityChecker;

architecture Behavioral of DynamicSeverityChecker is
    constant THRESHOLD : INTEGER := 100;
begin
    process(value, mode)
        variable severity_level : SEVERITY_LEVEL;
    begin
        -- モードに基づいてseverityレベルを設定
        if mode = '1' then
            severity_level := ERROR;
        else
            severity_level := WARNING;
        end if;

        -- 値のチェックと動的なseverityレベルの適用
        assert value <= THRESHOLD
            report "閾値超過: 値 " & INTEGER'image(value) & " が閾値 " & INTEGER'image(THRESHOLD) & " を超えています。"
            severity severity_level;
    end process;
end Behavioral;

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

entity SignalSeverityController is
    Port ( clk : in STD_LOGIC;
           reset : in STD_LOGIC;
           data_in : in STD_LOGIC_VECTOR(7 downto 0));
end SignalSeverityController;

architecture Behavioral of SignalSeverityController is
    signal data_valid : STD_LOGIC := '0';
    signal error_count : INTEGER := 0;
begin
    process(clk, reset)
    begin
        if reset = '1' then
            data_valid <= '0';
            error_count <= 0;
        elsif rising_edge(clk) then
            if data_in = "11111111" then
                data_valid <= '1';
            else
                data_valid <= '0';
                error_count <= error_count + 1;
            end if;

            -- エラーカウントに基づくseverity制御
            assert error_count < 5
                report "データエラーが頻発しています。エラー回数: " & INTEGER'image(error_count)
                severity WARNING;

            assert error_count < 10
                report "クリティカルなエラー状態です。即座の対応が必要です。エラー回数: " & INTEGER'image(error_count)
                severity ERROR;
        end if;
    end process;
end Behavioral;

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

entity VariableSeverityController is
    Port ( data_in : in STD_LOGIC_VECTOR(7 downto 0));
end VariableSeverityController;

architecture Behavioral of VariableSeverityController is
begin
    process(data_in)
        variable error_type : INTEGER;
        variable severity_level : SEVERITY_LEVEL;
    begin
        -- データに基づいてエラータイプを判定
        if data_in = "00000000" then
            error_type := 1;  -- 軽微なエラー
        elsif data_in = "11111111" then
            error_type := 2;  -- 中程度のエラー
        else
            error_type := 0;  -- エラーなし
        end if;

        -- エラータイプに基づいてseverityレベルを設定
        case error_type is
            when 1 =>
                severity_level := NOTE;
            when 2 =>
                severity_level := WARNING;
            when others =>
                severity_level := NOTE;
        end case;

        -- エラー報告
        assert error_type = 0
            report "データエラーを検出: タイプ " & INTEGER'image(error_type)
            severity severity_level;
    end process;
end Behavioral;

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

entity ConditionalSeverityManager is
    Port ( temperature : in INTEGER;
           pressure : in INTEGER);
end ConditionalSeverityManager;

architecture Behavioral of ConditionalSeverityManager is
    constant TEMP_WARNING : INTEGER := 80;
    constant TEMP_CRITICAL : INTEGER := 100;
    constant PRESSURE_WARNING : INTEGER := 200;
    constant PRESSURE_CRITICAL : INTEGER := 250;
begin
    process(temperature, pressure)
        variable temp_severity : SEVERITY_LEVEL;
        variable pressure_severity : SEVERITY_LEVEL;
    begin
        -- 温度に基づくseverity設定
        if temperature > TEMP_CRITICAL then
            temp_severity := ERROR;
        elsif temperature > TEMP_WARNING then
            temp_severity := WARNING;
        else
            temp_severity := NOTE;
        end if;

        -- 圧力に基づくseverity設定
        if pressure > PRESSURE_CRITICAL then
            pressure_severity := ERROR;
        elsif pressure > PRESSURE_WARNING then
            pressure_severity := WARNING;
        else
            pressure_severity := NOTE;
        end if;

        -- 温度のチェックと報告
        assert temperature <= TEMP_WARNING
            report "温度警告: 現在の温度は " & INTEGER'image(temperature) & " 度です。"
            severity temp_severity;

        -- 圧力のチェックと報告
        assert pressure <= PRESSURE_WARNING
            report "圧力警告: 現在の圧力は " & INTEGER'image(pressure) & " Paです。"
            severity pressure_severity;
    end process;
end Behavioral;

Warning: 温度警告: 現在の温度は 90 度です。
Warning: 圧力警告: 現在の圧力は 220 Paです。

Error: 温度警告: 現在の温度は 110 度です。
Error: 圧力警告: 現在の圧力は 260 Paです。

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

entity ClockEdgeDetector is
    Port ( clk : in STD_LOGIC;
           reset : in STD_LOGIC);
end ClockEdgeDetector;

architecture Behavioral of ClockEdgeDetector is
    signal prev_clk : STD_LOGIC := '0';
    signal edge_counter : INTEGER := 0;
    constant MAX_EDGES : INTEGER := 1000000;  -- 1秒間に想定されるエッジ数
begin
    process(clk, reset)
    begin
        if reset = '1' then
            prev_clk <= '0';
            edge_counter <= 0;
        elsif rising_edge(clk) then
            if prev_clk /= clk then
                edge_counter <= edge_counter + 1;
            end if;
            prev_clk <= clk;

            -- クロックエッジ数のチェック
            assert edge_counter <= MAX_EDGES
                report "クロックエッジ数が異常です。カウント: " & INTEGER'image(edge_counter)
                severity WARNING;

            if edge_counter > MAX_EDGES then
                assert false
                    report "クリティカル：クロック信号が不安定です。即座の対応が必要です。"
                    severity ERROR;
            end if;
        end if;
    end process;
end Behavioral;

Warning: クロックエッジ数が異常です。カウント: 1000001
Error: クリティカル：クロック信号が不安定です。即座の対応が必要です。

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

entity ClockErrorReporter is
    Port ( clk : in STD_LOGIC;
           reset : in STD_LOGIC;
           enable : in STD_LOGIC);
end ClockErrorReporter;

architecture Behavioral of ClockErrorReporter is
    signal clock_counter : INTEGER := 0;
    signal last_enable_state : STD_LOGIC := '0';
    constant EXPECTED_CLOCK_FREQUENCY : INTEGER := 100000000;  -- 100 MHz
    constant CLOCK_TOLERANCE : INTEGER := 1000000;  -- 1 MHz tolerance
begin
    process(clk, reset)
        variable frequency_error : BOOLEAN := false;
        variable enable_error : BOOLEAN := false;
    begin
        if reset = '1' then
            clock_counter <= 0;
            last_enable_state <= '0';
            frequency_error := false;
            enable_error := false;
        elsif rising_edge(clk) then
            clock_counter <= clock_counter + 1;

            -- クロック周波数チェック
            if clock_counter = EXPECTED_CLOCK_FREQUENCY then
                assert abs(clock_counter - EXPECTED_CLOCK_FREQUENCY) <= CLOCK_TOLERANCE
                    report "クロック周波数エラー: 測定値 " & INTEGER'image(clock_counter) & " Hz, 期待値 " & INTEGER'image(EXPECTED_CLOCK_FREQUENCY) & " Hz"
                    severity WARNING;
                frequency_error := abs(clock_counter - EXPECTED_CLOCK_FREQUENCY) > CLOCK_TOLERANCE;
                clock_counter <= 0;
            end if;

            -- enable信号のチェック
            if last_enable_state /= enable then
                assert last_enable_state = '0'
                    report "enable信号の予期せぬ変化を検出しました。"
                    severity NOTE;
                enable_error := last_enable_state = '1';
            end if;
            last_enable_state <= enable;

            -- 複合エラーの報告
            if frequency_error and enable_error then
                assert false
                    report "クリティカル：クロック周波数とenable信号の両方に問題が検出されました。システムの安定性が損なわれている可能性があります。"
                    severity ERROR;
            elsif frequency_error or enable_error then
                assert false
                    report "警告：クロック関連の問題が検出されました。詳細なチェックを推奨します。"
                    severity WARNING;
            end if;
        end if;
    end process;
end Behavioral;

Warning: クロック周波数エラー: 測定値 98000000 Hz, 期待値 100000000 Hz
Note: enable信号の予期せぬ変化を検出しました。
Error: クリティカル：クロック周波数とenable信号の両方に問題が検出されました。システムの安定性が損なわれている可能性があります。

process(clk)
    variable index : integer := 0;
    variable data_array : array (0 to 9) of integer;
begin
    if rising_edge(clk) then
        index := index + 1;
        assert index <= 9 report "配列の範囲外アクセス" severity ERROR;
        data_array(index) := 42;
    end if;
end process;

process(clk)
    variable index : integer := 0;
    variable data_array : array (0 to 9) of integer;
begin
    if rising_edge(clk) then
        if index <= 9 then
            data_array(index) := 42;
            index := index + 1;
        else
            report "配列の範囲外アクセスを防止しました" severity WARNING;
            -- エラー回復処理をここに記述
        end if;
    end if;
end process;

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

entity TimingSimulation is
    Port ( clk : in STD_LOGIC;
           data_in : in STD_LOGIC_VECTOR(7 downto 0);
           data_out : out STD_LOGIC_VECTOR(7 downto 0));
end TimingSimulation;

architecture Behavioral of TimingSimulation is
    signal data_delayed : STD_LOGIC_VECTOR(7 downto 0);
begin
    process(clk)
    begin
        if rising_edge(clk) then
            data_delayed <= data_in after 5 ns;
            data_out <= data_delayed;

            -- タイミング違反の検出
            assert data_delayed'stable(10 ns)
                report "タイミング違反: データが10ns以内に変化しました"
                severity WARNING;
        end if;
    end process;
end Behavioral;

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

package custom_severity_pkg is
    type custom_severity is (MINOR, MAJOR, CRITICAL);

    procedure report_custom(msg : string; sev : custom_severity);
end package;

package body custom_severity_pkg is
    procedure report_custom(msg : string; sev : custom_severity) is
    begin
        case sev is
            when MINOR =>
                report msg severity NOTE;
            when MAJOR =>
                report msg severity WARNING;
            when CRITICAL =>
                report msg severity ERROR;
        end case;
    end procedure;
end package body;

-- 使用例
use work.custom_severity_pkg.all;

entity CustomSeverityExample is
end CustomSeverityExample;

architecture Behavioral of CustomSeverityExample is
begin
    process
    begin
        report_custom("軽微な問題が発生しました", MINOR);
        report_custom("重大な問題が発生しました", MAJOR);
        report_custom("致命的な問題が発生しました", CRITICAL);
        wait;
    end process;
end Behavioral;

Note: 軽微な問題が発生しました
Warning: 重大な問題が発生しました
Error: 致命的な問題が発生しました

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

entity HierarchicalErrorReporting is
end HierarchicalErrorReporting;

architecture Behavioral of HierarchicalErrorReporting is
    type module_id is (CPU, MEMORY, IO);

    procedure report_error(mod : module_id; error_code : integer; msg : string; sev : severity_level) is
    begin
        report "モジュール: " & module_id'image(mod) & 
               ", エラーコード: " & integer'image(error_code) & 
               ", メッセージ: " & msg
               severity sev;
    end procedure;

begin
    process
    begin
        -- CPUモジュールからのエラー報告
        report_error(CPU, 101, "命令実行エラー", ERROR);

        -- メモリモジュールからのエラー報告
        report_error(MEMORY, 201, "メモリアクセス違反", WARNING);

        -- IOモジュールからのエラー報告
        report_error(IO, 301, "デバイス未応答", NOTE);

        wait;
    end process;
end Behavioral;

Error: モジュール: CPU, エラーコード: 101, メッセージ: 命令実行エラー
Warning: モジュール: MEMORY, エラーコード: 201, メッセージ: メモリアクセス違反
Note: モジュール: IO, エラーコード: 301, メッセージ: デバイス未応答

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

entity ArchitectureSpecificAssert is
    generic (
        ARCHITECTURE_TYPE : string := "GENERIC"
    );
end ArchitectureSpecificAssert;

architecture Behavioral of ArchitectureSpecificAssert is
    signal clock_frequency : integer := 100_000_000;  -- 100 MHz
begin
    process
    begin
        case ARCHITECTURE_TYPE is
            when "XILINX" =>
                assert clock_frequency <= 200_000_000
                    report "Xilinxアーキテクチャ: クロック周波数が上限を超えています"
                    severity ERROR;
            when "ALTERA" =>
                assert clock_frequency <= 250_000_000
                    report "Alteraアーキテクチャ: クロック周波数が上限を超えています"
                    severity ERROR;
            when others =>
                assert clock_frequency <= 150_000_000
                    report "一般的なアーキテクチャ: クロック周波数が上限を超えています"
                    severity WARNING;
        end case;
        wait;
    end process;
end Behavioral;

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

entity GeneratedCodeWithSeverity is
    generic (
        DATA_WIDTH : integer := 8;
        ADDR_WIDTH : integer := 4
    );
    Port ( clk : in STD_LOGIC;
           addr : in STD_LOGIC_VECTOR(ADDR_WIDTH-1 downto 0);
           data : in STD_LOGIC_VECTOR(DATA_WIDTH-1 downto 0);
           we : in STD_LOGIC);
end GeneratedCodeWithSeverity;

architecture Behavioral of GeneratedCodeWithSeverity is
    type ram_type is array (0 to 2**ADDR_WIDTH-1) of STD_LOGIC_VECTOR(DATA_WIDTH-1 downto 0);
    signal RAM : ram_type;

    -- 生成されたseverityチェック用の関数
    function check_parameters return boolean is
    begin
        if DATA_WIDTH > 32 then
            report "DATA_WIDTHが32ビットを超えています" severity WARNING;
            return false;
        elsif ADDR_WIDTH > 12 then
            report "ADDR_WIDTHが12ビットを超えています" severity WARNING;
            return false;
        else
            return true;
        end if;
    end function;

    constant PARAMS_OK : boolean := check_parameters;

begin
    process(clk)
    begin
        if rising_edge(clk) then
            assert PARAMS_OK report "パラメータチェックに失敗しました" severity ERROR;

            if we = '1' then
                RAM(to_integer(unsigned(addr))) <= data;

                -- 生成されたデータ整合性チェック
                assert unsigned(addr) < 2**ADDR_WIDTH
                    report "アドレス範囲外アクセス: " & integer'image(to_integer(unsigned(addr)))
                    severity ERROR;
            end if;
        end if;
    end process;
end Behavioral;

Warning: DATA_WIDTHが32ビットを超えています
Error: パラメータチェックに失敗しました