Downloader.pm

#-------------------------------------------------------------------------------
#  University of Applied Sciences Technikum Wien
#
#  Department of Embedded Systems
#  http://embsys.technikum-wien.at
#
#  Josef Ressel Center for Verification of Embedded Computing Systems
#  http://vecs.technikum-wien.at
#
#-------------------------------------------------------------------------------
#  Description:
#  FIJI Downloader class
#-------------------------------------------------------------------------------

## @file Downloader.pm
# @brief Contains class \ref FIJI::Downloader

## @class FIJI::Downloader
# @brief contains functionality to download tests via serial

package FIJI::Downloader;

use strict;
use warnings;

use Log::Log4perl qw(get_logger);
use FIJI::Tests;
use FIJI::Settings;
use FIJI::Connection;
use FIJI qw(:all);
use Clone 'clone';
use threads;
use threads::shared;

# FIXME: fix documentation
## @function public new ($testsname,%$existing_tests,$cfgname,%$existing_cfg)
#
# @param testsname          (optional) Name of a FIJI::Tests configuration file
# @param existing_tests     (optional) Reference to an existing FIJI::Tests object
# @param cfgname            (optional) Name of a FIJI::Settings configuration file
# @param existing_cfg       (optional) Reference to an existing FIJI::Settings object
#
# Either $testsname or $existing_tests must be present
# Either $cfgname or $existing_cfg must be present
sub new(;$$) {
    my $logger = get_logger("");
    my ($class, $mode, $testsname, $existing_tests, $cfgname, $existing_cfg) = @_;
    my $self = {};
    bless $self, $class;
    my $rvt;
    my $rvs;

    if (defined $existing_cfg) {
        $rvs = $self->existing_settings($existing_cfg);
    } elsif (defined $cfgname) {
        $rvs = $self->settings_from_file($cfgname);
    }

    if (!ref $rvs) {
        my $msg = "Constructor of " . $class . " could not obtain a FIJI::Settings object";
        $logger->error($msg);
        return $msg;
    }

    if (defined $existing_tests) {
        $rvt = $self->existing_tests($existing_tests);
    } elsif (defined $testsname) {
        $rvt = $self->tests_from_file($mode, $self->{'fiji_settings'}, $testsname);
    }

    if (!ref $rvt) {
        my $msg = "Constructor of " . $class . " could not obtain a FIJI::Tests object";
        $logger->error($msg);
        return $msg;
    }

    return $self;
}

## @method public settings_from_file ($cfgname)
# @brief read settings from a given file
# @param cfgname the file to read from
# @returns STRING if an error ocurred
# @returns FIJI::Settings object if sucessful
sub settings_from_file {
    my $logger = get_logger("");
    my $rv;
    my ($self, $cfgname) = @_;
    my ($fiji_settings, $warn) = FIJI::Settings->new("download", $cfgname);
    if (!defined($fiji_settings)) {
        $rv = $warn;
    } else {
        $logger->warn($warn) if defined $warn;
        $rv = $self->{'fiji_settings'} = $fiji_settings;
    }
    return $rv;
}

sub existing_settings {
    my $rv;
    my ($self, $existing_cfg) = @_;
    if (ref($existing_cfg) eq "FIJI::Settings") {
        $rv = $self->{'fiji_settings'} = $existing_cfg;
    } else {
        $rv = "Given Settings are not of type FIJI::Settings";
    }
}

## @method public tests_from_file ($mode, %$set_ref, $cfgname)
# @brief read tests from a given file
#
# @param mode           currently active FIJI settings
# @param set_ref        currently active FIJI settings
# @param cfgname        the file to read from
#
# @returns STRING if an error ocurred
# @returns FIJI::Tests object if sucessful
sub tests_from_file {
    my $rv;
    my $logger = get_logger("");
    my ($self, $mode, $set_ref, $cfgname) = @_;
    $logger->info("New Tests for mode '$mode'");
    my ($fiji_tests, $warn) = FIJI::Tests->new($mode, $set_ref, $cfgname);
    if (!ref($fiji_tests)) {
        $rv = $warn;
    } else {
        $rv = $self->{'fiji_tests'} = $fiji_tests;
    }
    return $rv;
}

sub existing_tests {
    my $rv;
    my ($self, $existing_tests) = @_;
    if (ref($existing_tests) eq "FIJI::Tests") {
        $rv = $self->{'fiji_tests'} = $existing_tests;
    } else {
        $rv = "Given Tests are not of type FIJI::Tests";
    }
}

## @method public download_auto ($$run_ref, %$$testref, $portname, &$intermediate_cb)
# @brief Download tests contained in the .cfg file
#
# @param run_ref            a reference to a boolean indicating that no abort is requested (yet).
# @param testref            (optional) reference (to a HASH REF) where this function shall put the
#                           executed tests
# @param portname           (optional) serial port to use
# @param intermediate_cb    (optional) reference to a function to call after each test
# @returns STRING if an error occurred
# @returns HASH containing the last received message if successfully sent
sub download_auto ($) {
    my $msg;
    my $logger = get_logger("");
    my ($self, $run_ref, $testref, $portname, $intermediate_cb) = @_;

    my $fiji_tests         = $self->{'fiji_tests'};
    my $fiji_design_consts = $self->{'fiji_settings'}->{'design'};

    my @tests;

    if (!defined $intermediate_cb) {
        $intermediate_cb = sub { return 1; };
    }

    $portname = $fiji_tests->{'design'}->{'UART'} if (!defined $portname);
    my $port = FIJI::Connection->init($portname, $fiji_design_consts->{'BAUDRATE'})
      or $logger->fatal("Could not init UART.")
      and return "Could not init UART.";

    my $toff = 0;
    my $ri   = 0;
    my $halt;

    $logger->info("Downloading in auto mode.");

    my $recv_msg;
    my $ti;

    # download tests until halted
    while (1) {
        for ($ti = $toff ; $ti < @{$fiji_tests->{'tests'}} ; $ti++) {

            $logger->info("Downloading test $ti.");

            $recv_msg = $self->_download_test($run_ref, @{$fiji_tests->{'tests'}}[$ti], $port, 0);

            return $recv_msg if (ref($recv_msg) ne "HASH");

            push @tests, @{$fiji_tests->{'tests'}}[$ti];

            my $check = $self->_check_halt($recv_msg);

            if (@{$check}) {
                $logger->error("Halt because of " . join(" and ", @{$check}) . ". Failed test: $ti, repetition $ri.");
                goto END;
            }

            if (&$intermediate_cb($recv_msg) == 0) {
                $logger->info("Fulfilling halt request after test: $ti, repetition $ri.");
                goto END;
            }

        }

        # @FIXME Repeat information comes from tests config file. OK?
        if ($fiji_tests->{'design'}->{'REPEAT'} == 0) {
            last;
        } else {
            $toff = $fiji_tests->{'design'}->{'REPEAT_OFFSET'};
            $logger->info("Repeat tests beginning with $toff.");
            $ri++;
        }
    }

  END:
    $$testref                                = clone($self->{'fiji_tests'});
    $$testref->{'design'}->{'NUM_TESTS'}     = $ti;
    $$testref->{'design'}->{'REPEAT'}        = 0;
    $$testref->{'design'}->{'REPEAT_OFFSET'} = 0;
    # We make sure that the returned tests reference is pointing to
    # shareable objects only if the reference itself is already shared.
    # This makes things easier for multithreaded applications like the EE GUI.
    if (is_shared($$testref)) {
        $$testref->{'tests'} = shared_clone(\@tests);
    } else {
        $$testref->{'tests'} = \@tests;
    }

    return $recv_msg;
}

## @method public download_auto (%$testref, $portname, &$intermediate_cb)
# @brief Download randomly generated tests
#
# \param run_ref            a reference to a boolean indicating that no abort is requested (yet).
# @param testref            (optional) reference where this function shall put the
#                           executed tests
# @param portname           (optional) serial port to use
# @param intermediate_cb    (optional) reference to a function to call after each test
# @returns STRING if an error occurred
# @returns HASH containing the last received message if successfully sent
sub download_random ($$$;$) {
    my $logger = get_logger("");
    my ($self, $run_ref, $testref, $portname, $intermediate_cb) = @_;
    my $fiji_design_consts = $self->{'fiji_settings'}->{'design'};
    my $fiji_tests_consts = $self->{'fiji_tests'}->{'design'};

    $portname = $fiji_tests_consts->{'UART'} if (!defined $portname);

    if (!defined $intermediate_cb) {
        $intermediate_cb = sub { return 1; };
    }

    my $port = FIJI::Connection->init($portname, $fiji_design_consts->{'BAUDRATE'})
      or $logger->fatal("Could not init UART.")
      and return "Could not init UART.";

    $logger->info("Downloading in random mode.");
    my @tests;
    my $ti = 0;
    my $recv_msg;
    my $check = 0;
    my $cont;

    do {
        my $temp_test = $self->{'fiji_tests'}->make_random_test($self->{'fiji_settings'}, ($ti == 0));
        return $temp_test if (!ref($temp_test));
        $tests[$ti] = $temp_test;
        $logger->info("=== Test $ti ===");
        $recv_msg = $self->_download_test($run_ref, $tests[$ti++], $port, 0);
        return $recv_msg if (ref($recv_msg) ne "HASH");
        $check = $self->_check_halt($recv_msg);
        $cont  = &$intermediate_cb($recv_msg);
    } while (@{$check} == 0 && $cont != 0);

    $logger->error("Halt because of " . join(" and ", @{$check}) . ". Failed test: " . ($ti - 1)) if @{$check};
    $logger->info("Fulfilling halt request after test: " . ($ti - 1)) if $cont == 0;

    $$testref                                = clone($self->{'fiji_tests'});
    $$testref->{'design'}->{'NUM_TESTS'}     = $ti;
    $$testref->{'design'}->{'REPEAT'}        = 0;
    $$testref->{'design'}->{'REPEAT_OFFSET'} = 0;
    if (is_shared($$testref)) {
        $$testref->{'tests'} = shared_clone(\@tests);
    } else {
        $$testref->{'tests'} = \@tests;
    }

    return $recv_msg;
}

## @method download_manual
# @brief Download manually defined tests prompted from <STDIN>
#
# @param run_ref   a reference to a boolean indicating that no abort is requested (yet).
# @param portname  (optional) the serial port to use
sub download_manual ($;$) {
    my $msg;
    my $logger = get_logger("");

    my ($self, $run_ref, $portname) = @_;

    my $fiji_design_consts = $self->{'fiji_settings'}->{'design'};
    my $fiji_tests_consts = $self->{'fiji_tests'}->{'design'};

    $portname = $fiji_tests_consts->{'UART'} if (!defined $portname);

    my $port = FIJI::Connection->init($portname, $fiji_design_consts->{'BAUDRATE'})
      or $logger->fatal("Could not init UART.")
      and return "Could not init UART.";

    $logger->info("Downloading in manual mode.");

    while (1) {

        my $test = $self->_get_test_from_stdin();
        my $recv_msg = $self->_download_test($run_ref, $test, $port, 0);

        return $recv_msg if (ref($recv_msg) ne "HASH");

        if (@{$self->_check_halt($recv_msg)}) {
            $msg = "Halt because of " . join(' and ', @{$self->_check_halt($recv_msg)});
            return $msg;
        }

    }

    return $msg;
}

## @method _get_test_from_stdin ()
# @brief Prompt tests from \<STDIN\>
sub _get_test_from_stdin {
    my $logger = get_logger("");
    my ($self) = @_;

    my $fiji_design_consts = $self->{'fiji_settings'}->{'design'};
    my $test               = {};

    my $cfg_mask    = 2**$fiji_design_consts->{'FIU_CFG_BITS'} - 1;
    my $default_cfg = $cfg_mask;

    for (my $i = 0 ; $i < $fiji_design_consts->{'FIU_NUM'} ; $i++) {
        for (my $t = 1 ; $t <= $fiji_design_consts->{'CFGS_PER_MSG'} ; $t++) {
            my $phase = ($t < $fiji_design_consts->{'CFGS_PER_MSG'}) ? "in t".($t+1) : "after t$t";
            printf("Enter configuration for FIU #%d %s (default: 0x%x): ", $i, $phase, $default_cfg);

            my $cfg_str = <STDIN>;
            last unless defined $cfg_str;
            $cfg_str =~ s/\R//g;    # remove line breaks globally
                                    # $cfg_str =~ s/^0x//i; # remove optional 0x prefix
                                    # if ($cfg_str !~ m/^[0-9A-F]+$|^$/i) {
                                    # printf("This is not hexadecimal.\n");
                                    # next;
                                    # }
            my $cur_cfg = (length($cfg_str) == 0) ? $default_cfg : $cfg_str;
            $cur_cfg = oct($cur_cfg) if $cur_cfg =~ /^0/;
            $logger->debug(sprintf("Configuration of FIU #%d %s is 0x%x.", $i, $phase, $cur_cfg));
            $test->{"FIU_${i}_FAULT_${t}"} = REVERSE_FIU_ENUM($cur_cfg);
        }
    }

    # default t1 is maximum/2
    my $default_t1_dur =
      oct("0x" . ("FF" x ($fiji_design_consts->{'TIMER_WIDTH'} / 8))) / 2;
    printf("Enter duration t1 (default: 0x%x): ", $default_t1_dur);
    $test->{'TIMER_VALUE_1'} = <STDIN>;
    last unless defined $test->{'TIMER_VALUE_1'};
    $test->{'TIMER_VALUE_1'} =~ s/\R//g;    # remove line breaks globally
    $test->{'TIMER_VALUE_1'} =
      int((length($test->{'TIMER_VALUE_1'}) == 0) ? $default_t1_dur : $test->{'TIMER_VALUE_1'});
    $test->{'TIMER_VALUE_1'} = oct($test->{'TIMER_VALUE_1'}) if $test->{'TIMER_VALUE_1'} =~ /^0/;
    $logger->debug(sprintf("t1 duration is %d (0x%x).", $test->{'TIMER_VALUE_1'}, $test->{'TIMER_VALUE_1'}));

    # default t2 duration to maximum/2
    my $default_t2_dur =
      oct("0x" . ("FF" x ($fiji_design_consts->{'TIMER_WIDTH'} / 8))) / 2;
    printf("Enter duration t2 (default: 0x%x): ", $default_t2_dur);
    $test->{'TIMER_VALUE_2'} = <STDIN>;
    last unless defined $test->{'TIMER_VALUE_2'};
    $test->{'TIMER_VALUE_2'} =~ s/\R//g;    # remove line breaks globally
    $test->{'TIMER_VALUE_2'} =
      int((length($test->{'TIMER_VALUE_2'}) == 0) ? $default_t2_dur : $test->{'TIMER_VALUE_2'});
    $test->{'TIMER_VALUE_2'} = oct($test->{'TIMER_VALUE_2'}) if $test->{'TIMER_VALUE_2'} =~ /^0/;
    $logger->debug(sprintf("t2 duration is %d (0x%x).", $test->{'TIMER_VALUE_2'}, $test->{'TIMER_VALUE_2'}));

    printf("Enable trigger (default: 0)? ");
    my $trigger_en = <STDIN>;
    last unless defined $trigger_en;
    $trigger_en =~ s/\R//g;                 # remove line breaks globally
    $trigger_en = ($trigger_en =~ /1|yes|y/i) ? 1 : 0;
    $logger->debug(sprintf("trigger is %sabled.", $trigger_en == 0 ? "dis" : "en"));

    my $trigger_ext = 0;
    if ($trigger_en) {
        printf("Use external/not internal trigger (default: 0)? ");
        $trigger_ext = <STDIN>;
        last unless defined $trigger_ext;
        $trigger_ext =~ s/\R//g;            # remove line breaks globally
        $trigger_ext = ($trigger_ext =~ /1|yes|y/i) ? 1 : 0;
        $logger->debug(sprintf("External trigger is %sabled, internal trigger is %sabled.", $trigger_ext == 0 ? "dis" : "en", $trigger_ext != 0 ? "dis" : "en"));
        if ($trigger_ext == 1) {
            $test->{'TRIGGER'} = "EXT";
        } else {
            $test->{'TRIGGER'} = "INT";
        }
    } else {
        $test->{'TRIGGER'} = "NONE";
    }

    printf("Enable reset (default: 0)? ");
    $test->{'RST_DUT_AFTER_CFG'} = <STDIN>;
    last unless defined $test->{'RST_DUT_AFTER_CFG'};
    $test->{'RST_DUT_AFTER_CFG'} =~ s/\R//g;    # remove line breaks globally
    $test->{'RST_DUT_AFTER_CFG'} = ($test->{'RST_DUT_AFTER_CFG'} =~ /1|yes|y/i) ? 1 : 0;
    $logger->debug(sprintf("reset is %sabled.", $test->{'RST_DUT_AFTER_CFG'} == 0 ? "dis" : "en"));

    return $test;
}

sub get_fic_status ($$) {
    my $logger = get_logger("");
    my ($self, $run_ref, $portname) = @_;

    # generate empty test
    my $test = {};
    $self->{'fiji_tests'}->set_test_defaults($test);

    my $port = FIJI::Connection->init($portname, $self->{'fiji_settings'}->{'design'}->{'BAUDRATE'})
      or $logger->fatal("Could not init UART.")
      and return "Could not init UART.";
    return $self->_download_test($run_ref, $test, $port, 1);
}

## @method public download_test (%$test, $portname)
# @brief Download a single test defined by a test hash
# @param test       the hash describing the test
# @param portname   the name of the serial port to use
# @returns STRING if an error ocurred
# @returns HASH   returned by _test_fi_uart() containing the decoded return message
sub download_test ($$) {
    my $logger = get_logger("");
    my ($self, $run_ref, $test, $portname) = @_;

    my $port = FIJI::Connection->init($portname, $self->{'fiji_settings'}->{'design'}->{'BAUDRATE'})
      or $logger->fatal("Could not init UART.")
      and return "Could not init UART.";

    return $self->_download_test($run_ref, $test, $port, 0);
}

sub update_dur($) {
    my $logger = get_logger("");
    my ($self, $dur) = @_;
    my $rv;
    for my $k (grep {defined $dur->{$_}} keys(%{$dur})) {
        if ($dur->{$k} < 0 || $dur->{$k} >= 2**($self->{'fiji_settings'}->{'design'}->{'TIMER_WIDTH'}*8)) {
            return "Invalid timer value $k: ".($dur->{$k}).". Must be >= 0 && < 2^".($self->{'fiji_settings'}->{'design'}->{'TIMER_WIDTH'}*8);
        } else {
            $logger->info("Duration $k set to ".$dur->{$k});
            $self->{'fiji_tests'}->{'design'}->{$k} = $dur->{$k};
        }
    }
    return undef;
}

sub update_prob($) {
    my $logger = get_logger("");
    my ($self, $rnd) = @_;
    my $prob = {};
    my $sum  = 0;
    for my $k (keys(%{$rnd})) {
        $prob->{$k} = $rnd->{$k};
        $prob->{$k} = $self->{'fiji_tests'}->{'design'}->{$k} if (!defined $prob->{$k});
        $sum += $prob->{$k};    
        $logger->info("Probability $k set to ".$prob->{$k});
    }
    return "Sum of probabilities larger than 1." if $sum > 1.0;

    for my $k (keys(%{$prob})) {
        $self->{'fiji_tests'}->{'design'}->{$k} = $prob->{$k};
    }
    return undef;
}

## @method private _download_test (%$test, $port)
# @brief Download a single test defined by a test hash
#
# \param run_ref   a reference to a boolean indicating that no abort is requested (yet).
# @param test The hash defining the test
#                - test->{'TIMER_VALUE_1'}
#                - test->{'TIMER_VALUE_2'}
#                - test->{"FIU_[0..FIU_NUM]_FAULT_[0..CFGS_PER_MSG]"}
#                - test->{'RST_DUT_AFTER_CFG'}
#                - test->{'TRIGGER'}
# @param port (optional) serial port to use
sub _download_test {
    my $logger = get_logger("");
    my ($self, $run_ref, $test, $port, $dryrun, $block_till_ready, $wait_for_ready) = @_;

    $dryrun = 0 if !defined $dryrun;

    my $fiji_design_consts = $self->{'fiji_settings'}->{'design'};
    my @payload;

    # first generate FIU configuration payload

    for (my $i = 0 ; $i < $fiji_design_consts->{'FIU_NUM'} ; $i++) {
        for (my $t = 1 ; $t <= $fiji_design_consts->{'CFGS_PER_MSG'} ; $t++) {
            my $k       = "FIU_${i}_FAULT_${t}";
            my $cur_cfg = FIUENUM->{$test->{$k}};
            $cur_cfg = oct($cur_cfg) if $cur_cfg =~ /^0/;
            $logger->debug(sprintf("Configuration of FIU #%d in t%d is 0x%x.", $i, $t, $cur_cfg));
            push(@payload, $cur_cfg);
        }
    }

    # then generate fixed configuration part (timers,trigger,reset)

    my $t1_duration = $test->{'TIMER_VALUE_1'};
    $logger->debug(sprintf("t1 duration is %d (0x%x).", $t1_duration, $t1_duration));

    my $t2_duration = $test->{'TIMER_VALUE_2'};
    $logger->debug(sprintf("t2 duration is %d (0x%x).", $t2_duration, $t2_duration));

    my $trigger_en  = ($test->{'TRIGGER'} ne "NONE") ? 1 : 0;
    my $trigger_ext = ($test->{'TRIGGER'} eq "EXT")  ? 1 : 0;
    my $reset       = $test->{'RST_DUT_AFTER_CFG'};

    $logger->debug(sprintf("trigger is %sabled.", $trigger_en == 0 ? "dis" : "en"));
    if ($trigger_en == 1) {
        $logger->debug(sprintf("External trigger is %sabled, internal trigger is %sabled.", $trigger_ext == 0 ? "dis" : "en", $trigger_ext != 0 ? "dis" : "en"));
    }

    $logger->debug(sprintf("reset is %sabled.", $reset == 0 ? "dis" : "en"));

    # Default to NOT block before communication but to wait afterwards
    $block_till_ready = 0 if !ref($block_till_ready);
    $wait_for_ready = 1 if !ref($wait_for_ready);

    $logger->trace("dryrun = $dryrun, block_till_ready = $block_till_ready, wait_for_ready = $wait_for_ready");
    # my @payload = map hex($_), $cfg_str =~ /(..)/g; # @TODO: how to do this with unpack?
    my %config = (
        payload     => \@payload,
        t1_duration => $t1_duration,
        t2_duration => $t2_duration,
        trigger_en  => $trigger_en,
        trigger_ext => $trigger_ext,
        reset       => $reset,
        consts      => $fiji_design_consts,
        dryrun      => $dryrun,
    );

    # Download test via serial
    my $recv_msg = $port->send_config(\%config, $run_ref, $block_till_ready, $wait_for_ready);
    if (ref($recv_msg) eq "HASH" && defined($recv_msg->{'msg_type'})) {
        my $log_msg = "Received " . $recv_msg->{'msg_type'} . " message";
        $log_msg .= sprintf(": U=%d, I=%d, C=%d, F1=%d, F2=%d,", $recv_msg->{'error'}->{'U'}, $recv_msg->{'error'}->{'I'}, $recv_msg->{'error'}->{'C'}, $recv_msg->{'fault_detect'}->{'1'}, $recv_msg->{'fault_detect'}->{'2'}) if (defined($recv_msg->{'error'}));
        $logger->info($log_msg);
    }
    return $recv_msg;
}

## @method private _check_halt (%$recv_msg)
# @brief Check the hash returned by _test_fi_uart() against HALT_ON_xxx-conditions
# @param recv_msg The hash returned by _test_fi_uart() containing the decoded
#                 return message
# @returns reference to list of reasons if execution shall be halted
# @returns reference to empty list otherwise
sub _check_halt ($) {
    my $logger = get_logger("");
    my ($self, $recv_msg) = @_;
    my $reasons    = [];
    my $fiji_tests = $self->{'fiji_tests'};

    # NB: HALT_on_xxx information is defined in tests config file but
    # is not setable by any UI. If need be it can be hardcoded in the .ini

    if ($recv_msg->{'msg_type'} eq "UNDERRUN") {
        $logger->info("UNDERRUN message received. HALT_ON_UNDERRUN = " . $fiji_tests->{'design'}->{'HALT_ON_UNDERRUN'} . ".");
        push @{$reasons}, 'HALT_ON_UNDERRUN' if $fiji_tests->{'design'}->{'HALT_ON_UNDERRUN'};
    }
    if ($recv_msg->{'underrun_occurred'}) {
        $logger->info("UNDERRUN occurred. HALT_ON_UNDERRUN = " . $fiji_tests->{'design'}->{'HALT_ON_UNDERRUN'} . ".");
        push @{$reasons}, 'HALT_ON_UNDERRUN' if $fiji_tests->{'design'}->{'HALT_ON_UNDERRUN'};
    }
    if ($recv_msg->{'error'}->{'U'}) {
        $logger->info("UART error. HALT_ON_UART_ERROR = " . $fiji_tests->{'design'}->{'HALT_ON_UART_ERROR'} . ".");
        push @{$reasons}, 'HALT_ON_UART_ERROR' if $fiji_tests->{'design'}->{'HALT_ON_UART_ERROR'};
    }
    if ($recv_msg->{'error'}->{'I'}) {
        $logger->info("ID error. HALT_ON_ID_ERROR = " . $fiji_tests->{'design'}->{'HALT_ON_ID_ERROR'} . ".");
        push @{$reasons}, 'HALT_ON_ID_ERROR' if $fiji_tests->{'design'}->{'HALT_ON_ID_ERROR'};
    }
    if ($recv_msg->{'error'}->{'C'}) {
        $logger->info("CRC error. HALT_ON_CRC_ERROR = " . $fiji_tests->{'design'}->{'HALT_ON_CRC_ERROR'} . ".");
        push @{$reasons}, 'HALT_ON_CRC_ERROR' if $fiji_tests->{'design'}->{'HALT_ON_CRC_ERROR'};
    }
    for my $ei (1 .. 2) {
        if ($recv_msg->{'fault_detect'}->{$ei}) {
            $logger->info("FAULT detected (Bit $ei). HALT_ON_FAULT_DETECT = " . $fiji_tests->{'design'}->{'HALT_ON_FAULT_DETECT'} . ".");
            push @{$reasons}, "HALT_ON_FAULT_DETECT($ei)" if $fiji_tests->{'design'}->{'HALT_ON_FAULT_DETECT'};
        }
    }

    return $reasons;
}

1;