summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--cesar/ce/fcall/test/src/test_fcall.c3
-rw-r--r--cesar/ce/rx/bitloading/src/transition.c124
-rw-r--r--cesar/ce/rx/bitloading/test/intervals/Config1
-rw-r--r--cesar/ce/rx/bitloading/test/intervals/Makefile22
-rw-r--r--cesar/ce/rx/bitloading/test/intervals/inc/scenario_defs.h114
-rw-r--r--cesar/ce/rx/bitloading/test/intervals/override/ce/rx/bitloading/nsr.h48
-rw-r--r--cesar/ce/rx/bitloading/test/intervals/override/cyg/kernel/kapi.h21
-rw-r--r--cesar/ce/rx/bitloading/test/intervals/src/scenario_intervals_actions.c40
-rw-r--r--cesar/ce/rx/bitloading/test/intervals/src/scenario_intervals_events.c170
-rw-r--r--cesar/ce/rx/bitloading/test/intervals/src/test_intervals_fsm.c755
-rw-r--r--cesar/ce/rx/bitloading/test/src/scenario_events.c5
-rw-r--r--cesar/ce/rx/bitloading/test/src/test_ber_margin_update.c4
-rw-r--r--cesar/ce/rx/bitloading/test/src/test_bl.c4
-rw-r--r--cesar/ce/rx/bitloading/test/src/test_fsm.c4
-rw-r--r--cesar/ce/rx/bitloading/test/src/test_intervals.c3
-rw-r--r--cesar/ce/rx/bitloading/test/src/test_pber.c3
-rw-r--r--cesar/ce/rx/bitloading/test/src/test_poly.c4
-rw-r--r--cesar/ce/rx/cp/stub/src/cp.c9
-rw-r--r--cesar/ce/rx/inc/trace.h3
-rw-r--r--cesar/ce/rx/src/trace.c6
20 files changed, 1316 insertions, 27 deletions
diff --git a/cesar/ce/fcall/test/src/test_fcall.c b/cesar/ce/fcall/test/src/test_fcall.c
index e73e342782..9858ea9174 100644
--- a/cesar/ce/fcall/test/src/test_fcall.c
+++ b/cesar/ce/fcall/test/src/test_fcall.c
@@ -17,6 +17,7 @@
#include "ce/fcall/fcall.h"
#include "ce/fcall/inc/fcall.h"
#include "ce/fcall/test/inc/margin.h"
+#include "ce/rx/rx.h"
#include "ce/rx/bitloading/inc/nsr.h"
#include "ce/rx/bitloading/inc/ber.h"
#include "ce/rx/ce_rx_param.h"
@@ -28,6 +29,8 @@
uint test_ce_fcall_margin_value;
u64 test_ce_fcall_ber_margin_value[PHY_FEC_RATE_NB];
+ce_rx_behavior_t ce_rx_behavior = CE_RX_BEHAVIOR_INTERVALS_DISABLE;
+
void
test_suite_ce_fcall (test_t t)
{
diff --git a/cesar/ce/rx/bitloading/src/transition.c b/cesar/ce/rx/bitloading/src/transition.c
index 51fae8bab3..7742f274f2 100644
--- a/cesar/ce/rx/bitloading/src/transition.c
+++ b/cesar/ce/rx/bitloading/src/transition.c
@@ -579,8 +579,14 @@ ce_rx_bl_fsm__INTERVAL_TRACKING__interval_sound (
sta_t *sta,
ce_rx_bitloading_fsm_event_param_t data)
{
- /* TODO, we should not execute this for the moment. */
- dbg_assert_default ();
+ /* We didn't requested sound on this interval so we reset the interval in
+ * order to be synchronized with remote station. */
+ ce_rx_bl_intervals_reset (ce_rx, sta, data.measure->fsm_id);
+ ce_rx_bl__common_sound_measure_received (ce_rx,
+ sta,
+ data.measure,
+ true);
+
return ce_rx_bl_fsm_next (INTERVAL_TRACKING, interval_sound);
}
@@ -590,8 +596,7 @@ ce_rx_bl_fsm__INTERVAL_TRACKING__interval_sound_completed (
sta_t *sta,
ce_rx_bitloading_fsm_event_param_t data)
{
- /* TODO, we should not execute this for the moment. */
- dbg_assert_default ();
+ /* As in global FSM, we may have several sound completed, let's ignore it. */
return ce_rx_bl_fsm_next (INTERVAL_TRACKING, interval_sound_completed);
}
@@ -601,17 +606,78 @@ ce_rx_bl_fsm__INTERVAL_TRACKING__interval_data (
sta_t *sta,
ce_rx_bitloading_fsm_event_param_t data)
{
- /* TODO, we should not execute this for the moment. */
- dbg_assert_default ();
- return ce_rx_bl_fsm_next_branch (INTERVAL_TRACKING,
- interval_data,
- no_channel_change);
- return ce_rx_bl_fsm_next_branch (INTERVAL_TRACKING,
- interval_data,
- pb_err_rate_high);
- return ce_rx_bl_fsm_next_branch (INTERVAL_TRACKING,
- interval_data,
- ber_too_low);
+ dbg_assert (sta);
+ dbg_assert (sta->intervals);
+ dbg_assert (data.measure);
+
+ u8 fsm_id = data.measure->fsm_id;
+ ce_rx_bitloading_t *bl = sta->intervals->intervals[fsm_id];
+
+ switch (ce_rx_bl_data_treatment (ce_rx, sta, bl, data.measure,
+ sta->intervals->tmi[fsm_id]))
+ {
+ case CE_RX_BL_TREATMENT_STATUS_NO_CHAN_CHANGE:
+ ce_debug_gpio_event (
+ CE_DEBUG_GPIO_EVENT_CE_RX_BL_MEASURE_DATA_NORMAL, true);
+ return ce_rx_bl_fsm_next_branch (INTERVAL_TRACKING,
+ interval_data,
+ no_channel_change);
+ break;
+
+ case CE_RX_BL_TREATMENT_STATUS_HIGH_PBERR:
+ ce_debug_gpio_event (
+ CE_DEBUG_GPIO_EVENT_CE_RX_BL_MEASURE_DATA_HIGH_PB_ERROR_RATE,
+ true);
+ CE_RX_TRACE (INTERVAL_DATA_PB_ERR, sta->tei,
+ data.measure->interval);
+ ce_rx_bl_stats_update (bl, sta,
+ CE_RX_BL_RESTART_REASON_PBERR_HIGH);
+
+ /* Reset PBER. */
+ ce_rx_bl_pber_reset (&bl->pber);
+ /* Reset BER margin update. */
+ ce_rx_bl_bmu_reset (&bl->bmu);
+ /* Reset intervals. */
+ ce_rx_bl_intervals_reset (ce_rx, sta, fsm_id);
+
+ return ce_rx_bl_fsm_next_branch (INTERVAL_TRACKING,
+ interval_data,
+ pb_err_rate_high);
+ break;
+
+ case CE_RX_BL_TREATMENT_STATUS_BER_TOO_LOW:
+ ce_debug_gpio_event (
+ CE_DEBUG_GPIO_EVENT_CE_RX_BL_MEASURE_DATA_BER_LOW,
+ true);
+ CE_RX_TRACE (INTERVAL_DATA_BER, sta->tei,
+ data.measure->interval);
+ ce_rx_bl_stats_update (bl, sta,
+ CE_RX_BL_RESTART_REASON_BER_LOW);
+
+ /* Reset PBER. */
+ ce_rx_bl_pber_reset (&bl->pber);
+ /* Reset BER margin update. */
+ ce_rx_bl_bmu_reset (&bl->bmu);
+ /* Reset intervals. */
+ ce_rx_bl_intervals_reset (ce_rx, sta, fsm_id);
+
+ return ce_rx_bl_fsm_next_branch (INTERVAL_TRACKING,
+ interval_data,
+ ber_too_low);
+ break;
+
+ case CE_RX_BL_TREATMENT_STATUS_BMU:
+ ce_rx_bl_stats_update (bl, sta,
+ CE_RX_BL_RESTART_REASON_BER_MARGIN_UPDATE);
+
+ /* Reset intervals. */
+ ce_rx_bl_intervals_reset (ce_rx, sta, fsm_id);
+ return ce_rx_bl_fsm_next_branch (INTERVAL_TRACKING,
+ interval_data,
+ ber_margin_update);
+ default:
+ dbg_assert_default ();
+ }
}
ce_rx_bl_fsm_branch_t
@@ -620,8 +686,10 @@ ce_rx_bl_fsm__INTERVAL_SOUND__interval_sound (
sta_t *sta,
ce_rx_bitloading_fsm_event_param_t data)
{
- /* TODO, we should not execute this for the moment. */
- dbg_assert_default ();
+ ce_rx_bl__common_sound_measure_received (ce_rx,
+ sta,
+ data.measure,
+ false);
return ce_rx_bl_fsm_next (INTERVAL_SOUND, interval_sound);
}
@@ -631,8 +699,10 @@ ce_rx_bl_fsm__INTERVAL_SOUND__interval_sound_completed (
sta_t *sta,
ce_rx_bitloading_fsm_event_param_t data)
{
- /* TODO, we should not execute this for the moment. */
- dbg_assert_default ();
+ ce_rx_bl__common_sound_measure_received (ce_rx,
+ sta,
+ data.measure,
+ false);
return ce_rx_bl_fsm_next (INTERVAL_SOUND, interval_sound_completed);
}
@@ -642,8 +712,6 @@ ce_rx_bl_fsm__INTERVAL_SOUND__interval_data (
sta_t *sta,
ce_rx_bitloading_fsm_event_param_t data)
{
- /* TODO, we should not execute this for the moment. */
- dbg_assert_default ();
return ce_rx_bl_fsm_next (INTERVAL_SOUND, interval_data);
}
@@ -653,8 +721,10 @@ ce_rx_bl_fsm__INTERVAL_SOUND_WAIT__interval_sound (
sta_t *sta,
ce_rx_bitloading_fsm_event_param_t data)
{
- /* TODO, we should not execute this for the moment. */
- dbg_assert_default ();
+ ce_rx_bl__common_sound_measure_received (ce_rx,
+ sta,
+ data.measure,
+ true);
return ce_rx_bl_fsm_next (INTERVAL_SOUND_WAIT, interval_sound);
}
@@ -664,8 +734,10 @@ ce_rx_bl_fsm__INTERVAL_SOUND_WAIT__interval_sound_completed (
sta_t *sta,
ce_rx_bitloading_fsm_event_param_t data)
{
- /* TODO, we should not execute this for the moment. */
- dbg_assert_default ();
+ ce_rx_bl__common_sound_measure_received (ce_rx,
+ sta,
+ data.measure,
+ true);
return ce_rx_bl_fsm_next (INTERVAL_SOUND_WAIT, interval_sound_completed);
}
@@ -675,7 +747,5 @@ ce_rx_bl_fsm__INTERVAL_SOUND_WAIT__interval_data (
sta_t *sta,
ce_rx_bitloading_fsm_event_param_t data)
{
- /* TODO, we should not execute this for the moment. */
- dbg_assert_default ();
return ce_rx_bl_fsm_next (INTERVAL_SOUND_WAIT, interval_data);
}
diff --git a/cesar/ce/rx/bitloading/test/intervals/Config b/cesar/ce/rx/bitloading/test/intervals/Config
new file mode 100644
index 0000000000..1221024089
--- /dev/null
+++ b/cesar/ce/rx/bitloading/test/intervals/Config
@@ -0,0 +1 @@
+CONFIG_DEBUG_FATAL_CATCH = y
diff --git a/cesar/ce/rx/bitloading/test/intervals/Makefile b/cesar/ce/rx/bitloading/test/intervals/Makefile
new file mode 100644
index 0000000000..10805c0c59
--- /dev/null
+++ b/cesar/ce/rx/bitloading/test/intervals/Makefile
@@ -0,0 +1,22 @@
+# List of program to build.
+HOST_PROGRAMS = test_ce_intervals_fsm
+
+# Base directory.
+BASE = ../../../../..
+
+test_ce_intervals_fsm_SOURCES = scenario_intervals_actions.c \
+ test_intervals_fsm.c scenario_intervals_events.c \
+ ../../src/ecos_stub.c
+test_ce_intervals_fsm_MODULES = lib ce/rx/bitloading/fsm ce/rx/bitloading \
+ ce/rx/cp/stub ce/common lib/scenario
+test_ce_intervals_CONFIG_MODULES = cp
+
+ce_rx_bitloading_MODULE_SOURCES = transition.c intervals.c common.c pber.c \
+ ber_margin_update.c
+mac_common_MODULE_SOURCES = interval.c
+
+INCLUDES += ce/rx/bitloading/test/intervals \
+ ce/rx/bitloading/test/intervals/override
+
+# Include base makefile.
+include $(BASE)/common/make/top.mk
diff --git a/cesar/ce/rx/bitloading/test/intervals/inc/scenario_defs.h b/cesar/ce/rx/bitloading/test/intervals/inc/scenario_defs.h
new file mode 100644
index 0000000000..6f56e6c7ba
--- /dev/null
+++ b/cesar/ce/rx/bitloading/test/intervals/inc/scenario_defs.h
@@ -0,0 +1,114 @@
+#ifndef ce_rx_bitloading_test_inc_scenario_defs_h
+#define ce_rx_bitloading_test_inc_scenario_defs_h
+/* Cesar project {{{
+ *
+ * Copyright (C) 2010 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}} */
+/**
+ * \file ce/rx/bitloading/test/inc/scenario_defs.h
+ * \brief Scenario definition.
+ * \ingroup test
+ */
+
+#include "ce/rx/rx.h"
+#include "mac/common/sta.h"
+#include "mac/common/tonemap.h"
+#include "ce/rx/bitloading/fsm/event.h"
+#include "ce_rx_bl_fsm_defs.h"
+
+#define DEFAULT_NEW_TMI TONEMAP_INDEX_NEGOTIATED_FIRST
+
+/* Scenario globals. */
+#define SCENARIO_DEFS_GLOBALS \
+ ce_rx_t *ce;
+
+/* Scenario actions. */
+#define SCENARIO_DEFS_ACTIONS \
+ INTERVAL_TRACKING__interval_sound, \
+ INTERVAL_TRACKING__interval_sound_completed, \
+ INTERVAL_TRACKING__interval_data, \
+ INTERVAL_SOUND__interval_sound, \
+ INTERVAL_SOUND__interval_sound_completed, \
+ INTERVAL_SOUND__interval_data, \
+ INTERVAL_SOUND_WAIT__interval_sound, \
+ INTERVAL_SOUND_WAIT__interval_sound_completed, \
+ INTERVAL_SOUND_WAIT__interval_data
+
+/* Actions with default parameters. */
+#define __action(action) \
+typedef struct \
+{ \
+ sta_t *sta; \
+ ce_rx_measure_mbox_t measure; \
+ ce_rx_bl_fsm_branch_t branch; \
+} scenario_action_ ## action ## _t; \
+\
+void \
+scenario_action_ ## action ## _cb ( \
+ scenario_globals_t *globals, \
+ scenario_params_t *params);
+
+__action (INTERVAL_TRACKING__interval_sound);
+__action (INTERVAL_TRACKING__interval_sound_completed);
+__action (INTERVAL_TRACKING__interval_data);
+__action (INTERVAL_SOUND__interval_sound);
+__action (INTERVAL_SOUND__interval_sound_completed);
+__action (INTERVAL_SOUND__interval_data);
+__action (INTERVAL_SOUND_WAIT__interval_sound);
+__action (INTERVAL_SOUND_WAIT__interval_sound_completed);
+__action (INTERVAL_SOUND_WAIT__interval_data);
+
+#undef __action
+
+/* Scenario events. */
+#define SCENARIO_DEFS_EVENTS \
+ ce_rx_bl_nsr_sum_init, \
+ ce_rx_bl_nsr_sum_add, \
+ ce_rx_bl_nsr_compute_mean, \
+ ce_rx_bl_ber_sliding_mean_update, \
+ tonemaps_reset, \
+ tonemaps_set_first_free_tmi, \
+ tonemap_free, \
+ ce_rx_cp_send_mme_new_tone_map, \
+ ce_rx_cp_send_mme_refresh_tmi_list, \
+ tonemap_disable, \
+ mac_interval_clear, \
+ mac_interval_commit_changes, \
+ mac_interval_append, \
+ ce_rx_bl_ber_pt_robo, \
+ ce_rx_bl_initial
+
+/* An event. */
+#define __event(event, param...) \
+typedef struct \
+{ \
+ PREPROC_FOR_EACH (__p_, ## param) \
+} scenario_event_ ## event ## _t;
+
+#define __p_(param) param;
+
+__event (ce_rx_bl_nsr_sum_init, ce_rx_bitloading_t *bl);
+__event (ce_rx_bl_nsr_sum_add, ce_rx_bitloading_t *bl);
+__event (ce_rx_bl_nsr_compute_mean, ce_rx_bitloading_t *bl);
+__event (ce_rx_bl_ber_sliding_mean_update, ce_rx_bitloading_t *bl);
+__event (tonemaps_reset, tonemaps_t *tms);
+__event (tonemaps_set_first_free_tmi);
+__event (tonemap_free, tonemap_t *tm);
+__event (ce_rx_cp_send_mme_new_tone_map, ce_rx_t *ce_rx, sta_t *peer,
+ u8 new_tmi, u8 old_tmi, bool initial_ce);
+__event (ce_rx_cp_send_mme_refresh_tmi_list, ce_rx_t *ce_rx, sta_t *peer);
+__event (tonemap_disable, tonemaps_t *tms, u8 tmi);
+__event (mac_interval_clear, tonemaps_t *tms);
+__event (mac_interval_commit_changes, tonemaps_t *tms);
+__event (mac_interval_append, tonemaps_t *tms, u16 end_offset_atu,
+ u8 tmi);
+__event (ce_rx_bl_ber_pt_robo);
+__event (ce_rx_bl_initial, ce_rx_bitloading_t *bl);
+
+#undef __event
+#undef __p_
+
+#endif /* ce_rx_bitloading_test_inc_scenario_defs_h */
diff --git a/cesar/ce/rx/bitloading/test/intervals/override/ce/rx/bitloading/nsr.h b/cesar/ce/rx/bitloading/test/intervals/override/ce/rx/bitloading/nsr.h
new file mode 100644
index 0000000000..dc4e4cd54a
--- /dev/null
+++ b/cesar/ce/rx/bitloading/test/intervals/override/ce/rx/bitloading/nsr.h
@@ -0,0 +1,48 @@
+#ifndef ce_rx_bitloading_test_fsm_override_ce_rx_bitloading_nsr_h
+#define ce_rx_bitloading_test_fsm_override_ce_rx_bitloading_nsr_h
+/* Cesar project {{{
+ *
+ * Copyright (C) 2011 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}} */
+/**
+ * \file ce/rx/bitloading/test/fsm/override/ce/rx/bitloading/nsr.h
+ * \brief override for ce/rx/bitloading/nsr.h
+ * \ingroup ce_rx_bl_test
+ */
+
+#include "ce/rx/bitloading/context.h"
+
+/**
+ * NSR must be rescaled before used by BER vs polynomials.
+ * Rescaling is not the same if NSR is based on sound or data.
+ */
+#define CE_RX_BL_NSR_SOUND_RESCALE (2)
+
+BEGIN_DECLS
+
+/**
+ * Clean NSR mean.
+ * \param bl the bit loading context of the peer
+ */
+extern inline void
+ce_rx_bl_nsr_clean (ce_rx_bitloading_t *bl)
+{
+ if (bl->noise_nrj_blk_count)
+ blk_release_desc_range_nb (bl->noise_nrj, bl->noise_nrj_blk_count);
+ bl->noise_nrj_blk_count = 0;
+}
+
+/**
+ * Get the current NSR used by the bit loading.
+ * \param ctx the bit loading context of the station.
+ * \return the NSR if available (NULL otherwise).
+ */
+blk_t *
+ce_rx_bl_get_nsr (ce_rx_bitloading_t *bl);
+
+END_DECLS
+
+#endif /* ce_rx_bitloading_test_fsm_override_ce_rx_bitloading_nsr_h */
diff --git a/cesar/ce/rx/bitloading/test/intervals/override/cyg/kernel/kapi.h b/cesar/ce/rx/bitloading/test/intervals/override/cyg/kernel/kapi.h
new file mode 100644
index 0000000000..ffc4b3b8f5
--- /dev/null
+++ b/cesar/ce/rx/bitloading/test/intervals/override/cyg/kernel/kapi.h
@@ -0,0 +1,21 @@
+#ifndef ce_rx_bitloading_test_override_cyg_kernel_kapi_h
+#define ce_rx_bitloading_test_override_cyg_kernel_kapi_h
+/* Cesar project {{{
+ *
+ * Copyright (C) 2010 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}} */
+/**
+ * \file ce/rx/bitloading/test/override/cyg/kernel/kapi.h
+ * \brief Override for test with eCos.
+ * \ingroup test
+ */
+
+extern u32 ecos_time;
+
+u32
+cyg_current_time (void);
+
+#endif /* ce_rx_bitloading_test_override_cyg_kernel_kapi_h */
diff --git a/cesar/ce/rx/bitloading/test/intervals/src/scenario_intervals_actions.c b/cesar/ce/rx/bitloading/test/intervals/src/scenario_intervals_actions.c
new file mode 100644
index 0000000000..c0fde0f6dc
--- /dev/null
+++ b/cesar/ce/rx/bitloading/test/intervals/src/scenario_intervals_actions.c
@@ -0,0 +1,40 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2010 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}} */
+/**
+ * \file ce/rx/bitloading/test/src/scenario_intervals_actions.c
+ * \brief Scenario actions of intervals.
+ * \ingroup test
+ */
+#include "common/std.h"
+#include "lib/scenario/scenario.h"
+#include "ce/rx/bitloading/inc/transition.h"
+
+#define __action_def(ACTION) \
+void \
+scenario_action_ ## ACTION ## _cb (scenario_globals_t *globals, \
+ scenario_params_t *params) \
+{ \
+ ce_rx_bl_fsm_branch_t ret = \
+ ce_rx_bl_fsm__ ## ACTION (globals->ce, \
+ params->action_ ## ACTION.sta, \
+ (ce_rx_bitloading_fsm_event_param_t) \
+ (&params->action_ ## ACTION.measure)); \
+ test_within (scenario.t); \
+ test_fail_unless (ret == params->action_ ## ACTION.branch); \
+}
+
+__action_def (INTERVAL_TRACKING__interval_sound);
+__action_def (INTERVAL_TRACKING__interval_sound_completed);
+__action_def (INTERVAL_TRACKING__interval_data);
+__action_def (INTERVAL_SOUND__interval_sound);
+__action_def (INTERVAL_SOUND__interval_sound_completed);
+__action_def (INTERVAL_SOUND__interval_data);
+__action_def (INTERVAL_SOUND_WAIT__interval_sound);
+__action_def (INTERVAL_SOUND_WAIT__interval_sound_completed);
+__action_def (INTERVAL_SOUND_WAIT__interval_data);
+
diff --git a/cesar/ce/rx/bitloading/test/intervals/src/scenario_intervals_events.c b/cesar/ce/rx/bitloading/test/intervals/src/scenario_intervals_events.c
new file mode 100644
index 0000000000..7bfb358c64
--- /dev/null
+++ b/cesar/ce/rx/bitloading/test/intervals/src/scenario_intervals_events.c
@@ -0,0 +1,170 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2010 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}} */
+/**
+ * \file ce/rx/bitloading/test/src/scenario_intervals_events.c
+ * \brief Scenario events stubs of intervals.
+ * \ingroup test
+ */
+#include "common/std.h"
+
+#include "ce/rx/bitloading/inc/initial.h"
+#include "ce/rx/bitloading/inc/nsr.h"
+#include "ce/rx/bitloading/inc/ber.h"
+#include "ce/rx/bitloading/inc/bitloading.h"
+#include "ce/rx/inc/measure.h"
+#include "mac/common/tonemap.h"
+#include "mac/common/interval.h"
+
+#include "lib/scenario/scenario.h"
+
+typedef struct
+{
+ u8 count;
+} test_intervals_t;
+
+test_intervals_t test_intervals;
+
+#define __event_empty_def(ret_name, func_name, params...) \
+ret_name \
+func_name (params) \
+{ \
+ scenario_event (func_name); \
+} \
+
+tonemap_t tonemap = {.bits_per_symbol = (uint)(-1)};
+
+void
+ce_rx_bl_nsr_sum_init (ce_rx_bitloading_t *bl,
+ phy_chandata_t *chan_data, uint chan_data_count)
+{
+ scenario_event (ce_rx_bl_nsr_sum_init, params);
+ test_fail_unless (bl == params->bl);
+}
+
+void ce_rx_bl_nsr_sum_add (ce_rx_bitloading_t *bl, phy_chandata_t *chan_data,
+ uint chan_data_count)
+{
+ scenario_event (ce_rx_bl_nsr_sum_add, params);
+ test_fail_unless (bl == params->bl);
+}
+
+void ce_rx_bl_nsr_compute_mean (ce_rx_bitloading_t *bl)
+{
+ scenario_event (ce_rx_bl_nsr_compute_mean, params);
+ test_fail_unless (bl == params->bl);
+}
+
+void ce_rx_bl_ber_sliding_mean_update (ce_rx_bitloading_t *bl, u64 ber)
+{
+ scenario_event (ce_rx_bl_ber_sliding_mean_update, params);
+ test_fail_unless (bl == params->bl);
+}
+
+u8
+tonemaps_set_first_free_tmi (tonemaps_t *tms, tonemap_t *tm)
+{
+ scenario_event (tonemaps_set_first_free_tmi);
+ test_fail_unless (&tonemap == tm);
+
+ return DEFAULT_NEW_TMI;
+}
+
+void
+tonemap_free (tonemap_t *tm)
+{
+ scenario_event (tonemap_free, params);
+ test_fail_unless (tm == params->tm);
+}
+
+void
+tonemaps_reset (tonemaps_t *tms, tonemap_release_list_t *tm_release_list)
+{
+ scenario_event (tonemaps_reset, params);
+ test_intervals.count = 0;
+ test_fail_unless (tms == params->tms);
+ test_fail_unless (tm_release_list);
+}
+
+void
+ce_rx_cp_send_mme_new_tone_map (ce_rx_t *ce_rx, sta_t *peer, u8 new_tmi,
+ u8 old_tmi, bool initial_ce)
+{
+ scenario_event (ce_rx_cp_send_mme_new_tone_map, params);
+ test_fail_unless (ce_rx == params->ce_rx);
+ test_fail_unless (peer == params->peer);
+ test_fail_unless (new_tmi == params->new_tmi);
+ test_fail_unless (old_tmi == params->old_tmi);
+ test_fail_unless (initial_ce == params->initial_ce);
+ test_fail_unless (new_tmi == DEFAULT_NEW_TMI);
+}
+
+void
+ce_rx_cp_send_mme_refresh_tmi_list (ce_rx_t *ce_rx, sta_t *peer)
+{
+ scenario_event (ce_rx_cp_send_mme_refresh_tmi_list, params);
+ test_fail_unless (ce_rx == params->ce_rx);
+ test_fail_unless (peer == params->peer);
+}
+
+void
+tonemap_disable (tonemaps_t *tms, u8 tmi)
+{
+ scenario_event (tonemap_disable, params);
+ test_fail_unless (tms == params->tms);
+ test_fail_unless (tmi == params->tmi);
+}
+
+void
+mac_interval_clear (tonemaps_t *tms)
+{
+ scenario_event (mac_interval_clear, params);
+ test_intervals.count = 0;
+ test_fail_unless (tms == params->tms);
+}
+
+void
+mac_interval_commit_changes (tonemaps_t *tms)
+{
+ scenario_event (mac_interval_commit_changes, params);
+ test_fail_unless (tms == params->tms);
+}
+
+u8
+mac_interval_append (tonemaps_t *tms,
+ u16 end_offset_atu, u8 tmi)
+{
+ scenario_event (mac_interval_append, params);
+ test_fail_unless (tms == params->tms);
+ test_fail_unless (tmi == params->tmi);
+
+ return ++test_intervals.count;
+}
+
+u64
+ce_rx_bl_ber_pt_robo (uint carrier_nb)
+{
+ scenario_event (ce_rx_bl_ber_pt_robo);
+ return 42;
+}
+
+tonemap_t *
+ce_rx_bl_initial (tonemask_info_t *tonemask, tonemask_info_t *reducedtm,
+ ce_rx_bitloading_t *bl)
+{
+ scenario_event (ce_rx_bl_initial, params);
+ test_fail_unless (bl == params->bl);
+
+ return &tonemap;
+}
+
+u64
+ce_rx_bl_ber_quantify (ce_rx_measure_mbox_t *measure, u64 ber_reached,
+ u16 pb_size)
+{
+ return 0;
+}
diff --git a/cesar/ce/rx/bitloading/test/intervals/src/test_intervals_fsm.c b/cesar/ce/rx/bitloading/test/intervals/src/test_intervals_fsm.c
new file mode 100644
index 0000000000..cf8c279f02
--- /dev/null
+++ b/cesar/ce/rx/bitloading/test/intervals/src/test_intervals_fsm.c
@@ -0,0 +1,755 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2010 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}} */
+/**
+ * \file ce/rx/bitloading/test/intervals/src/test_intervals_fsm.c
+ * \brief Test intervals sub FSM transitions.
+ * \ingroup test
+ */
+#include "common/std.h"
+
+#include "ce/rx/inc/rx.h"
+#include "ce/rx/bitloading/fsm/event.h"
+#include "ce/rx/bitloading/inc/ber.h"
+#include "ce/rx/bitloading/inc/pber.h"
+#include "ce/rx/inc/measure.h"
+#include "ce/common/mod.h"
+#include "mac/common/sta.h"
+#include "mac/common/tonemap.h"
+#include "ce_rx_bl_fsm_defs.h"
+
+#include "lib/test.h"
+#include "lib/scenario/scenario.h"
+#include "lib/preproc.h"
+#include "lib/rnd.h"
+
+#include <cyg/kernel/kapi.h>
+#include <string.h>
+
+u8 mac_interval_fsm_count_ = 6;
+u8 mac_interval_repetition_count_ = 4;
+u16 mac_interval_measure_shift_tolerance_ = 0;
+uint ce_rx_bl_pb_false_factor_ = CE_RX_BL_PB_FALSE_FACTOR;
+uint ce_rx_bl_pb_total_factor_ = CE_RX_BL_PB_TOTAL_FACTOR;
+uint ce_rx_bl_min_pb_per_frame_ = CE_RX_BL_MIN_PB_PER_FRAME;
+uint ce_rx_bl_min_frame_with_high_pb_err_rate_
+ = CE_RX_BL_MIN_FRAME_WITH_HIGH_PB_ERR_RATE;
+
+/**
+ * The configuration of the BER module.
+ */
+ce_rx_bl_ber_conf_t ce_rx_bl_ber_conf;
+
+/* Global CE/RX behavior stub. */
+ce_rx_behavior_t ce_rx_behavior = CE_RX_BEHAVIOR_INTERVALS_ENABLE;
+
+static void
+test_ce_rx_bl_fsm_INTERVAL_TRACKING (test_t t)
+{
+ mac_config_t config;
+ config.tonemask_info.carrier_nb = PHY_CARRIER_NB;
+ config.tonemask_info.tonemap_robo[PHY_MOD_ROBO].bits_per_symbol = 42;
+ bsu_aclf_t aclf;
+ *((bsu_aclf_bp_t*) &aclf.beacon_period_theo_tck) = BSU_ACLF_BP_50HZ_TCK;
+
+ ce_rx_t ce = { .mac_config = &config, .aclf = &aclf, };
+ ce.tck_per_rtc = 1;
+ scenario_globals_t globals = {
+ .ce = &ce,
+ };
+ int total_ints = mac_interval_fsm_count_ * mac_interval_repetition_count_;
+
+ ce_rx_measure_mbox_t measure;
+ u8 tested_tmi = TONEMAP_INDEX_NEGOTIATED_FIRST;
+ int tested_fsm_id = 2;
+ measure.fsm_id = tested_fsm_id;
+ measure.rx_params.sound = true;
+ measure.rx_params.sound_complete = false;
+
+ sta_t sta;
+ sta.intervals = ce_rx_bl_intervals_alloc (tested_tmi);
+
+ tonemaps_t rx_tms, tx_tms;
+ sta.rx_tonemaps = &rx_tms;
+ sta.tx_tonemaps = &tx_tms;
+
+ /* The tmi of the intervals is different from the default tmi. */
+ sta.rx_tonemaps->default_tmi = tested_tmi + 1;
+
+ test_case_begin (t, "INTERVAL_TRACKING, interval_sound appears");
+
+ test_begin (t, "The tonemap used in intervals is a negotiated one.")
+ {
+ scenario_entry_t fsm_base[300];
+ int pos = 0;
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_ACTION (
+ INTERVAL_TRACKING__interval_sound, .sta = &sta, .measure = measure,
+ .branch = ce_rx_bl_fsm_next (INTERVAL_TRACKING, interval_sound));
+
+ /* Check intervals are reset:
+ * - check the tonemap of the interval is disabled. */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ tonemap_disable, .tms = &rx_tms, .tmi = tested_tmi);
+
+ /* - check the interval is updated with 0xFE */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_clear, .tms = &rx_tms);
+ int j;
+ for (j = 0; j < total_ints; j++)
+ {
+ if (j % mac_interval_fsm_count_ == tested_fsm_id)
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_append, .tms = &rx_tms, .tmi = 0xFE);
+ else
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_append, .tms = &rx_tms, .tmi = tested_tmi);
+ }
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_commit_changes, .tms = &rx_tms);
+
+ /* - check MMe is sent */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_cp_send_mme_refresh_tmi_list, .ce_rx = &ce, .peer = &sta);
+ /* Check sound mesure is treated :
+ * - sum nsr is initialised */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_nsr_sum_init, .bl = sta.intervals->intervals[tested_fsm_id]);
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_END;
+ scenario_run (t, fsm_base, &globals);
+ } test_end;
+
+ /* Clean. */
+ ce_rx_bl_intervals_free (sta.intervals);
+
+ sta.rx_tonemaps->default_tmi = tested_tmi;
+ sta.intervals = ce_rx_bl_intervals_alloc (tested_tmi);
+
+ test_begin (t, "The tonemap used in intervals is the default tonemap.")
+ {
+ scenario_entry_t fsm_base[300];
+ int pos = 0;
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_ACTION (
+ INTERVAL_TRACKING__interval_sound, .sta = &sta, .measure = measure,
+ .branch = ce_rx_bl_fsm_next (INTERVAL_TRACKING, interval_sound));
+
+ /* Check intervals are reset:
+ * - check the interval is updated with 0xFE */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_clear, .tms = &rx_tms);
+ int j;
+ for (j = 0; j < total_ints; j++)
+ {
+ if (j % mac_interval_fsm_count_ == tested_fsm_id)
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_append, .tms = &rx_tms, .tmi = 0xFE);
+ else
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_append, .tms = &rx_tms, .tmi = tested_tmi);
+ }
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_commit_changes, .tms = &rx_tms);
+
+ /* - check MMe is sent */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_cp_send_mme_refresh_tmi_list, .ce_rx = &ce, .peer = &sta);
+ /* Check sound mesure is treated :
+ * - sum nsr is initialised */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_nsr_sum_init, .bl = sta.intervals->intervals[tested_fsm_id]);
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_END;
+ scenario_run (t, fsm_base, &globals);
+
+ } test_end;
+
+ /* Clean. */
+ ce_rx_bl_intervals_free (sta.intervals);
+
+
+ tested_tmi = 0; /* Mode Robo */
+ sta.rx_tonemaps->default_tmi = tested_tmi + 1;
+ sta.intervals = ce_rx_bl_intervals_alloc (tested_tmi);
+
+ test_begin (t, "The tonemap used in intervals is a ROBO mode.")
+ {
+ scenario_entry_t fsm_base[300];
+ int pos = 0;
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_ACTION (
+ INTERVAL_TRACKING__interval_sound, .sta = &sta, .measure = measure,
+ .branch = ce_rx_bl_fsm_next (INTERVAL_TRACKING, interval_sound));
+
+ /* Check intervals are reset:
+ * - check the interval is updated with 0xFE */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_clear, .tms = &rx_tms);
+ int j;
+ for (j = 0; j < total_ints; j++)
+ {
+ if (j % mac_interval_fsm_count_ == tested_fsm_id)
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_append, .tms = &rx_tms, .tmi = 0xFE);
+ else
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_append, .tms = &rx_tms, .tmi = tested_tmi);
+ }
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_commit_changes, .tms = &rx_tms);
+
+ /* - check MMe is sent */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_cp_send_mme_refresh_tmi_list, .ce_rx = &ce, .peer = &sta);
+ /* Check sound mesure is treated :
+ * - sum nsr is initialised */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_nsr_sum_init, .bl = sta.intervals->intervals[tested_fsm_id]);
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_END;
+ scenario_run (t, fsm_base, &globals);
+ } test_end;
+
+ /* Clean. */
+ ce_rx_bl_intervals_free (sta.intervals);
+
+ test_case_begin (t, "INTERVAL_TRACKING, interval_sound_completed appears");
+
+ test_begin (t, "The sound_completed is ignored.")
+ {
+ scenario_entry_t fsm_base[300];
+ int pos = 0;
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_ACTION (
+ INTERVAL_TRACKING__interval_sound_completed, .sta = &sta,
+ .measure = measure,
+ .branch = ce_rx_bl_fsm_next (INTERVAL_TRACKING, interval_sound_completed));
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_END;
+ scenario_run (t, fsm_base, &globals);
+ } test_end;
+
+ test_case_begin (t, "INTERVAL_TRACKING, interval_data appears");
+
+ tested_tmi = TONEMAP_INDEX_NEGOTIATED_FIRST;
+ sta.rx_tonemaps->default_tmi = tested_tmi;
+ sta.intervals = ce_rx_bl_intervals_alloc (tested_tmi);
+ measure.rx_params.tmi_av = tested_tmi + 1;
+ tonemap_t tm;
+ rx_tms.tm[tested_tmi] = &tm;
+ rx_tms.tm[tested_tmi]->fecrate = PHY_FEC_RATE_16_21;
+ rx_tms.tm[tested_tmi + 1] = NULL;
+
+ test_begin (t, "The measure has the wrong tmi.")
+ {
+ scenario_entry_t fsm_base[300];
+ int pos = 0;
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_ACTION (
+ INTERVAL_TRACKING__interval_data, .sta = &sta,
+ .measure = measure,
+ .branch = ce_rx_bl_fsm_next_branch (INTERVAL_TRACKING,
+ interval_data, no_channel_change));
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_END;
+ scenario_run (t, fsm_base, &globals);
+ } test_end;
+
+ /* Clean. */
+ ce_rx_bl_intervals_free (sta.intervals);
+
+ tested_tmi = TONEMAP_INDEX_NEGOTIATED_FIRST;
+ sta.rx_tonemaps->default_tmi = tested_tmi;
+ sta.rx_tonemaps->tm[tested_tmi]->ber_target = 1664;
+ sta.intervals = ce_rx_bl_intervals_alloc (tested_tmi);
+ measure.rx_params.tmi_av = tested_tmi;
+ measure.false_pb_count = ce_rx_bl_min_pb_per_frame_;
+ measure.total_pb_count = 1 + ce_rx_bl_min_pb_per_frame_ +
+ CEIL_DIV (ce_rx_bl_min_pb_per_frame_
+ * ce_rx_bl_pb_false_factor_, ce_rx_bl_pb_total_factor_);
+ measure.rx_params.pb_size = PHY_PB_SIZE_520;
+
+ sta.intervals->intervals[tested_fsm_id]->high_pb_error_rate_frame_counter =
+ ce_rx_bl_min_frame_with_high_pb_err_rate_ - 2;
+ sta.intervals->intervals[tested_fsm_id]->next_date_min_for_restart_rtc_date[0] = 1;
+ sta.intervals->intervals[tested_fsm_id]->next_date_min_for_restart_rtc_date[2] = 1;
+
+ test_begin (t, "High PB error rate, not enough frames and too soon.")
+ {
+ scenario_entry_t fsm_base[300];
+ int pos = 0;
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_ACTION (
+ INTERVAL_TRACKING__interval_data, .sta = &sta,
+ .measure = measure,
+ .branch = ce_rx_bl_fsm_next_branch (INTERVAL_TRACKING,
+ interval_data, no_channel_change));
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_ber_sliding_mean_update,
+ .bl = sta.intervals->intervals[tested_fsm_id]);
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_END;
+ scenario_run (t, fsm_base, &globals);
+ } test_end;
+
+ sta.intervals->intervals[tested_fsm_id]->high_pb_error_rate_frame_counter =
+ ce_rx_bl_min_frame_with_high_pb_err_rate_ - 1;
+ sta.intervals->intervals[tested_fsm_id]->next_date_min_for_restart_rtc_date[0] = 1;
+ sta.intervals->intervals[tested_fsm_id]->next_date_min_for_restart_rtc_date[2] = 1;
+
+ test_begin (t, "High PB error rate, enough frames too soon.")
+ {
+ scenario_entry_t fsm_base[300];
+ int pos = 0;
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_ACTION (
+ INTERVAL_TRACKING__interval_data, .sta = &sta,
+ .measure = measure,
+ .branch = ce_rx_bl_fsm_next_branch (INTERVAL_TRACKING,
+ interval_data, no_channel_change));
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_ber_sliding_mean_update,
+ .bl = sta.intervals->intervals[tested_fsm_id]);
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_END;
+ scenario_run (t, fsm_base, &globals);
+ } test_end;
+
+ sta.intervals->intervals[tested_fsm_id]->high_pb_error_rate_frame_counter =
+ ce_rx_bl_min_frame_with_high_pb_err_rate_ - 2;
+ sta.intervals->intervals[tested_fsm_id]->next_date_min_for_restart_rtc_date[0] = 0;
+ sta.intervals->intervals[tested_fsm_id]->next_date_min_for_restart_rtc_date[2] = 0;
+
+ test_begin (t, "High PB error rate, not too soon but not enough frames.")
+ {
+ scenario_entry_t fsm_base[300];
+ int pos = 0;
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_ACTION (
+ INTERVAL_TRACKING__interval_data, .sta = &sta,
+ .measure = measure,
+ .branch = ce_rx_bl_fsm_next_branch (INTERVAL_TRACKING,
+ interval_data, no_channel_change));
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_ber_sliding_mean_update,
+ .bl = sta.intervals->intervals[tested_fsm_id]);
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_END;
+ scenario_run (t, fsm_base, &globals);
+ } test_end;
+
+ sta.intervals->intervals[tested_fsm_id]->high_pb_error_rate_frame_counter =
+ ce_rx_bl_min_frame_with_high_pb_err_rate_ - 1;
+ sta.intervals->intervals[tested_fsm_id]->next_date_min_for_restart_rtc_date[0] = 0;
+
+ test_begin (t, "High PB error rate, not too soon and enough frames.")
+ {
+ scenario_entry_t fsm_base[300];
+ int pos = 0;
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_ACTION (
+ INTERVAL_TRACKING__interval_data, .sta = &sta,
+ .measure = measure,
+ .branch = ce_rx_bl_fsm_next_branch (INTERVAL_TRACKING,
+ interval_data, pb_err_rate_high));
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_ber_sliding_mean_update,
+ .bl = sta.intervals->intervals[tested_fsm_id]);
+ /* - check the interval is updated with 0xFE */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_clear, .tms = &rx_tms);
+ int j;
+ for (j = 0; j < total_ints; j++)
+ {
+ if (j % mac_interval_fsm_count_ == tested_fsm_id)
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_append, .tms = &rx_tms, .tmi = 0xFE);
+ else
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_append, .tms = &rx_tms, .tmi = tested_tmi);
+ }
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_commit_changes, .tms = &rx_tms);
+
+ /* - check MMe is sent */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_cp_send_mme_refresh_tmi_list, .ce_rx = &ce, .peer = &sta);
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_END;
+ scenario_run (t, fsm_base, &globals);
+ } test_end;
+
+ /* Clean. */
+ ce_rx_bl_intervals_free (sta.intervals);
+
+ tested_tmi = 0; /* ROBO */
+ sta.rx_tonemaps->default_tmi = tested_tmi;
+ sta.intervals = ce_rx_bl_intervals_alloc (tested_tmi);
+ measure.rx_params.tmi_av = tested_tmi;
+ sta.intervals->intervals[tested_fsm_id]->
+ ber_sliding_mean[CE_RX_BL_BER_SLIDING_MEAN_FAST] = 0;
+ sta.intervals->intervals[tested_fsm_id]->
+ ber_sliding_mean[CE_RX_BL_BER_SLIDING_MEAN_SLOW] = 0;
+ sta.intervals->intervals[tested_fsm_id]->
+ next_date_min_for_restart_rtc_date[1] = 0;
+
+ test_begin (t, "BER too low, ROBO tonemap.")
+ {
+ scenario_entry_t fsm_base[300];
+ int pos = 0;
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_ACTION (
+ INTERVAL_TRACKING__interval_data, .sta = &sta,
+ .measure = measure,
+ .branch = ce_rx_bl_fsm_next_branch (INTERVAL_TRACKING,
+ interval_data, ber_too_low));
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_ber_sliding_mean_update,
+ .bl = sta.intervals->intervals[tested_fsm_id]);
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (ce_rx_bl_ber_pt_robo);
+
+ /* - check the interval is updated with 0xFE */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_clear, .tms = &rx_tms);
+ int j;
+ for (j = 0; j < total_ints; j++)
+ {
+ if (j % mac_interval_fsm_count_ == tested_fsm_id)
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_append, .tms = &rx_tms, .tmi = 0xFE);
+ else
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_append, .tms = &rx_tms, .tmi = tested_tmi);
+ }
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_commit_changes, .tms = &rx_tms);
+
+ /* - check MMe is sent */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_cp_send_mme_refresh_tmi_list, .ce_rx = &ce, .peer = &sta);
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_END;
+ scenario_run (t, fsm_base, &globals);
+ } test_end;
+
+ /* Clean. */
+ ce_rx_bl_intervals_free (sta.intervals);
+
+ tested_tmi = TONEMAP_INDEX_NEGOTIATED_FIRST;
+ sta.rx_tonemaps->default_tmi = tested_tmi;
+ sta.rx_tonemaps->tm[tested_tmi]->bits_per_symbol = 0;
+ sta.rx_tonemaps->tm[tested_tmi]->ber_target_reached = 42;
+ ce.mac_config->tonemask_info.carrier_nb = 42;
+ sta.intervals = ce_rx_bl_intervals_alloc (tested_tmi);
+ measure.rx_params.tmi_av = tested_tmi;
+ sta.intervals->intervals[tested_fsm_id]->
+ ber_sliding_mean[CE_RX_BL_BER_SLIDING_MEAN_FAST] = 0;
+ sta.intervals->intervals[tested_fsm_id]->
+ ber_sliding_mean[CE_RX_BL_BER_SLIDING_MEAN_SLOW] = 0;
+ measure.false_pb_count = 0;
+
+ test_begin (t, "BER too low with a negotiated tonemap.")
+ {
+ scenario_entry_t fsm_base[300];
+ int pos = 0;
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_ACTION (
+ INTERVAL_TRACKING__interval_data, .sta = &sta,
+ .measure = measure,
+ .branch = ce_rx_bl_fsm_next_branch (INTERVAL_TRACKING,
+ interval_data, ber_too_low));
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_ber_sliding_mean_update,
+ .bl = sta.intervals->intervals[tested_fsm_id]);
+
+ /* - check the interval is updated with 0xFE */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_clear, .tms = &rx_tms);
+ int j;
+ for (j = 0; j < total_ints; j++)
+ {
+ if (j % mac_interval_fsm_count_ == tested_fsm_id)
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_append, .tms = &rx_tms, .tmi = 0xFE);
+ else
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_append, .tms = &rx_tms, .tmi = tested_tmi);
+ }
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_commit_changes, .tms = &rx_tms);
+
+ /* - check MMe is sent */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_cp_send_mme_refresh_tmi_list, .ce_rx = &ce, .peer = &sta);
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_END;
+ scenario_run (t, fsm_base, &globals);
+ } test_end;
+
+ /* Clean. */
+ ce_rx_bl_intervals_free (sta.intervals);
+}
+
+static void
+test_ce_rx_bl_fsm_INTERVAL_SOUND (test_t t)
+{
+ mac_config_t config;
+ config.tonemask_info.carrier_nb = PHY_CARRIER_NB;
+ config.tonemask_info.tonemap_robo[PHY_MOD_ROBO].bits_per_symbol = 42;
+ bsu_aclf_t aclf;
+ *((bsu_aclf_bp_t*) &aclf.beacon_period_theo_tck) = BSU_ACLF_BP_50HZ_TCK;
+ int total_ints = mac_interval_fsm_count_ * mac_interval_repetition_count_;
+
+ ce_rx_t ce = { .mac_config = &config, .aclf = &aclf, .tck_per_rtc = 1};
+ scenario_globals_t globals = {
+ .ce = &ce,
+ };
+
+ ce_rx_measure_mbox_t measure;
+ u8 tested_tmi = DEFAULT_NEW_TMI + 1;
+ int tested_fsm_id = 2;
+ measure.fsm_id = tested_fsm_id;
+ measure.rx_params.sound = true;
+ measure.rx_params.sound_complete = false;
+
+ sta_t sta;
+ sta.intervals = ce_rx_bl_intervals_alloc (tested_tmi);
+ tonemaps_t rx_tms;
+ sta.rx_tonemaps = &rx_tms;
+ sta.rx_tonemaps->default_tmi = tested_tmi;
+
+ test_case_begin (t, "INTERVAL_SOUND, interval_sound appears");
+
+ test_begin (t, "The sound is used in NSR sum.")
+ {
+ scenario_entry_t fsm_base[300];
+ int pos = 0;
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_ACTION (
+ INTERVAL_SOUND__interval_sound, .sta = &sta,
+ .measure = measure,
+ .branch = ce_rx_bl_fsm_next (INTERVAL_SOUND,
+ interval_sound));
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_nsr_sum_add,
+ .bl = sta.intervals->intervals[tested_fsm_id]);
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_END;
+ scenario_run (t, fsm_base, &globals);
+ } test_end;
+
+ test_case_begin (t, "INTERVAL_SOUND, interval_sound_completed appears");
+
+ measure.rx_params.sound_complete = true;
+
+ test_begin (t, "sound_completed appears")
+ {
+ scenario_entry_t fsm_base[300];
+ int pos = 0;
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_ACTION (
+ INTERVAL_SOUND__interval_sound_completed, .sta = &sta,
+ .measure = measure,
+ .branch = ce_rx_bl_fsm_next (INTERVAL_SOUND,
+ interval_sound_completed));
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_nsr_sum_add,
+ .bl = sta.intervals->intervals[tested_fsm_id]);
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_nsr_compute_mean,
+ .bl = sta.intervals->intervals[tested_fsm_id]),
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_initial, .bl = sta.intervals->intervals[tested_fsm_id]);
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ tonemaps_set_first_free_tmi);
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_ber_sliding_mean_update,
+ .bl = sta.intervals->intervals[tested_fsm_id]);
+
+ /* - check the interval is updated with 0xFE */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_clear, .tms = &rx_tms);
+ int j;
+ for (j = 0; j < total_ints; j++)
+ {
+ if (j % mac_interval_fsm_count_ == tested_fsm_id)
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_append, .tms = &rx_tms, .tmi = DEFAULT_NEW_TMI);
+ else
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_append, .tms = &rx_tms, .tmi = tested_tmi);
+ }
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_commit_changes, .tms = &rx_tms);
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_cp_send_mme_new_tone_map,
+ .ce_rx = &ce, .peer = &sta,
+ .new_tmi = DEFAULT_NEW_TMI, .old_tmi = 0,
+ .initial_ce = false);
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_END;
+
+ scenario_run (t, fsm_base, &globals);
+ } test_end;
+
+ test_case_begin (t, "INTERVAL_SOUND, interval_data appears");
+
+ test_begin (t, "interval_data is ignored")
+ {
+ scenario_entry_t fsm_base[300];
+ int pos = 0;
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_ACTION (
+ INTERVAL_SOUND__interval_data, .sta = &sta,
+ .measure = measure,
+ .branch = ce_rx_bl_fsm_next (INTERVAL_SOUND,
+ interval_data));
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_END;
+ scenario_run (t, fsm_base, &globals);
+ } test_end;
+
+ /* Clean. */
+ ce_rx_bl_intervals_free (sta.intervals);
+}
+
+static void
+test_ce_rx_bl_fsm_INTERVAL_SOUND_WAIT (test_t t)
+{
+ mac_config_t config;
+ config.tonemask_info.carrier_nb = PHY_CARRIER_NB;
+ config.tonemask_info.tonemap_robo[PHY_MOD_ROBO].bits_per_symbol = 42;
+ bsu_aclf_t aclf;
+ *((bsu_aclf_bp_t*) &aclf.beacon_period_theo_tck) = BSU_ACLF_BP_50HZ_TCK;
+ int total_ints = mac_interval_fsm_count_ * mac_interval_repetition_count_;
+
+ ce_rx_t ce = { .mac_config = &config, .aclf = &aclf, .tck_per_rtc = 1};
+ scenario_globals_t globals = {
+ .ce = &ce,
+ };
+
+ ce_rx_measure_mbox_t measure;
+ u8 tested_tmi = DEFAULT_NEW_TMI + 1;
+ int tested_fsm_id = 2;
+ measure.fsm_id = tested_fsm_id;
+ measure.rx_params.sound = true;
+ measure.rx_params.sound_complete = false;
+
+ sta_t sta;
+ sta.intervals = ce_rx_bl_intervals_alloc (tested_tmi);
+ tonemaps_t rx_tms;
+ rx_tms.default_tmi = tested_tmi;
+ sta.rx_tonemaps = &rx_tms;
+
+ test_case_begin (t, "INTERVAL_SOUND_WAIT, interval_sound appears");
+
+ test_begin (t, "The sound is used in NSR sum.")
+ {
+ scenario_entry_t fsm_base[300];
+ int pos = 0;
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_ACTION (
+ INTERVAL_SOUND_WAIT__interval_sound, .sta = &sta,
+ .measure = measure,
+ .branch = ce_rx_bl_fsm_next (INTERVAL_SOUND_WAIT,
+ interval_sound));
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_nsr_sum_init,
+ .bl = sta.intervals->intervals[tested_fsm_id]);
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_END;
+ scenario_run (t, fsm_base, &globals);
+ } test_end;
+
+ test_case_begin (t, "INTERVAL_SOUND_WAIT, interval_sound_completed appears");
+
+ measure.rx_params.sound_complete = true;
+
+ test_begin (t, "sound_completed appears")
+ {
+ scenario_entry_t fsm_base[300];
+ int pos = 0;
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_ACTION (
+ INTERVAL_SOUND_WAIT__interval_sound_completed, .sta = &sta,
+ .measure = measure,
+ .branch = ce_rx_bl_fsm_next (INTERVAL_SOUND_WAIT,
+ interval_sound_completed));
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_nsr_sum_init,
+ .bl = sta.intervals->intervals[tested_fsm_id]);
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_nsr_compute_mean, .bl = sta.intervals->intervals[tested_fsm_id]),
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_initial, .bl = sta.intervals->intervals[tested_fsm_id]);
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ tonemaps_set_first_free_tmi);
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_bl_ber_sliding_mean_update,
+ .bl = sta.intervals->intervals[tested_fsm_id]);
+
+ /* - check the interval is updated with 0xFE */
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_clear, .tms = &rx_tms);
+ int j;
+ for (j = 0; j < total_ints; j++)
+ {
+ if (j % mac_interval_fsm_count_ == tested_fsm_id)
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_append, .tms = &rx_tms, .tmi = DEFAULT_NEW_TMI);
+ else
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_append, .tms = &rx_tms, .tmi = tested_tmi);
+ }
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ mac_interval_commit_changes, .tms = &rx_tms);
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_EVENT (
+ ce_rx_cp_send_mme_new_tone_map,
+ .ce_rx = &ce, .peer = &sta,
+ .new_tmi = DEFAULT_NEW_TMI, .old_tmi = 0,
+ .initial_ce = false);
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_END;
+
+
+ scenario_run (t, fsm_base, &globals);
+ } test_end;
+
+ test_case_begin (t, "INTERVAL_SOUND_WAIT, interval_data appears");
+
+ test_begin (t, "interval_data is ignored")
+ {
+ scenario_entry_t fsm_base[300];
+ int pos = 0;
+
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_ACTION (
+ INTERVAL_SOUND_WAIT__interval_data, .sta = &sta,
+ .measure = measure,
+ .branch = ce_rx_bl_fsm_next (INTERVAL_SOUND_WAIT,
+ interval_data));
+ fsm_base[pos++] = (scenario_entry_t) SCENARIO_END;
+ scenario_run (t, fsm_base, &globals);
+ } test_end;
+
+ /* Clean. */
+ ce_rx_bl_intervals_free (sta.intervals);
+}
+
+int
+main (int argc, char **argv)
+{
+ test_t t;
+ test_init (t, argc, argv);
+
+ test_suite_begin (t, "CE:RX:BL:INTERVALS: SUB FSM");
+ ce_rx_bl_ber_conf_init();
+ test_ce_rx_bl_fsm_INTERVAL_TRACKING (t);
+ test_ce_rx_bl_fsm_INTERVAL_SOUND (t);
+ test_ce_rx_bl_fsm_INTERVAL_SOUND_WAIT (t);
+
+ /* Memory check. */
+ test_case_begin (t, "General");
+ test_begin (t, "Memory")
+ {
+ test_fail_unless (blk_check_memory ());
+ } test_end;
+
+ test_result (t);
+ return test_nb_failed (t) == 0 ? 0 : 1;
+}
diff --git a/cesar/ce/rx/bitloading/test/src/scenario_events.c b/cesar/ce/rx/bitloading/test/src/scenario_events.c
index f37b6febb1..3d270c817e 100644
--- a/cesar/ce/rx/bitloading/test/src/scenario_events.c
+++ b/cesar/ce/rx/bitloading/test/src/scenario_events.c
@@ -56,3 +56,8 @@ tonemaps_reset (tonemaps_t *tms, tonemap_release_list_t *tm_release_list)
test_fail_unless (tms == params->tms);
test_fail_unless (tm_release_list);
}
+
+void
+tonemap_disable (tonemaps_t *tms, u8 tmi)
+{
+}
diff --git a/cesar/ce/rx/bitloading/test/src/test_ber_margin_update.c b/cesar/ce/rx/bitloading/test/src/test_ber_margin_update.c
index 4526c54fa3..45006e0a82 100644
--- a/cesar/ce/rx/bitloading/test/src/test_ber_margin_update.c
+++ b/cesar/ce/rx/bitloading/test/src/test_ber_margin_update.c
@@ -12,6 +12,7 @@
*/
#include "common/std.h"
+#include "ce/rx/rx.h"
#include "ce/rx/tonemask.h"
#include "ce/rx/bitloading/ber_margin_update.h"
#include "ce/rx/bitloading/inc/ber_margin_update.h"
@@ -21,6 +22,9 @@
#include "lib/test.h"
+/* Global CE/RX behavior stub. */
+ce_rx_behavior_t ce_rx_behavior = CE_RX_BEHAVIOR_INTERVALS_DISABLE;
+
void
test_ce_rx_bl_bmu (test_t t)
{
diff --git a/cesar/ce/rx/bitloading/test/src/test_bl.c b/cesar/ce/rx/bitloading/test/src/test_bl.c
index 3c876eff58..dfd219016a 100644
--- a/cesar/ce/rx/bitloading/test/src/test_bl.c
+++ b/cesar/ce/rx/bitloading/test/src/test_bl.c
@@ -14,6 +14,7 @@
#include "lib/test.h"
#include "lib/utils.h"
+#include "ce/rx/rx.h"
#include "ce_rx_bl_fsm_defs.h"
#include "ce/rx/bitloading/inc/nsr.h"
#include "ce/rx/bitloading/inc/ber.h"
@@ -58,6 +59,9 @@
*/
#define TONE_TOLERATED_ERROR (PHY_CARRIER_NB * 1 / 100)
+/* Global CE/RX behavior stub. */
+ce_rx_behavior_t ce_rx_behavior = CE_RX_BEHAVIOR_INTERVALS_DISABLE;
+
/**
* Prepare structures for a bit loading after NSR on sound received and mean
* has been computed.
diff --git a/cesar/ce/rx/bitloading/test/src/test_fsm.c b/cesar/ce/rx/bitloading/test/src/test_fsm.c
index 1498b26f5a..ef7ed7675e 100644
--- a/cesar/ce/rx/bitloading/test/src/test_fsm.c
+++ b/cesar/ce/rx/bitloading/test/src/test_fsm.c
@@ -12,6 +12,7 @@
*/
#include "common/std.h"
+#include "ce/rx/rx.h"
#include "ce/rx/inc/rx.h"
#include "ce/rx/bitloading/inc/ber_margin_update.h"
#include "ce/rx/bitloading/inc/ber.h"
@@ -70,6 +71,9 @@ extern uint ce_rx_bl_min_time_between_resend_tm_ms;
static uint const tmi_av = 24;
+/* Global CE/RX behavior stub. */
+ce_rx_behavior_t ce_rx_behavior = CE_RX_BEHAVIOR_INTERVALS_DISABLE;
+
static void
test_ce_rx_bl_measure_empty (ce_rx_measure_mbox_t *m)
{
diff --git a/cesar/ce/rx/bitloading/test/src/test_intervals.c b/cesar/ce/rx/bitloading/test/src/test_intervals.c
index 5bb8050fde..d31d68acce 100644
--- a/cesar/ce/rx/bitloading/test/src/test_intervals.c
+++ b/cesar/ce/rx/bitloading/test/src/test_intervals.c
@@ -23,6 +23,9 @@
#include "mac/common/timings.h"
#include "ce/rx/bitloading/fsm/fsm.h"
+/* Global CE/RX behavior stub. */
+ce_rx_behavior_t ce_rx_behavior = CE_RX_BEHAVIOR_INTERVALS_ENABLE;
+
/**
* Test suite for intervals init and uninit.
*/
diff --git a/cesar/ce/rx/bitloading/test/src/test_pber.c b/cesar/ce/rx/bitloading/test/src/test_pber.c
index 5bd39b526e..4ca6b814d6 100644
--- a/cesar/ce/rx/bitloading/test/src/test_pber.c
+++ b/cesar/ce/rx/bitloading/test/src/test_pber.c
@@ -10,12 +10,15 @@
*/
#include "common/std.h"
+#include "ce/rx/rx.h"
#include "ce/rx/bitloading/pber.h"
#include "ce/rx/bitloading/inc/pber.h"
#include "mac/common/defs.h"
#include "lib/test.h"
#include "pber_vector.h"
+/* Global CE/RX behavior stub. */
+ce_rx_behavior_t ce_rx_behavior = CE_RX_BEHAVIOR_INTERVALS_DISABLE;
/**
* Check computation of PBER sliding mean is correct.
diff --git a/cesar/ce/rx/bitloading/test/src/test_poly.c b/cesar/ce/rx/bitloading/test/src/test_poly.c
index 9cce55c75e..e95ef2f9d5 100644
--- a/cesar/ce/rx/bitloading/test/src/test_poly.c
+++ b/cesar/ce/rx/bitloading/test/src/test_poly.c
@@ -14,8 +14,12 @@
#include "lib/test.h"
+#include "ce/rx/rx.h"
#include "ce/rx/bitloading/inc/ber.h"
+/* Global CE/RX behavior stub. */
+ce_rx_behavior_t ce_rx_behavior = CE_RX_BEHAVIOR_INTERVALS_DISABLE;
+
void
test_ce_rx_poly (test_t t)
{
diff --git a/cesar/ce/rx/cp/stub/src/cp.c b/cesar/ce/rx/cp/stub/src/cp.c
index d621e40725..1088d8691e 100644
--- a/cesar/ce/rx/cp/stub/src/cp.c
+++ b/cesar/ce/rx/cp/stub/src/cp.c
@@ -53,3 +53,12 @@ void
ce_rx_cp_send_mme_restart_initial_ce (ce_rx_t *ctx, sta_t *sta)
{
}
+
+void
+ce_rx_cp_send_mme_refresh_tmi_list (ce_rx_t *ce_rx, sta_t *peer)
+__attribute__ ((weak));
+
+void
+ce_rx_cp_send_mme_refresh_tmi_list (ce_rx_t *ce_rx, sta_t *peer)
+{
+}
diff --git a/cesar/ce/rx/inc/trace.h b/cesar/ce/rx/inc/trace.h
index 4f56c3072f..5018695cf2 100644
--- a/cesar/ce/rx/inc/trace.h
+++ b/cesar/ce/rx/inc/trace.h
@@ -50,6 +50,9 @@ enum
CE_RX_TRACE_RESTART_BER,
CE_RX_TRACE_BMU_STATE,
CE_RX_TRACE_RESTART_BER_MARGIN_UPDATE,
+ CE_RX_TRACE_INTERVAL_SOUND_COMPLETE,
+ CE_RX_TRACE_INTERVAL_DATA_PB_ERR,
+ CE_RX_TRACE_INTERVAL_DATA_BER
};
BEGIN_DECLS
diff --git a/cesar/ce/rx/src/trace.c b/cesar/ce/rx/src/trace.c
index 0ab23d023c..68db6977b1 100644
--- a/cesar/ce/rx/src/trace.c
+++ b/cesar/ce/rx/src/trace.c
@@ -117,6 +117,12 @@ ce_rx_trace_init (ce_rx_t *ctx)
TIMESTAMP),
TRACE_EVENT (CE_RX_TRACE_RESTART_BER_MARGIN_UPDATE, "tei %d: "
"restart BER margin update (FEC rate: %u)", TIMESTAMP),
+ TRACE_EVENT (CE_RX_TRACE_INTERVAL_SOUND_COMPLETE, "tei %d: "
+ "fsm_id %d: interval %d", TIMESTAMP),
+ TRACE_EVENT (CE_RX_TRACE_INTERVAL_DATA_PB_ERR, "tei %d: "
+ "interval %d", TIMESTAMP),
+ TRACE_EVENT (CE_RX_TRACE_INTERVAL_DATA_BER, "tei %d: "
+ "interval %d", TIMESTAMP),
};
dbg_assert (ctx);
trace_namespace_init (&namespace, event_ids, COUNT (event_ids));