654 lines
26 KiB
VHDL
654 lines
26 KiB
VHDL
library ieee;
|
|
use ieee.std_logic_1164.all;
|
|
use ieee.numeric_std.all;
|
|
|
|
library osvvm; -- Utility Library
|
|
context osvvm.OsvvmContext;
|
|
|
|
use work.rtps_package.all;
|
|
use work.user_config.all;
|
|
use work.rtps_config_package.all;
|
|
use work.rtps_test_package.all;
|
|
|
|
-- This testbench tests the Liveliness Handling of the DDS Writer, and more specifically the DDS GET_LIVELINESS_LOST_STATUS, and ASSERT_LIVELINESS Operations.
|
|
|
|
entity L0_dds_writer_test4_aik is
|
|
end entity;
|
|
|
|
architecture testbench of L0_dds_writer_test4_aik is
|
|
|
|
-- *CONSTANT DECLARATION*
|
|
constant MAX_REMOTE_ENDPOINTS : natural := 3;
|
|
|
|
-- *TYPE DECLARATION*
|
|
type DDS_STAGE_TYPE is (IDLE, START, PUSH, DONE, CHECK, CHECK_LIVELINESS);
|
|
type RTPS_STAGE_TYPE is (IDLE, START, DONE, CHECK);
|
|
|
|
-- *SIGNAL DECLARATION*
|
|
signal clk : std_logic := '0';
|
|
signal reset : std_logic := '1';
|
|
signal check_time : TIME_TYPE := TIME_ZERO;
|
|
signal start_rtps, start_dds, ack_rtps, ack_dds, done_rtps, done_dds : std_logic := '0';
|
|
signal opcode_rtps : HISTORY_CACHE_OPCODE_TYPE := NOP;
|
|
signal opcode_dds : DDS_WRITER_OPCODE_TYPE := NOP;
|
|
signal ret_rtps : HISTORY_CACHE_RESPONSE_TYPE := ERROR;
|
|
signal seq_nr_rtps, cc_seq_nr : SEQUENCENUMBER_TYPE := SEQUENCENUMBER_UNKNOWN;
|
|
signal ready_out_rtps, valid_out_rtps, last_word_out_rtps : std_logic := '0';
|
|
signal ready_in_dds, ready_out_dds, valid_in_dds, valid_out_dds, last_word_in_dds, last_word_out_dds : std_logic := '0';
|
|
signal data_out_rtps, data_in_dds, data_out_dds : std_logic_vector(WORD_WIDTH-1 downto 0) := (others => '0');
|
|
signal get_data_rtps, liveliness_assertion, data_available : std_logic := '0';
|
|
signal cc_source_timestamp, source_ts_dds : TIME_TYPE := TIME_INVALID;
|
|
signal cc_kind : CACHE_CHANGE_KIND_TYPE := ALIVE;
|
|
signal cc_instance_handle, instance_handle_dds : INSTANCE_HANDLE_TYPE := HANDLE_NIL;
|
|
signal max_wait_dds : DURATION_TYPE := DURATION_INFINITE;
|
|
signal return_code_dds : std_logic_vector(RETURN_CODE_WIDTH-1 downto 0) := (others => '0');
|
|
signal status : std_logic_vector(STATUS_KIND_WIDTH-1 downto 0) := (others => '0');
|
|
|
|
signal dds_start, dds_done, rtps_start, rtps_done : std_logic := '0';
|
|
signal dds_cnt, rtps_cnt : natural := 0;
|
|
signal dds_stage : DDS_STAGE_TYPE := IDLE;
|
|
signal rtps_stage : RTPS_STAGE_TYPE := IDLE;
|
|
shared variable dds : DDS_WRITER_TEST_TYPE := DEFAULT_DDS_WRITER_TEST;
|
|
shared variable rtps : RTPS_WRITER_TEST_TYPE := DEFAULT_RTPS_WRITER_TEST;
|
|
signal inst_id, kind_id, sn_id, ts_id, data_id, ret_id, status_id, assert_id : AlertLogIDType;
|
|
|
|
-- *FUNCTION DECLARATION*
|
|
function extract_key_hash (payload : TEST_PACKET_TYPE) return INSTANCE_HANDLE_TYPE is
|
|
variable ret : INSTANCE_HANDLE_TYPE := HANDLE_NIL;
|
|
begin
|
|
for i in 0 to 3 loop
|
|
ret(i) := not payload.data(i);
|
|
end loop;
|
|
|
|
return ret;
|
|
end function;
|
|
|
|
function gen_sn(input : natural) return SEQUENCENUMBER_TYPE is
|
|
variable ret : SEQUENCENUMBER_TYPE;
|
|
begin
|
|
ret(0) := (others => '0');
|
|
ret(1) := unsigned(int(input, WORD_WIDTH));
|
|
return ret;
|
|
end function;
|
|
|
|
begin
|
|
|
|
-- Unit Under Test
|
|
uut : entity work.dds_writer(arch)
|
|
generic map(
|
|
HISTORY_QOS => KEEP_ALL_HISTORY_QOS,
|
|
DEADLINE_QOS => DURATION_INFINITE,
|
|
LIFESPAN_QOS => DURATION_INFINITE,
|
|
LEASE_DURATION => gen_duration(1,0),
|
|
WITH_KEY => TRUE,
|
|
MAX_SAMPLES => std_logic_vector(to_unsigned(4,CDR_LONG_WIDTH)),
|
|
MAX_INSTANCES => std_logic_vector(to_unsigned(3,CDR_LONG_WIDTH)),
|
|
MAX_SAMPLES_PER_INSTANCE => std_logic_vector(to_unsigned(4,CDR_LONG_WIDTH)),
|
|
PAYLOAD_FRAME_SIZE => 11
|
|
)
|
|
port map (
|
|
clk => clk,
|
|
reset => reset,
|
|
time => check_time,
|
|
start_rtps => start_rtps,
|
|
opcode_rtps => opcode_rtps,
|
|
ack_rtps => ack_rtps,
|
|
done_rtps => done_rtps,
|
|
ret_rtps => ret_rtps,
|
|
seq_nr_rtps => seq_nr_rtps,
|
|
get_data_rtps => get_data_rtps,
|
|
data_out_rtps => data_out_rtps,
|
|
valid_out_rtps => valid_out_rtps,
|
|
ready_out_rtps => ready_out_rtps,
|
|
last_word_out_rtps => last_word_out_rtps,
|
|
liveliness_assertion => liveliness_assertion,
|
|
data_available => data_available,
|
|
cc_instance_handle => cc_instance_handle,
|
|
cc_kind => cc_kind,
|
|
cc_source_timestamp => cc_source_timestamp,
|
|
cc_seq_nr => cc_seq_nr,
|
|
start_dds => start_dds,
|
|
ack_dds => ack_dds,
|
|
opcode_dds => opcode_dds,
|
|
instance_handle_dds => instance_handle_dds,
|
|
source_ts_dds => source_ts_dds,
|
|
max_wait_dds => max_wait_dds,
|
|
done_dds => done_dds,
|
|
return_code_dds => return_code_dds,
|
|
ready_in_dds => ready_in_dds,
|
|
valid_in_dds => valid_in_dds,
|
|
data_in_dds => data_in_dds,
|
|
last_word_in_dds => last_word_in_dds,
|
|
ready_out_dds => ready_out_dds,
|
|
valid_out_dds => valid_out_dds,
|
|
data_out_dds => data_out_dds,
|
|
last_word_out_dds => last_word_out_dds,
|
|
status => status
|
|
);
|
|
|
|
stimulus_prc : process
|
|
variable RV : RandomPType;
|
|
variable kh1, kh2, kh3, kh4 : INSTANCE_HANDLE_TYPE := HANDLE_NIL;
|
|
variable cc1, cc2, cc3, cc4, cc : CACHE_CHANGE_TYPE := DEFAULT_CACHE_CHANGE;
|
|
|
|
alias idle_sig is <<signal uut.idle_sig : std_logic>>;
|
|
|
|
impure function gen_payload(key_hash : INSTANCE_HANDLE_TYPE; len : natural) return TEST_PACKET_TYPE is
|
|
variable ret : TEST_PACKET_TYPE := EMPTY_TEST_PACKET;
|
|
begin
|
|
assert (len >= 4) report "Payload length has to be at least 16 Bytes long" severity FAILURE;
|
|
|
|
for i in 0 to len-1 loop
|
|
if (i < 4) then
|
|
-- NOTE: Beginning of payload is negated key to allow deterministic Key Hash generation from the kh_prc
|
|
ret.data(ret.length) := not key_hash(i);
|
|
else
|
|
ret.data(ret.length) := RV.RandSlv(WORD_WIDTH);
|
|
end if;
|
|
ret.length := ret.length + 1;
|
|
end loop;
|
|
ret.last(ret.length-1) := '1';
|
|
|
|
return ret;
|
|
end function;
|
|
|
|
impure function gen_key_hash return KEY_HASH_TYPE is
|
|
variable ret : KEY_HASH_TYPE := (others => (others => '0'));
|
|
begin
|
|
for i in 0 to KEY_HASH_TYPE'length-1 loop
|
|
ret(i) := RV.RandSlv(WORD_WIDTH);
|
|
end loop;
|
|
return ret;
|
|
end function;
|
|
|
|
procedure start_dds is
|
|
begin
|
|
dds_start <= '1';
|
|
wait until rising_edge(clk);
|
|
dds_start <= '0';
|
|
wait until rising_edge(clk);
|
|
end procedure;
|
|
|
|
procedure start_rtps is
|
|
begin
|
|
rtps_start <= '1';
|
|
wait until rising_edge(clk);
|
|
rtps_start <= '0';
|
|
wait until rising_edge(clk);
|
|
end procedure;
|
|
|
|
procedure wait_on_dds is
|
|
begin
|
|
if (dds_done /= '1') then
|
|
wait until dds_done = '1';
|
|
end if;
|
|
end procedure;
|
|
|
|
procedure wait_on_rtps is
|
|
begin
|
|
if (rtps_done /= '1') then
|
|
wait until rtps_done = '1';
|
|
end if;
|
|
end procedure;
|
|
|
|
procedure wait_on_completion is
|
|
begin
|
|
if (rtps_done /= '1' or dds_done /= '1') then
|
|
wait until rtps_done = '1' and dds_done = '1';
|
|
end if;
|
|
end procedure;
|
|
|
|
-- NOTE: This procedure waits until the idle_sig is high for at least
|
|
-- two consecutive clock cycles.
|
|
procedure wait_on_idle is
|
|
begin
|
|
loop
|
|
if (idle_sig /= '1') then
|
|
wait until idle_sig = '1';
|
|
else
|
|
exit;
|
|
end if;
|
|
wait until rising_edge(clk);
|
|
wait until rising_edge(clk);
|
|
end loop;
|
|
end procedure;
|
|
|
|
begin
|
|
|
|
SetAlertLogName("dds_writer - Level 0 - (KEEP ALL, Infinite Lifespan, Keyed) - Liveliness Handling");
|
|
SetAlertEnable(FAILURE, TRUE);
|
|
SetAlertEnable(ERROR, TRUE);
|
|
SetAlertEnable(WARNING, TRUE);
|
|
SetLogEnable(DEBUG, FALSE);
|
|
SetLogEnable(PASSED, FALSE);
|
|
SetLogEnable(INFO, TRUE);
|
|
RV.InitSeed(RV'instance_name);
|
|
inst_id <= GetAlertLogID("Instance", ALERTLOG_BASE_ID);
|
|
kind_id <= GetAlertLogID("Cache Change Kind", ALERTLOG_BASE_ID);
|
|
sn_id <= GetAlertLogID("SequenceNumber", ALERTLOG_BASE_ID);
|
|
ts_id <= GetAlertLogID("TimeStamp", ALERTLOG_BASE_ID);
|
|
data_id <= GetAlertLogID("Data Out", ALERTLOG_BASE_ID);
|
|
ret_id <= GetAlertLogID("Return Code", ALERTLOG_BASE_ID);
|
|
status_id <= GetAlertLogID("Communication Status", ALERTLOG_BASE_ID);
|
|
assert_id <= GetAlertLogID("Assertion Propagation", ALERTLOG_BASE_ID);
|
|
|
|
-- Key Hashes
|
|
kh1 := gen_key_hash;
|
|
kh2 := gen_key_hash;
|
|
kh3 := gen_key_hash;
|
|
kh4 := gen_key_hash;
|
|
|
|
Log("Initiating Test", INFO);
|
|
Log("Current Time: 0s", INFO);
|
|
check_time <= TIME_ZERO;
|
|
reset <= '1';
|
|
wait until rising_edge(clk);
|
|
wait until rising_edge(clk);
|
|
reset <= '0';
|
|
wait_on_idle;
|
|
-- Stored CC: 0, 0, 0, 0
|
|
|
|
AffirmIf(status_id,(status and LIVELINESS_LOST_STATUS) /= LIVELINESS_LOST_STATUS, "Expected: 0", "Received 1");
|
|
|
|
Log("Current Time: 1s", INFO);
|
|
check_time <= gen_duration(1,0);
|
|
wait until rising_edge(clk);
|
|
wait until rising_edge(clk);
|
|
wait_on_idle;
|
|
|
|
AffirmIf(status_id,(status and LIVELINESS_LOST_STATUS) = LIVELINESS_LOST_STATUS, "Expected: 1", "Received 0");
|
|
|
|
Log("DDS Operation GET_LIVELINESS_LOST_STATUS (Expected: count 1, change 1)", INFO);
|
|
dds := DEFAULT_DDS_WRITER_TEST;
|
|
dds.opcode := GET_LIVELINESS_LOST_STATUS;
|
|
dds.ret_code := RETCODE_OK;
|
|
dds.count := 1;
|
|
dds.change := 1;
|
|
start_dds;
|
|
wait_on_dds;
|
|
|
|
wait_on_idle;
|
|
AffirmIf(status_id,(status and LIVELINESS_LOST_STATUS) /= LIVELINESS_LOST_STATUS, "Expected: 0", "Received 1");
|
|
|
|
Log("Current Time: 1.5s", INFO);
|
|
check_time <= gen_duration(1,500);
|
|
wait until rising_edge(clk);
|
|
wait until rising_edge(clk);
|
|
wait_on_idle;
|
|
|
|
AffirmIf(status_id,(status and LIVELINESS_LOST_STATUS) /= LIVELINESS_LOST_STATUS, "Expected: 0", "Received 1");
|
|
|
|
cc := DEFAULT_CACHE_CHANGE;
|
|
cc.serialized_key := FALSE;
|
|
cc.kind := ALIVE;
|
|
cc.instance := kh1;
|
|
cc.payload := gen_payload(kh1,10);
|
|
cc.seq_nr := gen_sn(1);
|
|
|
|
Log("DDS Operation WRITE [Instance 1, HANDLE_NIL, Aligned Payload] (ACCEPTED)", INFO);
|
|
dds := DEFAULT_DDS_WRITER_TEST;
|
|
dds.opcode := WRITE;
|
|
dds.cc := cc;
|
|
dds.cc.instance:= HANDLE_NIL;
|
|
dds.ret_code := RETCODE_OK;
|
|
start_dds;
|
|
wait_on_dds;
|
|
cc1 := cc;
|
|
-- Stored CC: I1S1, 0, 0, 0
|
|
|
|
Log("Current Time: 2s", INFO);
|
|
check_time <= gen_duration(2,0);
|
|
wait until rising_edge(clk);
|
|
wait until rising_edge(clk);
|
|
wait_on_idle;
|
|
|
|
AffirmIf(status_id,(status and LIVELINESS_LOST_STATUS) /= LIVELINESS_LOST_STATUS, "Expected: 0", "Received 1");
|
|
|
|
Log("Current Time: 2.4s", INFO);
|
|
check_time <= gen_duration(2,400);
|
|
wait until rising_edge(clk);
|
|
wait until rising_edge(clk);
|
|
wait_on_idle;
|
|
|
|
AffirmIf(status_id,(status and LIVELINESS_LOST_STATUS) /= LIVELINESS_LOST_STATUS, "Expected: 0", "Received 1");
|
|
|
|
cc := DEFAULT_CACHE_CHANGE;
|
|
cc.serialized_key := TRUE;
|
|
cc.kind := NOT_ALIVE_DISPOSED;
|
|
cc.instance := kh1;
|
|
cc.payload := gen_payload(kh1,5);
|
|
cc.seq_nr := gen_sn(2);
|
|
|
|
Log("DDS Operation DISPOSE [Instance 1] (ACCEPTED)", INFO);
|
|
dds := DEFAULT_DDS_WRITER_TEST;
|
|
dds.opcode := DISPOSE;
|
|
dds.cc := cc;
|
|
dds.ret_code := RETCODE_OK;
|
|
start_dds;
|
|
wait_on_dds;
|
|
cc2 := cc;
|
|
-- Stored CC: I1S1, I1S2, 0, 0
|
|
|
|
Log("Current Time: 3s", INFO);
|
|
check_time <= gen_duration(3,0);
|
|
wait until rising_edge(clk);
|
|
wait until rising_edge(clk);
|
|
wait_on_idle;
|
|
|
|
AffirmIf(status_id,(status and LIVELINESS_LOST_STATUS) /= LIVELINESS_LOST_STATUS, "Expected: 0", "Received 1");
|
|
|
|
Log("Current Time: 3.3s", INFO);
|
|
check_time <= gen_duration(3,300);
|
|
wait until rising_edge(clk);
|
|
wait until rising_edge(clk);
|
|
wait_on_idle;
|
|
|
|
AffirmIf(status_id,(status and LIVELINESS_LOST_STATUS) /= LIVELINESS_LOST_STATUS, "Expected: 0", "Received 1");
|
|
|
|
cc := DEFAULT_CACHE_CHANGE;
|
|
cc.serialized_key := TRUE;
|
|
cc.kind := NOT_ALIVE_UNREGISTERED;
|
|
cc.instance := kh1;
|
|
cc.payload := gen_payload(kh1,5);
|
|
cc.seq_nr := gen_sn(3);
|
|
|
|
Log("DDS Operation UNREGISTER_INSTANCE [Instance 1] (ACCEPTED)", INFO);
|
|
dds := DEFAULT_DDS_WRITER_TEST;
|
|
dds.opcode := UNREGISTER_INSTANCE;
|
|
dds.cc := cc;
|
|
dds.ret_code := RETCODE_OK;
|
|
start_dds;
|
|
wait_on_dds;
|
|
cc3 := cc;
|
|
-- Stored CC: I1S1, I1S2, I1S3, 0
|
|
|
|
Log("Current Time: 4s", INFO);
|
|
check_time <= gen_duration(4,0);
|
|
wait until rising_edge(clk);
|
|
wait until rising_edge(clk);
|
|
wait_on_idle;
|
|
|
|
AffirmIf(status_id,(status and LIVELINESS_LOST_STATUS) /= LIVELINESS_LOST_STATUS, "Expected: 0", "Received 1");
|
|
|
|
Log("Current Time: 5s", INFO);
|
|
check_time <= gen_duration(5,0);
|
|
wait until rising_edge(clk);
|
|
wait until rising_edge(clk);
|
|
wait_on_idle;
|
|
|
|
AffirmIf(status_id,(status and LIVELINESS_LOST_STATUS) = LIVELINESS_LOST_STATUS, "Expected: 1", "Received 0");
|
|
|
|
Log("Current Time: 6s", INFO);
|
|
check_time <= gen_duration(6,0);
|
|
wait until rising_edge(clk);
|
|
wait until rising_edge(clk);
|
|
wait_on_idle;
|
|
|
|
AffirmIf(status_id,(status and LIVELINESS_LOST_STATUS) = LIVELINESS_LOST_STATUS, "Expected: 1", "Received 0");
|
|
|
|
Log("DDS Operation GET_LIVELINESS_LOST_STATUS (Expected: count 3, change 2)", INFO);
|
|
dds := DEFAULT_DDS_WRITER_TEST;
|
|
dds.opcode := GET_LIVELINESS_LOST_STATUS;
|
|
dds.ret_code := RETCODE_OK;
|
|
dds.count := 3;
|
|
dds.change := 2;
|
|
start_dds;
|
|
wait_on_dds;
|
|
|
|
wait_on_idle;
|
|
AffirmIf(status_id,(status and LIVELINESS_LOST_STATUS) /= LIVELINESS_LOST_STATUS, "Expected: 0", "Received 1");
|
|
|
|
Log("Current Time: 6.5s", INFO);
|
|
check_time <= gen_duration(6,500);
|
|
wait until rising_edge(clk);
|
|
wait until rising_edge(clk);
|
|
wait_on_idle;
|
|
|
|
AffirmIf(status_id,(status and LIVELINESS_LOST_STATUS) /= LIVELINESS_LOST_STATUS, "Expected: 0", "Received 1");
|
|
|
|
Log("DDS Operation ASSERT_LIVELINESS (OK)", INFO);
|
|
dds := DEFAULT_DDS_WRITER_TEST;
|
|
dds.opcode := ASSERT_LIVELINESS;
|
|
dds.ret_code := RETCODE_OK;
|
|
dds.assertion := '1';
|
|
start_dds;
|
|
wait_on_dds;
|
|
|
|
Log("Current Time: 7s", INFO);
|
|
check_time <= gen_duration(7,0);
|
|
wait until rising_edge(clk);
|
|
wait until rising_edge(clk);
|
|
wait_on_idle;
|
|
|
|
AffirmIf(status_id,(status and LIVELINESS_LOST_STATUS) /= LIVELINESS_LOST_STATUS, "Expected: 0", "Received 1");
|
|
|
|
wait_on_completion;
|
|
TranscriptOpen(RESULTS_FILE, APPEND_MODE);
|
|
SetTranscriptMirror;
|
|
ReportAlerts;
|
|
TranscriptClose;
|
|
std.env.stop;
|
|
wait;
|
|
end process;
|
|
|
|
clock_prc : process
|
|
begin
|
|
clk <= '0';
|
|
wait for 25 ns;
|
|
clk <= '1';
|
|
wait for 25 ns;
|
|
end process;
|
|
|
|
alert_prc : process(all)
|
|
begin
|
|
if rising_edge(clk) then
|
|
-- TODO
|
|
end if;
|
|
end process;
|
|
|
|
dds_prc : process(all)
|
|
begin
|
|
if rising_edge(clk) then
|
|
dds_done <= '0';
|
|
case (dds_stage) is
|
|
when IDLE =>
|
|
if (dds_start = '1') then
|
|
dds_stage <= START;
|
|
else
|
|
dds_done <= '1';
|
|
end if;
|
|
when START =>
|
|
if (ack_dds = '1') then
|
|
case (dds.opcode) is
|
|
when GET_LIVELINESS_LOST_STATUS =>
|
|
dds_stage <= DONE;
|
|
dds_cnt <= 0;
|
|
when ASSERT_LIVELINESS =>
|
|
dds_stage <= DONE;
|
|
dds_cnt <= 0;
|
|
when others =>
|
|
dds_stage <= PUSH;
|
|
dds_cnt <= 0;
|
|
end case;
|
|
end if;
|
|
when PUSH =>
|
|
if (ready_in_dds = '1') then
|
|
dds_cnt <= dds_cnt + 1;
|
|
if (dds_cnt = dds.cc.payload.length-1) then
|
|
-- DEFAULT
|
|
dds_stage <= DONE;
|
|
|
|
case (dds.opcode) is
|
|
when REGISTER_INSTANCE =>
|
|
dds_stage <= CHECK;
|
|
dds_cnt <= 0;
|
|
when LOOKUP_INSTANCE =>
|
|
dds_stage <= CHECK;
|
|
dds_cnt <= 0;
|
|
when others =>
|
|
null;
|
|
end case;
|
|
end if;
|
|
end if;
|
|
when DONE =>
|
|
if (done_dds = '1') then
|
|
AffirmIfEqual(ret_id, return_code_dds, dds.ret_code);
|
|
case (dds.opcode) is
|
|
when GET_LIVELINESS_LOST_STATUS =>
|
|
if (dds.ret_code = RETCODE_OK) then
|
|
dds_stage <= CHECK_LIVELINESS;
|
|
dds_cnt <= 0;
|
|
else
|
|
dds_stage <= IDLE;
|
|
end if;
|
|
when ASSERT_LIVELINESS =>
|
|
AffirmIfEqual(assert_id, liveliness_assertion, dds.assertion);
|
|
dds_stage <= IDLE;
|
|
when others =>
|
|
dds_stage <= IDLE;
|
|
end case;
|
|
end if;
|
|
when CHECK =>
|
|
if (valid_out_dds = '1') then
|
|
AffirmIfEqual(data_id, data_out_dds, dds.cc.instance(dds_cnt));
|
|
dds_cnt <= dds_cnt + 1;
|
|
if (dds_cnt = 3) then
|
|
AlertIf(data_id, last_word_out_dds /= '1', "Last Word Signal not pulled High", ERROR);
|
|
dds_stage <= IDLE;
|
|
end if;
|
|
end if;
|
|
when CHECK_LIVELINESS =>
|
|
if (valid_out_dds = '1') then
|
|
dds_cnt <= dds_cnt + 1;
|
|
case (dds_cnt) is
|
|
when 0 =>
|
|
AffirmIfEqual(data_id, data_out_dds, std_logic_vector(to_unsigned(dds.count,CDR_LONG_WIDTH)));
|
|
when 1 =>
|
|
AffirmIfEqual(data_id, data_out_dds, std_logic_vector(to_unsigned(dds.change,CDR_LONG_WIDTH)));
|
|
AlertIf(data_id, last_word_out_dds /= '1', "Last Word Signal not pulled High", ERROR);
|
|
dds_stage <= IDLE;
|
|
when others =>
|
|
null;
|
|
end case;
|
|
end if;
|
|
end case;
|
|
end if;
|
|
|
|
-- DEFAULT
|
|
start_dds <= '0';
|
|
opcode_dds <= NOP;
|
|
valid_in_dds <= '0';
|
|
last_word_in_dds <= '0';
|
|
data_in_dds <= (others => '0');
|
|
instance_handle_dds <= HANDLE_NIL;
|
|
source_ts_dds <= TIME_INVALID;
|
|
ready_out_dds <= '0';
|
|
|
|
case (dds_stage) is
|
|
when START =>
|
|
start_dds <= '1';
|
|
opcode_dds <= dds.opcode;
|
|
instance_handle_dds <= dds.cc.instance;
|
|
source_ts_dds <= dds.cc.src_timestamp;
|
|
when PUSH =>
|
|
valid_in_dds <= '1';
|
|
data_in_dds <= dds.cc.payload.data(dds_cnt);
|
|
last_word_in_dds <= dds.cc.payload.last(dds_cnt);
|
|
when CHECK =>
|
|
ready_out_dds <= '1';
|
|
when CHECK_LIVELINESS =>
|
|
ready_out_dds <= '1';
|
|
when others =>
|
|
null;
|
|
end case;
|
|
end process;
|
|
|
|
rtps_prc : process(all)
|
|
begin
|
|
if rising_edge(clk) then
|
|
rtps_done <= '0';
|
|
case (rtps_stage) is
|
|
when IDLE =>
|
|
if (rtps_start = '1') then
|
|
rtps_stage <= START;
|
|
else
|
|
rtps_done <= '1';
|
|
end if;
|
|
when START =>
|
|
if (ack_rtps = '1') then
|
|
rtps_stage <= DONE;
|
|
end if;
|
|
when DONE =>
|
|
if (done_rtps = '1') then
|
|
-- DEFAULT
|
|
rtps_stage <= IDLE;
|
|
|
|
AffirmIfEqual(ret_id, HISTORY_CACHE_RESPONSE_TYPE'pos(ret_rtps), HISTORY_CACHE_RESPONSE_TYPE'pos(rtps.ret_code));
|
|
case (rtps.opcode) is
|
|
when GET_CACHE_CHANGE =>
|
|
if (rtps.ret_code = OK) then
|
|
AffirmIfEqual(inst_id, cc_instance_handle(0), rtps.cc.instance(0));
|
|
AffirmIfEqual(inst_id, cc_instance_handle(1), rtps.cc.instance(1));
|
|
AffirmIfEqual(inst_id, cc_instance_handle(2), rtps.cc.instance(2));
|
|
AffirmIfEqual(inst_id, cc_instance_handle(3), rtps.cc.instance(3));
|
|
AffirmIfEqual(kind_id, CACHE_CHANGE_KIND_TYPE'pos(cc_kind), CACHE_CHANGE_KIND_TYPE'pos(rtps.cc.kind));
|
|
AffirmIfEqual(sn_id, to_unsigned(cc_seq_nr), to_unsigned(rtps.cc.seq_nr));
|
|
AffirmIfEqual(ts_id, to_unsigned(cc_source_timestamp), to_unsigned(rtps.cc.src_timestamp));
|
|
rtps_stage <= CHECK;
|
|
rtps_cnt <= 0;
|
|
end if;
|
|
when GET_MIN_SN =>
|
|
AffirmIfEqual(sn_id, to_unsigned(cc_seq_nr), to_unsigned(rtps.cc.seq_nr));
|
|
when GET_MAX_SN =>
|
|
AffirmIfEqual(sn_id, to_unsigned(cc_seq_nr), to_unsigned(rtps.cc.seq_nr));
|
|
when others =>
|
|
null;
|
|
end case;
|
|
end if;
|
|
when CHECK =>
|
|
if (valid_out_rtps = '1') then
|
|
AffirmIfEqual(data_id, last_word_out_rtps & data_out_rtps, rtps.cc.payload.last(rtps_cnt) & rtps.cc.payload.data(rtps_cnt));
|
|
rtps_cnt <= rtps_cnt + 1;
|
|
if (rtps_cnt = rtps.cc.payload.length-1) then
|
|
rtps_stage <= IDLE;
|
|
end if;
|
|
end if;
|
|
end case;
|
|
end if;
|
|
|
|
-- DEFAULT
|
|
start_rtps <= '0';
|
|
opcode_rtps <= NOP;
|
|
seq_nr_rtps <= SEQUENCENUMBER_UNKNOWN;
|
|
get_data_rtps <= '0';
|
|
ready_out_rtps <= '0';
|
|
|
|
case (rtps_stage) is
|
|
when START =>
|
|
start_rtps <= '1';
|
|
opcode_rtps <= rtps.opcode;
|
|
seq_nr_rtps <= rtps.cc.seq_nr;
|
|
when DONE =>
|
|
if (done_rtps = '1') then
|
|
case (rtps.opcode) is
|
|
when GET_CACHE_CHANGE =>
|
|
get_data_rtps <= '1';
|
|
when others =>
|
|
null;
|
|
end case;
|
|
end if;
|
|
when CHECK =>
|
|
ready_out_rtps <= '1';
|
|
when others =>
|
|
null;
|
|
end case;
|
|
end process;
|
|
|
|
watchdog : process
|
|
begin
|
|
wait for 1 ms;
|
|
Alert("Test timeout", FAILURE);
|
|
std.env.stop;
|
|
end process;
|
|
|
|
end architecture; |