# HG changeset patch
# User paul
# Date 2015-01-15 06:23:34
# Node ID f0fdfd2b8c4c2b5139740ff3455092715e69f163
# Parent  9b2f5df5b110ff27212ec35138920a52ad3160d4

Integration of basic parameters functions in the flight software
BP1 and BP2 are computed
constant LSB_FIRST_TCH is defined (will be removed later)
k coefficients are initialized in the init task
v, e1 and e2 are read directly in buffers and put in HK packets
sending functions slightly modified
spectral matrices are now correctly timestamped

a few changes to LFR_basic-parameters

diff --git a/.hgsubstate b/.hgsubstate
--- a/.hgsubstate
+++ b/.hgsubstate
@@ -1,2 +1,2 @@
-19349b3a5e90c2bacc9d369aa948c68aa9e8d5f0 LFR_basic-parameters
-da5613aff4446e5c98b3c56bc32ce7008b3e2340 header/lfr_common_headers
+a309a930a482e851061936696121f4a1cf7005de LFR_basic-parameters
+2b5dc338fb623046072d6eb98c26ad884e17f95e header/lfr_common_headers
diff --git a/FSW-qt/fsw-qt.pro b/FSW-qt/fsw-qt.pro
--- a/FSW-qt/fsw-qt.pro
+++ b/FSW-qt/fsw-qt.pro
@@ -12,7 +12,7 @@ SWVERSION=-1-0
 DEFINES += SW_VERSION_N1=2 # major
 DEFINES += SW_VERSION_N2=0 # minor
 DEFINES += SW_VERSION_N3=2 # patch
-DEFINES += SW_VERSION_N4=0 # internal
+DEFINES += SW_VERSION_N4=1 # internal
 
 # <GCOV>
 #QMAKE_CFLAGS_RELEASE += -fprofile-arcs -ftest-coverage
@@ -28,6 +28,7 @@ contains( CONFIG, lpp_dpu_destid ) {
 contains( CONFIG, debug_tch ) {
     DEFINES += DEBUG_TCH
 }
+DEFINES += LSB_FIRST_TCH
 
 contains( CONFIG, vhdl_dev ) {
     DEFINES += VHDL_DEV
@@ -64,7 +65,7 @@ INCLUDEPATH += \
     $${PWD}/../header \
     $${PWD}/../header/lfr_common_headers \
     $${PWD}/../header/processing \
-    $${PWD}/../src/LFR_basic-parameters
+    $${PWD}/../LFR_basic-parameters
 
 SOURCES += \
     ../src/wf_handler.c \
@@ -81,7 +82,7 @@ SOURCES += \
     ../src/processing/avf1_prc1.c \
     ../src/processing/avf2_prc2.c \
     ../src/lfr_cpu_usage_report.c \
-    ../src/LFR_basic-parameters/basic_parameters.c
+    ../LFR_basic-parameters/basic_parameters.c
 
 HEADERS += \
     ../header/wf_handler.h \
@@ -99,12 +100,12 @@ HEADERS += \
     ../header/processing/avf2_prc2.h \
     ../header/fsw_params_wf_handler.h \
     ../header/lfr_cpu_usage_report.h \
-    ../src/LFR_basic-parameters/basic_parameters.h \
-    ../src/LFR_basic-parameters/basic_parameters_params.h \
     ../header/lfr_common_headers/ccsds_types.h \
     ../header/lfr_common_headers/fsw_params.h \
     ../header/lfr_common_headers/fsw_params_nb_bytes.h \
     ../header/lfr_common_headers/fsw_params_processing.h \
     ../header/lfr_common_headers/TC_types.h \
-    ../header/lfr_common_headers/tm_byte_positions.h
+    ../header/lfr_common_headers/tm_byte_positions.h \
+    ../LFR_basic-parameters/basic_parameters.h \
+    ../LFR_basic-parameters/basic_parameters_params.h
 
diff --git a/header/grlib_regs.h b/header/grlib_regs.h
--- a/header/grlib_regs.h
+++ b/header/grlib_regs.h
@@ -90,6 +90,10 @@ typedef struct{
     volatile unsigned int f3_1_fine_time;   // 0x88
     //
     unsigned int buffer_length;             // 0x8c = buffer length in burst 2688 / 16 = 168
+    //
+    volatile unsigned int v;                // 0x90
+    volatile unsigned int e1;               // 0x94
+    volatile unsigned int e2;               // 0x98
 } waveform_picker_regs_0_1_18_t;
 
 typedef struct {
@@ -111,7 +115,7 @@ typedef struct {
     volatile unsigned int f1_0_coarse_time; // 0x30
     volatile unsigned int f1_0_fine_time;   // 0x34
     volatile unsigned int f1_1_coarse_time; // 0x38
-    volatile unsigned int f1_1_time_time;   // 0x3C
+    volatile unsigned int f1_1_fine_time;   // 0x3C
     //
     volatile unsigned int f2_0_coarse_time; // 0x40
     volatile unsigned int f2_0_fine_time;   // 0x44
diff --git a/header/processing/avf0_prc0.h b/header/processing/avf0_prc0.h
--- a/header/processing/avf0_prc0.h
+++ b/header/processing/avf0_prc0.h
@@ -27,10 +27,11 @@ rtems_task prc0_task( rtems_task_argumen
 // FUNCTIONS
 
 void reset_nb_sm_f0( unsigned char lfrMode );
+void init_k_coefficients_f0( void );
+void test_TCH( void );
 
 //*******
 // EXTERN
-extern ring_node *ring_node_for_averaging_sm_f0;
 extern rtems_status_code get_message_queue_id_prc0( rtems_id *queue_id );
 
 #endif // AVF0_PRC0_H_INCLUDED
diff --git a/header/processing/avf1_prc1.h b/header/processing/avf1_prc1.h
--- a/header/processing/avf1_prc1.h
+++ b/header/processing/avf1_prc1.h
@@ -2,6 +2,7 @@
 #define AVF1_PRC1_H
 
 #include "fsw_processing.h"
+#include "basic_parameters.h"
 
 typedef struct {
     unsigned int norm_bp1;
@@ -24,10 +25,10 @@ rtems_task prc1_task( rtems_task_argumen
 // FUNCTIONS
 
 void reset_nb_sm_f1( unsigned char lfrMode );
+void init_k_coefficients_f1( void );
 
 //*******
 // EXTERN
-extern struct ring_node *ring_node_for_averaging_sm_f1;
 extern rtems_status_code get_message_queue_id_prc1( rtems_id *queue_id );
 
 #endif // AVF1_PRC1_H
diff --git a/header/processing/avf2_prc2.h b/header/processing/avf2_prc2.h
--- a/header/processing/avf2_prc2.h
+++ b/header/processing/avf2_prc2.h
@@ -2,6 +2,7 @@
 #define AVF2_PRC2_H
 
 #include "fsw_processing.h"
+#include "basic_parameters.h"
 
 typedef struct {
     unsigned int norm_bp1;
@@ -18,11 +19,11 @@ rtems_task prc2_task( rtems_task_argumen
 // FUNCTIONS
 
 void reset_nb_sm_f2( void );
-void SM_average_f2(float *averaged_spec_mat_f2, ring_node *ring_node, unsigned int nbAverageNormF2 );
+void SM_average_f2(float *averaged_spec_mat_f2, ring_node *ring_node, unsigned int nbAverageNormF2 , asm_msg *msgForMATR);
+void init_k_coefficients_f2( void );
 
 //*******
 // EXTERN
-extern struct ring_node *ring_node_for_averaging_sm_f2;
 extern rtems_status_code get_message_queue_id_prc2( rtems_id *queue_id );
 
 #endif // AVF2_PRC2_H
diff --git a/header/processing/fsw_processing.h b/header/processing/fsw_processing.h
--- a/header/processing/fsw_processing.h
+++ b/header/processing/fsw_processing.h
@@ -21,7 +21,25 @@ typedef struct ring_node_asm
 
 typedef struct
 {
-    Header_TM_LFR_SCIENCE_BP_t header;
+    unsigned char targetLogicalAddress;
+    unsigned char protocolIdentifier;
+    unsigned char reserved;
+    unsigned char userApplication;
+    unsigned char packetID[2];
+    unsigned char packetSequenceControl[2];
+    unsigned char packetLength[2];
+    // DATA FIELD HEADER
+    unsigned char spare1_pusVersion_spare2;
+    unsigned char serviceType;
+    unsigned char serviceSubType;
+    unsigned char destinationID;
+    unsigned char time[6];
+    // AUXILIARY HEADER
+    unsigned char sid;
+    unsigned char biaStatusInfo;
+    unsigned char acquisitionTime[6];
+    unsigned char pa_lfr_bp_blk_nr[2];
+    // SOURCE DATA
     unsigned char data[ 30 * 22 ];   // MAX size is 22 * 30 [TM_LFR_SCIENCE_BURST_BP2_F1]
 } bp_packet;
 
@@ -36,8 +54,10 @@ typedef struct
     ring_node_asm *norm;
     ring_node_asm *burst_sbm;
     rtems_event_set event;
-    unsigned int coarseTime;
-    unsigned int fineTime;
+    unsigned int coarseTimeNORM;
+    unsigned int fineTimeNORM;
+    unsigned int coarseTimeSBM;
+    unsigned int fineTimeSBM;
 } asm_msg;
 
 extern volatile int sm_f0[ ];
@@ -49,11 +69,13 @@ extern struct param_local_str param_loca
 
 // registers
 extern time_management_regs_t *time_management_regs;
-extern spectral_matrix_regs_t *spectral_matrix_regs;
+extern volatile spectral_matrix_regs_t *spectral_matrix_regs;
 
 extern rtems_name  misc_name[5];
 extern rtems_id    Task_id[20];         /* array of task ids */
 
+//
+ring_node * getRingNodeForAveraging( unsigned char frequencyChannel);
 // ISR
 rtems_isr spectral_matrices_isr( rtems_vector_number vector );
 rtems_isr spectral_matrices_isr_simu( rtems_vector_number vector );
@@ -71,7 +93,7 @@ void ASM_generic_init_ring(ring_node_asm
 // Basic Parameters
 
 void BP_reset_current_ring_nodes( void );
-void BP_init_header( Header_TM_LFR_SCIENCE_BP_t *header,
+void BP_init_header(bp_packet *header,
                      unsigned int apid, unsigned char sid,
                      unsigned int packetLength , unsigned char blkNr);
 void BP_init_header_with_spare( Header_TM_LFR_SCIENCE_BP_with_spare_t *header,
@@ -87,8 +109,6 @@ void reset_sm_status( void );
 void reset_spectral_matrix_regs( void );
 void set_time(unsigned char *time, unsigned char *timeInBuffer );
 unsigned long long int get_acquisition_time( unsigned char *timePtr );
-void close_matrix_actions( unsigned int *nb_sm, unsigned int nb_sm_before_avf, rtems_id avf_task_id,
-                           ring_node *node_for_averaging, ring_node *ringNode, unsigned long long int time );
 unsigned char getSID( rtems_event_set event );
 
 extern rtems_status_code get_message_queue_id_prc1( rtems_id *queue_id );
@@ -97,11 +117,12 @@ extern rtems_status_code get_message_que
 //***************************************
 // DEFINITIONS OF STATIC INLINE FUNCTIONS
 static inline void SM_average(float *averaged_spec_mat_NORM, float *averaged_spec_mat_SBM,
-                  ring_node *ring_node_tab[],
-                  unsigned int nbAverageNORM, unsigned int nbAverageSBM );
+                              ring_node *ring_node_tab[],
+                              unsigned int nbAverageNORM, unsigned int nbAverageSBM,
+                              asm_msg *msgForMATR );
 static inline void SM_average_debug( float *averaged_spec_mat_NORM, float *averaged_spec_mat_SBM,
-                  ring_node *ring_node_tab[],
-                  unsigned int nbAverageNORM, unsigned int nbAverageSBM );
+                                     ring_node *ring_node_tab[],
+                                     unsigned int nbAverageNORM, unsigned int nbAverageSBM );
 static inline void ASM_reorganize_and_divide(float *averaged_spec_mat, float *averaged_spec_mat_reorganized,
                                float divider );
 static inline void ASM_compress_reorganize_and_divide(float *averaged_spec_mat, float *compressed_spec_mat,
@@ -110,8 +131,9 @@ static inline void ASM_compress_reorgani
 static inline void ASM_convert(volatile float *input_matrix, char *output_matrix);
 
 void SM_average( float *averaged_spec_mat_NORM, float *averaged_spec_mat_SBM,
-                  ring_node *ring_node_tab[],
-                  unsigned int nbAverageNORM, unsigned int nbAverageSBM )
+                 ring_node *ring_node_tab[],
+                 unsigned int nbAverageNORM, unsigned int nbAverageSBM,
+                 asm_msg *msgForMATR )
 {
     float sum;
     unsigned int i;
@@ -131,6 +153,10 @@ void SM_average( float *averaged_spec_ma
         {
             averaged_spec_mat_NORM[ i ] = sum;
             averaged_spec_mat_SBM[  i ] = sum;
+            msgForMATR->coarseTimeNORM  = ring_node_tab[0]->coarseTime;
+            msgForMATR->fineTimeNORM    = ring_node_tab[0]->fineTime;
+            msgForMATR->coarseTimeSBM   = ring_node_tab[0]->coarseTime;
+            msgForMATR->fineTimeSBM     = ring_node_tab[0]->fineTime;
         }
         else if ( (nbAverageNORM != 0) && (nbAverageSBM != 0) )
         {
@@ -141,6 +167,8 @@ void SM_average( float *averaged_spec_ma
         {
             averaged_spec_mat_NORM[ i ] = ( averaged_spec_mat_NORM[ i ] + sum );
             averaged_spec_mat_SBM[  i ] = sum;
+            msgForMATR->coarseTimeSBM   = ring_node_tab[0]->coarseTime;
+            msgForMATR->fineTimeSBM     = ring_node_tab[0]->fineTime;
         }
         else
         {
@@ -186,21 +214,22 @@ void ASM_reorganize_and_divide( float *a
 {
     int frequencyBin;
     int asmComponent;
-    unsigned int offsetAveragedSpecMatReorganized;
-    unsigned int offsetAveragedSpecMat;
+    unsigned int offsetASM;
+    unsigned int offsetASMReorganized;
 
+    // BUILD DATA
     for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++)
     {
         for( frequencyBin = 0; frequencyBin < NB_BINS_PER_SM; frequencyBin++ )
         {
-            offsetAveragedSpecMatReorganized =
+            offsetASMReorganized =
                     frequencyBin * NB_VALUES_PER_SM
                     + asmComponent;
-            offsetAveragedSpecMat            =
+            offsetASM            =
                     asmComponent * NB_BINS_PER_SM
                     + frequencyBin;
-            averaged_spec_mat_reorganized[offsetAveragedSpecMatReorganized  ] =
-                    averaged_spec_mat[ offsetAveragedSpecMat ] / divider;
+            averaged_spec_mat_reorganized[offsetASMReorganized  ] =
+                    averaged_spec_mat[ offsetASM ] / divider;
         }
     }
 }
@@ -214,7 +243,7 @@ void ASM_compress_reorganize_and_divide(
     int offsetCompressed;
     int k;
 
-    // build data
+    // BUILD DATA
     for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++)
     {
         for( frequencyBin = 0; frequencyBin < nbBinsCompressedMatrix; frequencyBin++ )
@@ -231,8 +260,10 @@ void ASM_compress_reorganize_and_divide(
             {
                 compressed_spec_mat[offsetCompressed ] =
                         ( compressed_spec_mat[ offsetCompressed ]
-                        + averaged_spec_mat[ offsetASM + k ] ) / (divider * nbBinsToAverage);
+                        + averaged_spec_mat[ offsetASM + k ] );
             }
+            compressed_spec_mat[ offsetCompressed ] =
+                    compressed_spec_mat[ offsetCompressed ] / (divider * nbBinsToAverage);
         }
     }
 }
diff --git a/src/fsw_init.c b/src/fsw_init.c
--- a/src/fsw_init.c
+++ b/src/fsw_init.c
@@ -108,6 +108,9 @@ rtems_task Init( rtems_task_argument ign
     init_parameter_dump();
     init_local_mode_parameters();
     init_housekeeping_parameters();
+    init_k_coefficients_f0();
+    init_k_coefficients_f1();
+    init_k_coefficients_f2();
 
     // waveform picker initialization
     WFP_init_rings();      // initialize the waveform rings
@@ -215,6 +218,8 @@ rtems_task Init( rtems_task_argument ign
 
     BOOT_PRINTF("delete INIT\n")
 
+//    test_TCH();
+
     status = rtems_task_delete(RTEMS_SELF);
 
 }
diff --git a/src/fsw_misc.c b/src/fsw_misc.c
--- a/src/fsw_misc.c
+++ b/src/fsw_misc.c
@@ -225,7 +225,7 @@ rtems_task hous_task(rtems_task_argument
 
             spacewire_update_statistics();
 
-//            get_v_e1_e2_f3( housekeeping_packet.hk_lfr_sc_v_f3 );
+            get_v_e1_e2_f3( housekeeping_packet.hk_lfr_sc_v_f3 );
             get_cpu_load( (unsigned char *) &housekeeping_packet.hk_lfr_cpu_load );
 
             // SEND PACKET
@@ -443,107 +443,20 @@ void send_dumb_hk( void )
 
 void get_v_e1_e2_f3( unsigned char *spacecraft_potential )
 {
-    unsigned long long int localTime_asLong;
-    unsigned long long int f3_0_AcquisitionTime_asLong;
-    unsigned long long int f3_1_AcquisitionTime_asLong;
-    unsigned long long int deltaT;
-    unsigned long long int deltaT_f3_0;
-    unsigned long long int deltaT_f3_1;
-    unsigned char *bufferPtr;
-
-    unsigned int offset_in_samples;
-    unsigned int offset_in_bytes;
-    unsigned char f3;
-
-    bufferPtr = NULL;
-    deltaT = 0;
-    deltaT_f3_0 = 0xffffffff;
-    deltaT_f3_1 = 0xffffffff;
-    f3 = 16;    // v, e1 and e2 will be picked up each second, f3 = 16 Hz
-
-    if (lfrCurrentMode == LFR_MODE_STANDBY)
-    {
-        spacecraft_potential[0] = 0x00;
-        spacecraft_potential[1] = 0x00;
-        spacecraft_potential[2] = 0x00;
-        spacecraft_potential[3] = 0x00;
-        spacecraft_potential[4] = 0x00;
-        spacecraft_potential[5] = 0x00;
-    }
-    else
-    {
-        localTime_asLong = get_acquisition_time( (unsigned char *) &time_management_regs->coarse_time );
-        f3_0_AcquisitionTime_asLong = get_acquisition_time( (unsigned char *) &waveform_picker_regs->f3_0_coarse_time );
-        f3_1_AcquisitionTime_asLong = get_acquisition_time( (unsigned char *) &waveform_picker_regs->f3_1_coarse_time );
-        printf("localTime 0x%llx, f3_0 0x%llx, f3_1 0x%llx\n",
-               localTime_asLong,
-               f3_0_AcquisitionTime_asLong,
-               f3_1_AcquisitionTime_asLong);
-
-        if ( localTime_asLong >= f3_0_AcquisitionTime_asLong )
-        {
-            deltaT_f3_0 = localTime_asLong - f3_0_AcquisitionTime_asLong;
-        }
-
-        if ( localTime_asLong > f3_1_AcquisitionTime_asLong )
-        {
-            deltaT_f3_1 = localTime_asLong - f3_1_AcquisitionTime_asLong;
-        }
+    unsigned char* v_ptr;
+    unsigned char* e1_ptr;
+    unsigned char* e2_ptr;
 
-        if ( (deltaT_f3_0 != 0xffffffff) && (deltaT_f3_1 != 0xffffffff) )
-        {
-            if ( deltaT_f3_0 > deltaT_f3_1 )
-            {
-                deltaT = deltaT_f3_1;
-                bufferPtr = (unsigned char*) waveform_picker_regs->addr_data_f3_1;
-            }
-            else
-            {
-                deltaT = deltaT_f3_0;
-                bufferPtr = (unsigned char*) waveform_picker_regs->addr_data_f3_0;
-            }
-        }
-        else if ( (deltaT_f3_0 == 0xffffffff) && (deltaT_f3_1 != 0xffffffff) )
-        {
-            deltaT = deltaT_f3_1;
-            bufferPtr = (unsigned char*) waveform_picker_regs->addr_data_f3_1;
-        }
-        else if ( (deltaT_f3_0 != 0xffffffff) && (deltaT_f3_1 == 0xffffffff) )
-        {
-            deltaT = deltaT_f3_0;
-            bufferPtr = (unsigned char*) waveform_picker_regs->addr_data_f3_1;
-        }
-        else
-        {
-            deltaT = 0xffffffff;
-        }
+    v_ptr  = (unsigned char *) &waveform_picker_regs->v;
+    e1_ptr = (unsigned char *) &waveform_picker_regs->e1;
+    e2_ptr = (unsigned char *) &waveform_picker_regs->e2;
 
-        if ( deltaT == 0xffffffff )
-        {
-            spacecraft_potential[0] = 0x00;
-            spacecraft_potential[1] = 0x00;
-            spacecraft_potential[2] = 0x00;
-            spacecraft_potential[3] = 0x00;
-            spacecraft_potential[4] = 0x00;
-            spacecraft_potential[5] = 0x00;
-        }
-        else
-        {
-            offset_in_samples = ( (double) deltaT ) / 65536. * f3;
-            if ( offset_in_samples > (NB_SAMPLES_PER_SNAPSHOT - 1) )
-            {
-                PRINTF1("ERR *** in get_v_e1_e2_f3 *** trying to read out of the buffer, counter = %d\n", offset_in_samples)
-                offset_in_samples = NB_SAMPLES_PER_SNAPSHOT - 1;
-            }
-            offset_in_bytes = offset_in_samples * NB_WORDS_SWF_BLK * 4;
-            spacecraft_potential[0] = bufferPtr[ offset_in_bytes + 0];
-            spacecraft_potential[1] = bufferPtr[ offset_in_bytes + 1];
-            spacecraft_potential[2] = bufferPtr[ offset_in_bytes + 2];
-            spacecraft_potential[3] = bufferPtr[ offset_in_bytes + 3];
-            spacecraft_potential[4] = bufferPtr[ offset_in_bytes + 4];
-            spacecraft_potential[5] = bufferPtr[ offset_in_bytes + 5];
-        }
-    }
+    spacecraft_potential[0] = v_ptr[2];
+    spacecraft_potential[1] = v_ptr[3];
+    spacecraft_potential[2] = e1_ptr[2];
+    spacecraft_potential[3] = e1_ptr[3];
+    spacecraft_potential[4] = e2_ptr[2];
+    spacecraft_potential[5] = e2_ptr[3];
 }
 
 void get_cpu_load( unsigned char *resource_statistics )
diff --git a/src/fsw_spacewire.c b/src/fsw_spacewire.c
--- a/src/fsw_spacewire.c
+++ b/src/fsw_spacewire.c
@@ -690,8 +690,8 @@ void init_header_cwf( Header_TM_LFR_SCIE
     header->userApplication = CCSDS_USER_APP;
     header->packetSequenceControl[0]    = TM_PACKET_SEQ_CTRL_STANDALONE;
     header->packetSequenceControl[1]    = TM_PACKET_SEQ_CNT_DEFAULT;
-    header->packetLength[0] = (unsigned char) (TM_LEN_SCI_CWF_336 >> 8);
-    header->packetLength[1] = (unsigned char) (TM_LEN_SCI_CWF_336     );
+    header->packetLength[0] = 0x00;
+    header->packetLength[1] = 0x00;
     // DATA FIELD HEADER
     header->spare1_pusVersion_spare2    = DEFAULT_SPARE1_PUSVERSION_SPARE2;
     header->serviceType     = TM_TYPE_LFR_SCIENCE; // service type
@@ -706,8 +706,8 @@ void init_header_cwf( Header_TM_LFR_SCIE
     // AUXILIARY DATA HEADER
     header->sid = 0x00;
     header->hkBIA = DEFAULT_HKBIA;
-    header->blkNr[0] = (unsigned char) (BLK_NR_CWF >> 8);
-    header->blkNr[1] = (unsigned char) (BLK_NR_CWF     );
+    header->blkNr[0] = 0x00;
+    header->blkNr[1] = 0x00;
 }
 
 void init_header_swf( Header_TM_LFR_SCIENCE_SWF_t *header )
@@ -808,6 +808,11 @@ int spw_send_waveform_CWF( ring_node *ri
     fineTime    = ring_node_to_send->fineTime;
     dataPtr     = (int*) ring_node_to_send->buffer_address;
 
+    header->packetLength[0] = (unsigned char) (TM_LEN_SCI_CWF_336 >> 8);
+    header->packetLength[1] = (unsigned char) (TM_LEN_SCI_CWF_336     );
+    header->blkNr[0] = (unsigned char) (BLK_NR_CWF >> 8);
+    header->blkNr[1] = (unsigned char) (BLK_NR_CWF     );
+
     for (i=0; i<NB_PACKETS_PER_GROUP_OF_CWF; i++) // send waveform
     {
         spw_ioctl_send_CWF.data = (char*) &dataPtr[ (i * BLK_NR_CWF * NB_WORDS_SWF_BLK) ];
@@ -974,6 +979,11 @@ int spw_send_waveform_CWF3_light( ring_n
     fineTime    = ring_node_to_send->fineTime;
     dataPtr     = (char*) ring_node_to_send->buffer_address;
 
+    header->packetLength[0] = (unsigned char) (TM_LEN_SCI_CWF_672 >> 8);
+    header->packetLength[1] = (unsigned char) (TM_LEN_SCI_CWF_672     );
+    header->blkNr[0] = (unsigned char) (BLK_NR_CWF_SHORT_F3 >> 8);
+    header->blkNr[1] = (unsigned char) (BLK_NR_CWF_SHORT_F3     );
+
     //*********************
     // SEND CWF3_light DATA
     for (i=0; i<NB_PACKETS_PER_GROUP_OF_CWF_LIGHT; i++) // send waveform
diff --git a/src/processing/avf0_prc0.c b/src/processing/avf0_prc0.c
--- a/src/processing/avf0_prc0.c
+++ b/src/processing/avf0_prc0.c
@@ -24,8 +24,9 @@ float asm_f0_reorganized   [ TOTAL_SIZE_
 char  asm_f0_char          [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ];
 float compressed_sm_norm_f0[ TOTAL_SIZE_COMPRESSED_ASM_NORM_F0];
 float compressed_sm_sbm_f0 [ TOTAL_SIZE_COMPRESSED_ASM_SBM_F0 ];
-//unsigned char bp1_norm_f0  [ TOTAL_SIZE_BP1_NORM_F0 ];
-//unsigned char bp1_sbm_f0   [ TOTAL_SIZE_BP1_SBM_F0  ];
+
+float k_coeff_intercalib_f0_norm[ NB_BINS_COMPRESSED_SM_F0     * NB_K_COEFF_PER_BIN ];  // 11 * 32 = 352
+float k_coeff_intercalib_f0_sbm[  NB_BINS_COMPRESSED_SM_SBM_F0 * NB_K_COEFF_PER_BIN ];  // 22 * 32 = 704
 
 //************
 // RTEMS TASKS
@@ -38,6 +39,7 @@ rtems_task avf0_task( rtems_task_argumen
     rtems_status_code status;
     rtems_id queue_id_prc0;
     asm_msg msgForMATR;
+    ring_node *nodeForAveraging;
     ring_node *ring_node_tab[8];
     ring_node_asm *current_ring_node_asm_burst_sbm_f0;
     ring_node_asm *current_ring_node_asm_norm_f0;
@@ -76,23 +78,24 @@ rtems_task avf0_task( rtems_task_argumen
         msgForMATR.norm       = current_ring_node_asm_norm_f0;
         msgForMATR.burst_sbm  = current_ring_node_asm_burst_sbm_f0;
         msgForMATR.event      = 0x00;  // this composite event will be sent to the PRC0 task
-        msgForMATR.coarseTime = ring_node_for_averaging_sm_f0->coarseTime;
-        msgForMATR.fineTime   = ring_node_for_averaging_sm_f0->fineTime;
         //
         //****************************************
 
-        ring_node_tab[NB_SM_BEFORE_AVF0-1] = ring_node_for_averaging_sm_f0;
+        nodeForAveraging = getRingNodeForAveraging( 0 );
+
+        ring_node_tab[NB_SM_BEFORE_AVF0-1] = nodeForAveraging;
         for ( i = 2; i < (NB_SM_BEFORE_AVF0+1); i++ )
         {
-            ring_node_for_averaging_sm_f0 = ring_node_for_averaging_sm_f0->previous;
-            ring_node_tab[NB_SM_BEFORE_AVF0-i] = ring_node_for_averaging_sm_f0;
+            nodeForAveraging = nodeForAveraging->previous;
+            ring_node_tab[NB_SM_BEFORE_AVF0-i] = nodeForAveraging;
         }
 
         // compute the average and store it in the averaged_sm_f1 buffer
         SM_average( current_ring_node_asm_norm_f0->matrix,
                     current_ring_node_asm_burst_sbm_f0->matrix,
                     ring_node_tab,
-                    nb_norm_bp1, nb_sbm_bp1 );
+                    nb_norm_bp1, nb_sbm_bp1,
+                    &msgForMATR );
 
         // update nb_average
         nb_norm_bp1 = nb_norm_bp1 + NB_SM_BEFORE_AVF0;
@@ -157,7 +160,6 @@ rtems_task avf0_task( rtems_task_argumen
             if ( (lfrCurrentMode == LFR_MODE_NORMAL)
                  || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )
             {
-//                PRINTF1("%lld\n", localTime)
                 msgForMATR.event = msgForMATR.event | RTEMS_EVENT_NORM_ASM_F0;
             }
         }
@@ -185,10 +187,10 @@ rtems_task prc0_task( rtems_task_argumen
     rtems_status_code status;
     rtems_id queue_id;
     rtems_id queue_id_q_p0;
-    bp_packet_with_spare    packet_norm_bp1_f0;
-    bp_packet               packet_norm_bp2_f0;
-    bp_packet               packet_sbm_bp1_f0;
-    bp_packet               packet_sbm_bp2_f0;
+    bp_packet_with_spare    packet_norm_bp1;
+    bp_packet               packet_norm_bp2;
+    bp_packet               packet_sbm_bp1;
+    bp_packet               packet_sbm_bp2;
     ring_node               *current_ring_node_to_send_asm_f0;
 
     unsigned long long int localTime;
@@ -199,10 +201,10 @@ rtems_task prc0_task( rtems_task_argumen
 
     //*************
     // NORM headers
-    BP_init_header_with_spare( &packet_norm_bp1_f0.header,
+    BP_init_header_with_spare( &packet_norm_bp1.header,
                                APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP1_F0,
                                PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0, NB_BINS_COMPRESSED_SM_F0 );
-    BP_init_header( &packet_norm_bp2_f0.header,
+    BP_init_header( &packet_norm_bp2,
                     APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP2_F0,
                     PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0, NB_BINS_COMPRESSED_SM_F0);
 
@@ -210,28 +212,28 @@ rtems_task prc0_task( rtems_task_argumen
     // BURST SBM1 and SBM2 headers
     if ( lfrRequestedMode == LFR_MODE_BURST )
     {
-        BP_init_header( &packet_sbm_bp1_f0.header,
+        BP_init_header( &packet_sbm_bp1,
                         APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP1_F0,
                         PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
-        BP_init_header( &packet_sbm_bp2_f0.header,
+        BP_init_header( &packet_sbm_bp2,
                         APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP2_F0,
                         PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
     }
     else if ( lfrRequestedMode == LFR_MODE_SBM1 )
     {
-        BP_init_header( &packet_sbm_bp1_f0.header,
+        BP_init_header( &packet_sbm_bp1,
                         APID_TM_SCIENCE_SBM1_SBM2, SID_SBM1_BP1_F0,
                         PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
-        BP_init_header( &packet_sbm_bp2_f0.header,
+        BP_init_header( &packet_sbm_bp2,
                         APID_TM_SCIENCE_SBM1_SBM2, SID_SBM1_BP2_F0,
                         PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
     }
     else if ( lfrRequestedMode == LFR_MODE_SBM2 )
     {
-        BP_init_header( &packet_sbm_bp1_f0.header,
+        BP_init_header( &packet_sbm_bp1,
                         APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP1_F0,
                         PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
-        BP_init_header( &packet_sbm_bp2_f0.header,
+        BP_init_header( &packet_sbm_bp2,
                         APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP2_F0,
                         PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
     }
@@ -275,22 +277,22 @@ rtems_task prc0_task( rtems_task_argumen
                                          NB_BINS_COMPRESSED_SM_SBM_F0, NB_BINS_TO_AVERAGE_ASM_SBM_F0,
                                          ASM_F0_INDICE_START);
             // 2) compute the BP1 set
-//            BP1_set( compressed_sm_norm_f0, NB_BINS_COMPRESSED_SM_SBM_F0, bp1_sbm_f0 );
+            BP1_set( compressed_sm_sbm_f0, k_coeff_intercalib_f0_sbm, NB_BINS_COMPRESSED_SM_SBM_F0, packet_sbm_bp1.data );
             // 3) send the BP1 set
-            set_time( packet_sbm_bp1_f0.header.time,            (unsigned char *) &incomingMsg->coarseTime );
-            set_time( packet_sbm_bp1_f0.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
-            BP_send( (char *) &packet_sbm_bp1_f0, queue_id,
+            set_time( packet_sbm_bp1.time,            (unsigned char *) &incomingMsg->coarseTimeSBM );
+            set_time( packet_sbm_bp1.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeSBM );
+            BP_send( (char *) &packet_sbm_bp1, queue_id,
                      PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0 + PACKET_LENGTH_DELTA,
                      sid);
             // 4) compute the BP2 set if needed
             if ( (incomingMsg->event & RTEMS_EVENT_BURST_BP2_F0) || (incomingMsg->event & RTEMS_EVENT_SBM_BP2_F0) )
             {
                 // 1) compute the BP2 set
-
+                BP2_set( compressed_sm_sbm_f0, NB_BINS_COMPRESSED_SM_SBM_F0, packet_sbm_bp2.data );
                 // 2) send the BP2 set
-                set_time( packet_sbm_bp2_f0.header.time,            (unsigned char *) &incomingMsg->coarseTime );
-                set_time( packet_sbm_bp2_f0.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
-                BP_send( (char *) &packet_sbm_bp2_f0, queue_id,
+                set_time( packet_sbm_bp2.time,            (unsigned char *) &incomingMsg->coarseTimeSBM );
+                set_time( packet_sbm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeSBM );
+                BP_send( (char *) &packet_sbm_bp2, queue_id,
                          PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0 + PACKET_LENGTH_DELTA,
                          sid);
             }
@@ -309,23 +311,63 @@ rtems_task prc0_task( rtems_task_argumen
                                          NB_BINS_COMPRESSED_SM_F0, NB_BINS_TO_AVERAGE_ASM_F0,
                                          ASM_F0_INDICE_START );
             // 2) compute the BP1 set
-//            BP1_set( compressed_sm_norm_f0, NB_BINS_COMPRESSED_SM_F0, bp1_norm_f0 );
+            BP1_set( compressed_sm_norm_f0, k_coeff_intercalib_f0_norm, NB_BINS_COMPRESSED_SM_F0, packet_norm_bp1.data );
             // 3) send the BP1 set
-            set_time( packet_norm_bp1_f0.header.time,            (unsigned char *) &incomingMsg->coarseTime );
-            set_time( packet_norm_bp1_f0.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
-            BP_send( (char *) &packet_norm_bp1_f0, queue_id,
+            set_time( packet_norm_bp1.header.time,            (unsigned char *) &incomingMsg->coarseTimeNORM );
+            set_time( packet_norm_bp1.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM );
+            BP_send( (char *) &packet_norm_bp1, queue_id,
                       PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0 + PACKET_LENGTH_DELTA,
                      SID_NORM_BP1_F0 );
             if (incomingMsg->event & RTEMS_EVENT_NORM_BP2_F0)
             {
                 // 1) compute the BP2 set using the same ASM as the one used for BP1
-
+                BP2_set( compressed_sm_norm_f0, NB_BINS_COMPRESSED_SM_F0, packet_norm_bp2.data );
                 // 2) send the BP2 set
-                set_time( packet_norm_bp2_f0.header.time,            (unsigned char *) &incomingMsg->coarseTime );
-                set_time( packet_norm_bp2_f0.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
-                BP_send( (char *) &packet_norm_bp2_f0, queue_id,
+                set_time( packet_norm_bp2.time,            (unsigned char *) &incomingMsg->coarseTimeNORM );
+                set_time( packet_norm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM );
+                BP_send( (char *) &packet_norm_bp2, queue_id,
                           PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0 + PACKET_LENGTH_DELTA,
                          SID_NORM_BP2_F0);
+
+                // < TMP DATA>
+#define INDEX_COMPRESSED 1
+                unsigned int signif;
+                float significand;
+                unsigned int nbitexp = 6;
+                unsigned int nbitsig = 16 - nbitexp;       // number of bits for the significand
+                unsigned int rangesig = (1 << nbitsig)-1;  // == 2^nbitsig - 1
+                int expmax = 32;
+                int expmin = expmax - ((int) (1 << nbitexp)) + 1;
+                int exponent;
+                float auto_a0;
+                exponent = ( (int) ( (packet_norm_bp2.data[INDEX_COMPRESSED * NB_BYTES_PER_BP2] & 0xfc) >> 2) ) + expmin; // [1111 1100]
+                printf("exponent = %x, computed with exp = %x, expmin = %d\n",
+                       exponent,
+                       (packet_norm_bp2.data[INDEX_COMPRESSED * NB_BYTES_PER_BP2] & 0xfc) >> 2,
+                       expmin);
+                signif = ( (packet_norm_bp2.data[INDEX_COMPRESSED * NB_BYTES_PER_BP2] & 0x3) << 8 ) + packet_norm_bp2.data[INDEX_COMPRESSED * NB_BYTES_PER_BP2+1];
+                significand = ( ( (float) signif ) / ( (float) rangesig) + 1) / 2;
+                auto_a0 = significand * pow(2,exponent);
+                printf("(BP2) [%d] compressed = %f *** AUTO A0 = %x, %x, exponent = %x, significand = %f ===> %f\n",
+                       INDEX_COMPRESSED,
+                       compressed_sm_norm_f0[INDEX_COMPRESSED * NB_VALUES_PER_SM],
+                       packet_norm_bp2.data[ INDEX_COMPRESSED * NB_BYTES_PER_BP2],
+                       packet_norm_bp2.data[ INDEX_COMPRESSED * NB_BYTES_PER_BP2 + 1],
+                       exponent, significand, auto_a0 );
+//                printf("(BP2) 0 = %f, 1 = %f, 2 = %f, 3 = %f, 4 = %f, 5 = %f, 6 = %f, 7 = %f, 8 = %f, 9 = %f, 10 = %f,\n",
+//                        compressed_sm_norm_f0[0 * NB_VALUES_PER_SM],
+//                        compressed_sm_norm_f0[1 * NB_VALUES_PER_SM],
+//                        compressed_sm_norm_f0[2 * NB_VALUES_PER_SM],
+//                        compressed_sm_norm_f0[3 * NB_VALUES_PER_SM],
+//                        compressed_sm_norm_f0[4 * NB_VALUES_PER_SM],
+//                        compressed_sm_norm_f0[5 * NB_VALUES_PER_SM],
+//                        compressed_sm_norm_f0[6 * NB_VALUES_PER_SM],
+//                        compressed_sm_norm_f0[7 * NB_VALUES_PER_SM],
+//                        compressed_sm_norm_f0[8 * NB_VALUES_PER_SM],
+//                        compressed_sm_norm_f0[9 * NB_VALUES_PER_SM],
+//                        compressed_sm_norm_f0[10 * NB_VALUES_PER_SM]);
+                // </TMP DATA>
+
             }
         }
 
@@ -337,9 +379,25 @@ rtems_task prc0_task( rtems_task_argumen
                                        nb_sm_before_f0.norm_bp1 );
             // 2) convert the float array in a char array
             ASM_convert( asm_f0_reorganized, (char*) current_ring_node_to_send_asm_f0->buffer_address );
-            current_ring_node_to_send_asm_f0->coarseTime    = incomingMsg->coarseTime;
-            current_ring_node_to_send_asm_f0->fineTime      = incomingMsg->fineTime;
+            current_ring_node_to_send_asm_f0->coarseTime    = incomingMsg->coarseTimeNORM;
+            current_ring_node_to_send_asm_f0->fineTime      = incomingMsg->fineTimeNORM;
             current_ring_node_to_send_asm_f0->sid           = SID_NORM_ASM_F0;
+
+            // < TMP DATA>
+#define INDEX_TO_LOOK_AT 31
+            float b11;
+            unsigned char *b11_charPtr;
+            b11_charPtr = (unsigned char*) &b11;
+            b11_charPtr[0] = ((unsigned char *) current_ring_node_to_send_asm_f0->buffer_address)[(INDEX_TO_LOOK_AT * NB_VALUES_PER_SM) * 2];
+            b11_charPtr[1] = ((unsigned char *) current_ring_node_to_send_asm_f0->buffer_address)[(INDEX_TO_LOOK_AT * NB_VALUES_PER_SM) * 2 +1];
+            b11_charPtr[2] = 0x00;
+            b11_charPtr[3] = 0x00;
+            printf("(ASM) initial = %f, reorganized and divided = %f, converted = %f\n",
+                   incomingMsg->norm->matrix[INDEX_TO_LOOK_AT],   // 32 * 96 = 3072 Hz
+                   asm_f0_reorganized[ INDEX_TO_LOOK_AT * NB_VALUES_PER_SM ],
+                    b11);
+            // </TMP DATA>
+
             // 3) send the spectral matrix packets
             status =  rtems_message_queue_send( queue_id, &current_ring_node_to_send_asm_f0, sizeof( ring_node* ) );
             // change asm ring node
@@ -385,3 +443,56 @@ void reset_nb_sm_f0( unsigned char lfrMo
         nb_sm_before_f0.burst_sbm_bp2 =  nb_sm_before_f0.burst_bp2;
     }
 }
+
+void init_k_coefficients_f0( void )
+{
+    init_k_coefficients( k_coeff_intercalib_f0_norm, NB_BINS_COMPRESSED_SM_F0    );
+    init_k_coefficients( k_coeff_intercalib_f0_sbm,  NB_BINS_COMPRESSED_SM_SBM_F0);
+}
+
+void test_TCH( void )
+{
+#define NB_BINS_COMPRESSED_MATRIX_TCH 1
+
+    unsigned char LFR_BP1_f0[NB_BINS_COMPRESSED_MATRIX_TCH*NB_BYTES_BP1];
+    unsigned char LFR_BP2_f0[NB_BINS_COMPRESSED_MATRIX_TCH*NB_BYTES_BP2];
+    float k_coefficients[NB_BINS_COMPRESSED_MATRIX_TCH * NB_K_COEFF_PER_BIN];
+
+    float compressed_spectral_matrix_TCH[ NB_BINS_COMPRESSED_MATRIX_TCH * NB_VALUES_PER_SPECTRAL_MATRIX ] = {
+        1.02217712e+06,
+        -8.58216250e+04,
+        -3.22199043e+04,
+        1.01597820e+05,
+        8.10333875e+05,
+        1.19030141e+05,
+        -8.69636688e+05,
+        5.01504031e+05,
+        -1.01948547e+05,
+        1.35475020e+04,
+        -3.67825469e+04,
+        -1.10950273e+05,
+        2.10715000e+04,
+        4.49727383e+04,
+        -4.37282031e+04,
+        3.83337695e+03,
+        1.05317175e+06,
+        -4.04155312e+05,
+        -1.32987891e+05,
+        1.49277250e+05,
+        -4.39122625e+05,
+        9.46006250e+05,
+        2.64386625e+05,
+        3.71843125e+05,
+        3.39770000e+05
+    };
+
+    init_k_coefficients( k_coefficients, NB_BINS_COMPRESSED_MATRIX_TCH );
+
+    printf("\n");
+
+    BP1_set(compressed_spectral_matrix_TCH, k_coefficients, NB_BINS_COMPRESSED_MATRIX_TCH, LFR_BP1_f0);
+
+    printf("\n");
+
+    BP2_set(compressed_spectral_matrix_TCH, NB_BINS_COMPRESSED_MATRIX_TCH, LFR_BP2_f0);
+}
diff --git a/src/processing/avf1_prc1.c b/src/processing/avf1_prc1.c
--- a/src/processing/avf1_prc1.c
+++ b/src/processing/avf1_prc1.c
@@ -11,6 +11,8 @@
 
 nb_sm_before_bp_asm_f1 nb_sm_before_f1;
 
+extern ring_node sm_ring_f1[ ];
+
 //***
 // F1
 ring_node_asm asm_ring_norm_f1      [ NB_RING_NODES_ASM_NORM_F1      ];
@@ -24,6 +26,9 @@ char  asm_f1_char          [ TIME_OFFSET
 float compressed_sm_norm_f1[ TOTAL_SIZE_COMPRESSED_ASM_NORM_F1];
 float compressed_sm_sbm_f1 [ TOTAL_SIZE_COMPRESSED_ASM_SBM_F1 ];
 
+float k_coeff_intercalib_f1_norm[ NB_BINS_COMPRESSED_SM_F1     * NB_K_COEFF_PER_BIN ];   // 13 * 32 = 416
+float k_coeff_intercalib_f1_sbm[  NB_BINS_COMPRESSED_SM_SBM_F1 * NB_K_COEFF_PER_BIN ];   // 26 * 32 = 832
+
 //************
 // RTEMS TASKS
 
@@ -35,7 +40,8 @@ rtems_task avf1_task( rtems_task_argumen
     rtems_status_code status;
     rtems_id queue_id_prc1;
     asm_msg msgForMATR;
-    ring_node *ring_node_tab[8];
+    ring_node *nodeForAveraging;
+    ring_node *ring_node_tab[NB_SM_BEFORE_AVF0];
     ring_node_asm *current_ring_node_asm_burst_sbm_f1;
     ring_node_asm *current_ring_node_asm_norm_f1;
 
@@ -73,23 +79,24 @@ rtems_task avf1_task( rtems_task_argumen
         msgForMATR.norm       = current_ring_node_asm_norm_f1;
         msgForMATR.burst_sbm  = current_ring_node_asm_burst_sbm_f1;
         msgForMATR.event      = 0x00;  // this composite event will be sent to the PRC1 task
-        msgForMATR.coarseTime = ring_node_for_averaging_sm_f1->coarseTime;
-        msgForMATR.fineTime   = ring_node_for_averaging_sm_f1->fineTime;
         //
         //****************************************
 
-        ring_node_tab[NB_SM_BEFORE_AVF1-1] = ring_node_for_averaging_sm_f1;
+        nodeForAveraging = getRingNodeForAveraging( 1 );
+
+        ring_node_tab[NB_SM_BEFORE_AVF1-1] = nodeForAveraging;
         for ( i = 2; i < (NB_SM_BEFORE_AVF1+1); i++ )
         {
-            ring_node_for_averaging_sm_f1 = ring_node_for_averaging_sm_f1->previous;
-            ring_node_tab[NB_SM_BEFORE_AVF1-i] = ring_node_for_averaging_sm_f1;
+            nodeForAveraging = nodeForAveraging->previous;
+            ring_node_tab[NB_SM_BEFORE_AVF1-i] = nodeForAveraging;
         }
 
         // compute the average and store it in the averaged_sm_f1 buffer
         SM_average( current_ring_node_asm_norm_f1->matrix,
                     current_ring_node_asm_burst_sbm_f1->matrix,
                     ring_node_tab,
-                    nb_norm_bp1, nb_sbm_bp1 );
+                    nb_norm_bp1, nb_sbm_bp1,
+                    &msgForMATR );
 
         // update nb_average
         nb_norm_bp1 = nb_norm_bp1 + NB_SM_BEFORE_AVF1;
@@ -198,7 +205,7 @@ rtems_task prc1_task( rtems_task_argumen
     BP_init_header_with_spare( &packet_norm_bp1.header,
                                APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP1_F1,
                                PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F1, NB_BINS_COMPRESSED_SM_F1 );
-    BP_init_header( &packet_norm_bp2.header,
+    BP_init_header( &packet_norm_bp2,
                     APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP2_F1,
                     PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F1, NB_BINS_COMPRESSED_SM_F1);
 
@@ -206,19 +213,19 @@ rtems_task prc1_task( rtems_task_argumen
     // BURST and SBM2 headers
     if ( lfrRequestedMode == LFR_MODE_BURST )
     {
-        BP_init_header( &packet_sbm_bp1.header,
+        BP_init_header( &packet_sbm_bp1,
                         APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP1_F1,
                         PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F1, NB_BINS_COMPRESSED_SM_SBM_F1);
-        BP_init_header( &packet_sbm_bp2.header,
+        BP_init_header( &packet_sbm_bp2,
                         APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP2_F1,
                         PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F1, NB_BINS_COMPRESSED_SM_SBM_F1);
     }
     else if ( lfrRequestedMode == LFR_MODE_SBM2 )
     {
-        BP_init_header( &packet_sbm_bp1.header,
+        BP_init_header( &packet_sbm_bp1,
                         APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP1_F1,
                         PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F1, NB_BINS_COMPRESSED_SM_SBM_F1);
-        BP_init_header( &packet_sbm_bp2.header,
+        BP_init_header( &packet_sbm_bp2,
                         APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP2_F1,
                         PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F1, NB_BINS_COMPRESSED_SM_SBM_F1);
     }
@@ -261,10 +268,10 @@ rtems_task prc1_task( rtems_task_argumen
                                          NB_BINS_COMPRESSED_SM_SBM_F1, NB_BINS_TO_AVERAGE_ASM_SBM_F1,
                                          ASM_F1_INDICE_START);
             // 2) compute the BP1 set
-
+            BP1_set( compressed_sm_sbm_f1, k_coeff_intercalib_f1_sbm, NB_BINS_COMPRESSED_SM_SBM_F1, packet_sbm_bp1.data );
             // 3) send the BP1 set
-            set_time( packet_sbm_bp1.header.time,            (unsigned char *) &incomingMsg->coarseTime );
-            set_time( packet_sbm_bp1.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
+            set_time( packet_sbm_bp1.time,            (unsigned char *) &incomingMsg->coarseTimeSBM );
+            set_time( packet_sbm_bp1.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeSBM );
             BP_send( (char *) &packet_sbm_bp1, queue_id_send,
                      PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F1 + PACKET_LENGTH_DELTA,
                      sid );
@@ -272,10 +279,10 @@ rtems_task prc1_task( rtems_task_argumen
             if ( (incomingMsg->event & RTEMS_EVENT_BURST_BP2_F1) || (incomingMsg->event & RTEMS_EVENT_SBM_BP2_F1) )
             {
                 // 1) compute the BP2 set
-
+                BP2_set( compressed_sm_sbm_f1, NB_BINS_COMPRESSED_SM_SBM_F1, packet_norm_bp2.data );
                 // 2) send the BP2 set
-                set_time( packet_sbm_bp2.header.time,            (unsigned char *) &incomingMsg->coarseTime );
-                set_time( packet_sbm_bp2.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
+                set_time( packet_sbm_bp2.time,            (unsigned char *) &incomingMsg->coarseTimeSBM );
+                set_time( packet_sbm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeSBM );
                 BP_send( (char *) &packet_sbm_bp2, queue_id_send,
                          PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F1 + PACKET_LENGTH_DELTA,
                          sid );
@@ -295,20 +302,20 @@ rtems_task prc1_task( rtems_task_argumen
                                          NB_BINS_COMPRESSED_SM_F0, NB_BINS_TO_AVERAGE_ASM_F0,
                                          ASM_F0_INDICE_START );
             // 2) compute the BP1 set
-
+            BP1_set( compressed_sm_norm_f1, k_coeff_intercalib_f1_norm, NB_BINS_COMPRESSED_SM_F1, packet_norm_bp1.data );
             // 3) send the BP1 set
-            set_time( packet_norm_bp1.header.time,            (unsigned char *) &incomingMsg->coarseTime );
-            set_time( packet_norm_bp1.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime   );
+            set_time( packet_norm_bp1.header.time,            (unsigned char *) &incomingMsg->coarseTimeNORM );
+            set_time( packet_norm_bp1.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM   );
             BP_send( (char *) &packet_norm_bp1, queue_id_send,
                      PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F1 + PACKET_LENGTH_DELTA,
                      SID_NORM_BP1_F1 );
             if (incomingMsg->event & RTEMS_EVENT_NORM_BP2_F1)
             {
                 // 1) compute the BP2 set
-
+                BP2_set( compressed_sm_norm_f1, NB_BINS_COMPRESSED_SM_F1, packet_norm_bp2.data );
                 // 2) send the BP2 set
-                set_time( packet_norm_bp2.header.time,            (unsigned char *) &incomingMsg->coarseTime );
-                set_time( packet_norm_bp2.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
+                set_time( packet_norm_bp2.time,            (unsigned char *) &incomingMsg->coarseTimeNORM );
+                set_time( packet_norm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM );
                 BP_send( (char *) &packet_norm_bp2, queue_id_send,
                          PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F1 + PACKET_LENGTH_DELTA,
                          SID_NORM_BP2_F1 );
@@ -323,8 +330,8 @@ rtems_task prc1_task( rtems_task_argumen
                                        nb_sm_before_f1.norm_bp1 );
             // 2) convert the float array in a char array
             ASM_convert( asm_f1_reorganized, (char*) current_ring_node_to_send_asm_f1->buffer_address );
-            current_ring_node_to_send_asm_f1->coarseTime    = incomingMsg->coarseTime;
-            current_ring_node_to_send_asm_f1->fineTime      = incomingMsg->fineTime;
+            current_ring_node_to_send_asm_f1->coarseTime    = incomingMsg->coarseTimeNORM;
+            current_ring_node_to_send_asm_f1->fineTime      = incomingMsg->fineTimeNORM;
             current_ring_node_to_send_asm_f1->sid           = SID_NORM_ASM_F1;
             // 3) send the spectral matrix packets
             status =  rtems_message_queue_send( queue_id_send, &current_ring_node_to_send_asm_f1, sizeof( ring_node* ) );
@@ -365,3 +372,8 @@ void reset_nb_sm_f1( unsigned char lfrMo
     }
 }
 
+void init_k_coefficients_f1( void )
+{
+    init_k_coefficients( k_coeff_intercalib_f1_norm, NB_BINS_COMPRESSED_SM_F1    );
+    init_k_coefficients( k_coeff_intercalib_f1_sbm,  NB_BINS_COMPRESSED_SM_SBM_F1);
+}
diff --git a/src/processing/avf2_prc2.c b/src/processing/avf2_prc2.c
--- a/src/processing/avf2_prc2.c
+++ b/src/processing/avf2_prc2.c
@@ -11,19 +11,23 @@
 
 nb_sm_before_bp_asm_f2 nb_sm_before_f2;
 
+extern ring_node sm_ring_f2[ ];
+
 //***
 // F2
 ring_node_asm asm_ring_norm_f2     [ NB_RING_NODES_ASM_NORM_F2      ];
 ring_node_asm asm_ring_burst_sbm_f2[ NB_RING_NODES_ASM_BURST_SBM_F2 ];
 
-ring_node ring_to_send_asm_f2       [ NB_RING_NODES_ASM_F2 ];
-int buffer_asm_f2                   [ NB_RING_NODES_ASM_F2 * TOTAL_SIZE_SM ];
+ring_node ring_to_send_asm_f2      [ NB_RING_NODES_ASM_F2 ];
+int buffer_asm_f2                  [ NB_RING_NODES_ASM_F2 * TOTAL_SIZE_SM ];
 
 float asm_f2_reorganized   [ TOTAL_SIZE_SM ];
 char  asm_f2_char          [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ];
 float compressed_sm_norm_f2[ TOTAL_SIZE_COMPRESSED_ASM_NORM_F2];
 float compressed_sm_sbm_f2 [ TOTAL_SIZE_COMPRESSED_ASM_SBM_F2 ];
 
+float k_coeff_intercalib_f2[ NB_BINS_COMPRESSED_SM_F2 * NB_K_COEFF_PER_BIN ];   // 12 * 32 = 384
+
 //************
 // RTEMS TASKS
 
@@ -35,6 +39,7 @@ rtems_task avf2_task( rtems_task_argumen
     rtems_status_code status;
     rtems_id queue_id_prc2;
     asm_msg msgForMATR;
+    ring_node *nodeForAveraging;
     ring_node_asm *current_ring_node_asm_norm_f2;
 
     unsigned int nb_norm_bp1;
@@ -65,15 +70,28 @@ rtems_task avf2_task( rtems_task_argumen
         msgForMATR.norm       = current_ring_node_asm_norm_f2;
         msgForMATR.burst_sbm  = NULL;
         msgForMATR.event      = 0x00;  // this composite event will be sent to the PRC2 task
-        msgForMATR.coarseTime = ring_node_for_averaging_sm_f2->coarseTime;
-        msgForMATR.fineTime   = ring_node_for_averaging_sm_f2->fineTime;
         //
         //****************************************
 
+        nodeForAveraging = getRingNodeForAveraging( 2 );
+
+//        printf(" **0** %x . %x", sm_ring_f2[0].coarseTime, sm_ring_f2[0].fineTime);
+//        printf(" **1** %x . %x", sm_ring_f2[1].coarseTime, sm_ring_f2[1].fineTime);
+//        printf(" **2** %x . %x", sm_ring_f2[2].coarseTime, sm_ring_f2[2].fineTime);
+//        printf(" **3** %x . %x", sm_ring_f2[3].coarseTime, sm_ring_f2[3].fineTime);
+//        printf(" **4** %x . %x", sm_ring_f2[4].coarseTime, sm_ring_f2[4].fineTime);
+//        printf(" **5** %x . %x", sm_ring_f2[5].coarseTime, sm_ring_f2[5].fineTime);
+//        printf(" **6** %x . %x", sm_ring_f2[6].coarseTime, sm_ring_f2[6].fineTime);
+//        printf(" **7** %x . %x", sm_ring_f2[7].coarseTime, sm_ring_f2[7].fineTime);
+//        printf(" **8** %x . %x", sm_ring_f2[8].coarseTime, sm_ring_f2[8].fineTime);
+//        printf(" **9** %x . %x", sm_ring_f2[9].coarseTime, sm_ring_f2[9].fineTime);
+//        printf(" **10** %x . %x\n", sm_ring_f2[10].coarseTime, sm_ring_f2[10].fineTime);
+
         // compute the average and store it in the averaged_sm_f2 buffer
         SM_average_f2( current_ring_node_asm_norm_f2->matrix,
-                       ring_node_for_averaging_sm_f2,
-                       nb_norm_bp1 );
+                       nodeForAveraging,
+                       nb_norm_bp1,
+                       &msgForMATR );
 
         // update nb_average
         nb_norm_bp1 = nb_norm_bp1 + NB_SM_BEFORE_AVF2;
@@ -108,7 +126,6 @@ rtems_task avf2_task( rtems_task_argumen
             if ( (lfrCurrentMode == LFR_MODE_NORMAL) || (lfrCurrentMode == LFR_MODE_SBM1)
                  || (lfrCurrentMode == LFR_MODE_SBM2) )
             {
-//                PRINTF1("%lld\n", localTime)
                 msgForMATR.event = msgForMATR.event | RTEMS_EVENT_NORM_ASM_F2;
             }
         }
@@ -135,8 +152,8 @@ rtems_task prc2_task( rtems_task_argumen
     rtems_status_code status;
     rtems_id queue_id;
     rtems_id queue_id_q_p2;
-    bp_packet                   packet_norm_bp1_f2;
-    bp_packet                   packet_norm_bp2_f2;
+    bp_packet                   packet_norm_bp1;
+    bp_packet                   packet_norm_bp2;
     ring_node                   *current_ring_node_to_send_asm_f2;
 
     unsigned long long int localTime;
@@ -149,10 +166,10 @@ rtems_task prc2_task( rtems_task_argumen
 
     //*************
     // NORM headers
-    BP_init_header( &packet_norm_bp1_f2.header,
+    BP_init_header( &packet_norm_bp1,
                     APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP1_F2,
                     PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F2, NB_BINS_COMPRESSED_SM_F2 );
-    BP_init_header( &packet_norm_bp2_f2.header,
+    BP_init_header( &packet_norm_bp2,
                     APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP2_F2,
                     PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F2, NB_BINS_COMPRESSED_SM_F2 );
 
@@ -190,21 +207,21 @@ rtems_task prc2_task( rtems_task_argumen
                                          NB_BINS_COMPRESSED_SM_F2, NB_BINS_TO_AVERAGE_ASM_F2,
                                          ASM_F2_INDICE_START );
             // 2) compute the BP1 set
-
+            BP1_set( compressed_sm_norm_f2, k_coeff_intercalib_f2, NB_BINS_COMPRESSED_SM_F2, packet_norm_bp1.data );
             // 3) send the BP1 set
-            set_time( packet_norm_bp1_f2.header.time,            (unsigned char *) &incomingMsg->coarseTime );
-            set_time( packet_norm_bp1_f2.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
-            BP_send( (char *) &packet_norm_bp1_f2, queue_id,
+            set_time( packet_norm_bp1.time,            (unsigned char *) &incomingMsg->coarseTimeNORM );
+            set_time( packet_norm_bp1.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM );
+            BP_send( (char *) &packet_norm_bp1, queue_id,
                      PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F2 + PACKET_LENGTH_DELTA,
                      SID_NORM_BP1_F2 );
             if (incomingMsg->event & RTEMS_EVENT_NORM_BP2_F2)
             {
                 // 1) compute the BP2 set using the same ASM as the one used for BP1
-
+                BP2_set( compressed_sm_norm_f2, NB_BINS_COMPRESSED_SM_F2, packet_norm_bp2.data );
                 // 2) send the BP2 set
-                set_time( packet_norm_bp2_f2.header.time,            (unsigned char *) &incomingMsg->coarseTime );
-                set_time( packet_norm_bp2_f2.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
-                BP_send( (char *) &packet_norm_bp2_f2, queue_id,
+                set_time( packet_norm_bp2.time,            (unsigned char *) &incomingMsg->coarseTimeNORM );
+                set_time( packet_norm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM );
+                BP_send( (char *) &packet_norm_bp2, queue_id,
                          PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F2 + PACKET_LENGTH_DELTA,
                          SID_NORM_BP2_F2 );
             }
@@ -218,8 +235,8 @@ rtems_task prc2_task( rtems_task_argumen
                                        nb_sm_before_f2.norm_bp1 );
             // 2) convert the float array in a char array
             ASM_convert( asm_f2_reorganized, (char*) current_ring_node_to_send_asm_f2->buffer_address );
-            current_ring_node_to_send_asm_f2->coarseTime    = incomingMsg->coarseTime;
-            current_ring_node_to_send_asm_f2->fineTime      = incomingMsg->fineTime;
+            current_ring_node_to_send_asm_f2->coarseTime    = incomingMsg->coarseTimeNORM;
+            current_ring_node_to_send_asm_f2->fineTime      = incomingMsg->fineTimeNORM;
             current_ring_node_to_send_asm_f2->sid           = SID_NORM_ASM_F2;
             // 3) send the spectral matrix packets
             status =  rtems_message_queue_send( queue_id, &current_ring_node_to_send_asm_f2, sizeof( ring_node* ) );
@@ -241,8 +258,9 @@ void reset_nb_sm_f2( void )
 }
 
 void SM_average_f2( float *averaged_spec_mat_f2,
-                  ring_node *ring_node,
-                  unsigned int nbAverageNormF2 )
+                    ring_node *ring_node,
+                    unsigned int nbAverageNormF2,
+                    asm_msg *msgForMATR )
 {
     float sum;
     unsigned int i;
@@ -253,6 +271,8 @@ void SM_average_f2( float *averaged_spec
         if ( (nbAverageNormF2 == 0) )
         {
             averaged_spec_mat_f2[ i ] = sum;
+            msgForMATR->coarseTimeNORM  = ring_node->coarseTime;
+            msgForMATR->fineTimeNORM    = ring_node->fineTime;
         }
         else
         {
@@ -260,3 +280,8 @@ void SM_average_f2( float *averaged_spec
         }
     }
 }
+
+void init_k_coefficients_f2( void )
+{
+    init_k_coefficients( k_coeff_intercalib_f2, NB_BINS_COMPRESSED_SM_F2);
+}
diff --git a/src/processing/fsw_processing.c b/src/processing/fsw_processing.c
--- a/src/processing/fsw_processing.c
+++ b/src/processing/fsw_processing.c
@@ -27,78 +27,91 @@ ring_node *ring_node_for_averaging_sm_f0
 ring_node *ring_node_for_averaging_sm_f1;
 ring_node *ring_node_for_averaging_sm_f2;
 
+//
+ring_node * getRingNodeForAveraging( unsigned char frequencyChannel)
+{
+    ring_node *node;
+
+    node = NULL;
+    switch ( frequencyChannel ) {
+    case 0:
+        node = ring_node_for_averaging_sm_f0;
+        break;
+    case 1:
+        node = ring_node_for_averaging_sm_f1;
+        break;
+    case 2:
+        node = ring_node_for_averaging_sm_f2;
+        break;
+    default:
+        break;
+    }
+
+    return node;
+}
+
 //***********************************************************
 // Interrupt Service Routine for spectral matrices processing
 
 void spectral_matrices_isr_f0( void )
 {
     unsigned char status;
-    unsigned long long int time_0;
-    unsigned long long int time_1;
-    unsigned long long int syncBit0;
-    unsigned long long int syncBit1;
+    rtems_status_code status_code;
 
     status = spectral_matrix_regs->status & 0x03;   // [0011] get the status_ready_matrix_f0_x bits
 
-    time_0 = get_acquisition_time( (unsigned char *) &spectral_matrix_regs->f0_0_coarse_time );
-    time_1 = get_acquisition_time( (unsigned char *) &spectral_matrix_regs->f0_1_coarse_time );
-    syncBit0 = ( (unsigned long long int) (spectral_matrix_regs->f0_0_coarse_time & 0x80000000) ) << 16;
-    syncBit1 = ( (unsigned long long int) (spectral_matrix_regs->f0_1_coarse_time & 0x80000000) ) << 16;
-
     switch(status)
     {
     case 0:
         break;
     case 3:
-        // send a message if two buffers are ready
-        rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_6 );
-        if ( time_0 < time_1 )
-        {
-            close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0],
-                                  ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_0 | syncBit0);
-            current_ring_node_sm_f0 = current_ring_node_sm_f0->next;
-            spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->buffer_address;
-            close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0],
-                                  ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_1 | syncBit1);
-            current_ring_node_sm_f0 = current_ring_node_sm_f0->next;
-            spectral_matrix_regs->f0_1_address = current_ring_node_sm_f0->buffer_address;
-        }
-        else
-        {
-            close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0],
-                                  ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_1 | syncBit1);
-            current_ring_node_sm_f0 = current_ring_node_sm_f0->next;
-            spectral_matrix_regs->f0_1_address = current_ring_node_sm_f0->buffer_address;
-            close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0],
-                                  ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_0 | syncBit0);
-            current_ring_node_sm_f0 = current_ring_node_sm_f0->next;
-            spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->buffer_address;
-        }
+        // UNEXPECTED VALUE
         spectral_matrix_regs->status = 0x03;   // [0011]
+        status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_11 );
         break;
     case 1:
-        close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0],
-                              ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_0 | syncBit0);
+        ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0->previous;
         current_ring_node_sm_f0 = current_ring_node_sm_f0->next;
+        ring_node_for_averaging_sm_f0->coarseTime = spectral_matrix_regs->f0_0_coarse_time;
+        ring_node_for_averaging_sm_f0->fineTime = spectral_matrix_regs->f0_0_fine_time;
         spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->buffer_address;
-        spectral_matrix_regs->status = 0x01;   // [0001]
+        spectral_matrix_regs->status = 0x01;   // [0000 0001]
+        // if there are enough ring nodes ready, wake up an AVFx task
+        nb_sm_f0 = nb_sm_f0 + 1;
+        if (nb_sm_f0 == NB_SM_BEFORE_AVF0)
+        {
+            if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
+            {
+                status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
+            }
+            nb_sm_f0 = 0;
+        }
         break;
     case 2:
-        close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0],
-                              ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_1 | syncBit1);
+        ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0->previous;
         current_ring_node_sm_f0 = current_ring_node_sm_f0->next;
-        spectral_matrix_regs->f0_1_address = current_ring_node_sm_f0->buffer_address;
-        spectral_matrix_regs->status = 0x02;   // [0010]
+        ring_node_for_averaging_sm_f0->coarseTime = spectral_matrix_regs->f0_1_coarse_time;
+        ring_node_for_averaging_sm_f0->fineTime = spectral_matrix_regs->f0_1_fine_time;
+        spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->buffer_address;
+        spectral_matrix_regs->status = 0x02;   // [0000 0010]
+        // if there are enough ring nodes ready, wake up an AVFx task
+        nb_sm_f0 = nb_sm_f0 + 1;
+        if (nb_sm_f0 == NB_SM_BEFORE_AVF0)
+        {
+            if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
+            {
+                status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
+            }
+            nb_sm_f0 = 0;
+        }
         break;
     }
 }
 
 void spectral_matrices_isr_f1( void )
 {
+    rtems_status_code status_code;
     unsigned char status;
-    unsigned long long int time;
-    unsigned long long int syncBit;
-    rtems_status_code status_code;
 
     status = (spectral_matrix_regs->status & 0x0c) >> 2;   // [1100] get the status_ready_matrix_f0_x bits
 
@@ -112,22 +125,40 @@ void spectral_matrices_isr_f1( void )
         status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_11 );
         break;
     case 1:
-        time = get_acquisition_time( (unsigned char *) &spectral_matrix_regs->f1_0_coarse_time );
-        syncBit = ( (unsigned long long int) (spectral_matrix_regs->f1_0_coarse_time & 0x80000000) ) << 16;
-        close_matrix_actions( &nb_sm_f1, NB_SM_BEFORE_AVF1, Task_id[TASKID_AVF1],
-                              ring_node_for_averaging_sm_f1, current_ring_node_sm_f1, time | syncBit);
+        ring_node_for_averaging_sm_f1 = current_ring_node_sm_f1->previous;
         current_ring_node_sm_f1 = current_ring_node_sm_f1->next;
+        ring_node_for_averaging_sm_f1->coarseTime = spectral_matrix_regs->f1_0_coarse_time;
+        ring_node_for_averaging_sm_f1->fineTime = spectral_matrix_regs->f1_0_fine_time;
         spectral_matrix_regs->f1_0_address = current_ring_node_sm_f1->buffer_address;
-        spectral_matrix_regs->status = 0x04;   // [0100]
+        spectral_matrix_regs->status = 0x04;   // [0000 0100]
+        // if there are enough ring nodes ready, wake up an AVFx task
+        nb_sm_f1 = nb_sm_f1 + 1;
+        if (nb_sm_f1 == NB_SM_BEFORE_AVF1)
+        {
+            if (rtems_event_send( Task_id[TASKID_AVF1], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
+            {
+                status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
+            }
+            nb_sm_f1 = 0;
+        }
         break;
     case 2:
-        time = get_acquisition_time( (unsigned char *) &spectral_matrix_regs->f1_1_coarse_time );
-        syncBit = ( (unsigned long long int) (spectral_matrix_regs->f1_1_coarse_time & 0x80000000) ) << 16;
-        close_matrix_actions( &nb_sm_f1, NB_SM_BEFORE_AVF1, Task_id[TASKID_AVF1],
-                              ring_node_for_averaging_sm_f1, current_ring_node_sm_f1, time | syncBit);
+        ring_node_for_averaging_sm_f1 = current_ring_node_sm_f1->previous;
         current_ring_node_sm_f1 = current_ring_node_sm_f1->next;
+        ring_node_for_averaging_sm_f1->coarseTime = spectral_matrix_regs->f1_1_coarse_time;
+        ring_node_for_averaging_sm_f1->fineTime = spectral_matrix_regs->f1_1_fine_time;
         spectral_matrix_regs->f1_1_address = current_ring_node_sm_f1->buffer_address;
-        spectral_matrix_regs->status = 0x08;   // [1000]
+        spectral_matrix_regs->status = 0x08;   // [1000 0000]
+        // if there are enough ring nodes ready, wake up an AVFx task
+        nb_sm_f1 = nb_sm_f1 + 1;
+        if (nb_sm_f1 == NB_SM_BEFORE_AVF1)
+        {
+            if (rtems_event_send( Task_id[TASKID_AVF1], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
+            {
+                status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
+            }
+            nb_sm_f1 = 0;
+        }
         break;
     }
 }
@@ -139,10 +170,6 @@ void spectral_matrices_isr_f2( void )
 
     status = (spectral_matrix_regs->status & 0x30) >> 4;   // [0011 0000] get the status_ready_matrix_f0_x bits
 
-    ring_node_for_averaging_sm_f2 = current_ring_node_sm_f2;
-
-    current_ring_node_sm_f2 = current_ring_node_sm_f2->next;
-
     switch(status)
     {
     case 0:
@@ -153,6 +180,8 @@ void spectral_matrices_isr_f2( void )
         status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_11 );
         break;
     case 1:
+        ring_node_for_averaging_sm_f2 = current_ring_node_sm_f2->previous;
+        current_ring_node_sm_f2 = current_ring_node_sm_f2->next;
         ring_node_for_averaging_sm_f2->coarseTime = spectral_matrix_regs->f2_0_coarse_time;
         ring_node_for_averaging_sm_f2->fineTime = spectral_matrix_regs->f2_0_fine_time;
         spectral_matrix_regs->f2_0_address = current_ring_node_sm_f2->buffer_address;
@@ -163,6 +192,8 @@ void spectral_matrices_isr_f2( void )
         }
         break;
     case 2:
+        ring_node_for_averaging_sm_f2 = current_ring_node_sm_f2->previous;
+        current_ring_node_sm_f2 = current_ring_node_sm_f2->next;
         ring_node_for_averaging_sm_f2->coarseTime = spectral_matrix_regs->f2_1_coarse_time;
         ring_node_for_averaging_sm_f2->fineTime = spectral_matrix_regs->f2_1_fine_time;
         spectral_matrix_regs->f2_1_address = current_ring_node_sm_f2->buffer_address;
@@ -177,14 +208,14 @@ void spectral_matrices_isr_f2( void )
 
 void spectral_matrix_isr_error_handler( void )
 {
-//    rtems_status_code status_code;
+    rtems_status_code status_code;
 
-//    if (spectral_matrix_regs->status & 0x7c0)    // [0111 1100 0000]
-//    {
-//        status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 );
-//    }
+    if (spectral_matrix_regs->status & 0x7c0)    // [0111 1100 0000]
+    {
+        status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 );
+    }
 
-//    spectral_matrix_regs->status = spectral_matrix_regs->status & 0x7c0;
+    spectral_matrix_regs->status = spectral_matrix_regs->status & 0x7c0;
 }
 
 rtems_isr spectral_matrices_isr( rtems_vector_number vector )
@@ -306,7 +337,7 @@ void SM_reset_current_ring_nodes( void )
 //*****************
 // Basic Parameters
 
-void BP_init_header( Header_TM_LFR_SCIENCE_BP_t *header,
+void BP_init_header( bp_packet *header,
                      unsigned int apid, unsigned char sid,
                      unsigned int packetLength, unsigned char blkNr )
 {
@@ -325,15 +356,21 @@ void BP_init_header( Header_TM_LFR_SCIEN
     header->serviceType = TM_TYPE_LFR_SCIENCE; // service type
     header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype
     header->destinationID = TM_DESTINATION_ID_GROUND;
+    header->time[0] = 0x00;
+    header->time[1] = 0x00;
+    header->time[2] = 0x00;
+    header->time[3] = 0x00;
+    header->time[4] = 0x00;
+    header->time[5] = 0x00;
     // AUXILIARY DATA HEADER
     header->sid = sid;
     header->biaStatusInfo = 0x00;
-    header->time[0] = 0x00;
-    header->time[0] = 0x00;
-    header->time[0] = 0x00;
-    header->time[0] = 0x00;
-    header->time[0] = 0x00;
-    header->time[0] = 0x00;
+    header->acquisitionTime[0] = 0x00;
+    header->acquisitionTime[1] = 0x00;
+    header->acquisitionTime[2] = 0x00;
+    header->acquisitionTime[3] = 0x00;
+    header->acquisitionTime[4] = 0x00;
+    header->acquisitionTime[5] = 0x00;
     header->pa_lfr_bp_blk_nr[0] = 0x00;  // BLK_NR MSB
     header->pa_lfr_bp_blk_nr[1] = blkNr;  // BLK_NR LSB
 }
@@ -420,10 +457,13 @@ void reset_spectral_matrix_regs( void )
 
     reset_sm_status();
 
+    // F1
     spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->previous->buffer_address;
     spectral_matrix_regs->f0_1_address = current_ring_node_sm_f0->buffer_address;
+    // F2
     spectral_matrix_regs->f1_0_address = current_ring_node_sm_f1->previous->buffer_address;
     spectral_matrix_regs->f1_1_address = current_ring_node_sm_f1->buffer_address;
+    // F3
     spectral_matrix_regs->f2_0_address = current_ring_node_sm_f2->previous->buffer_address;
     spectral_matrix_regs->f2_1_address = current_ring_node_sm_f2->buffer_address;
 
@@ -453,37 +493,6 @@ unsigned long long int get_acquisition_t
     return acquisitionTimeAslong;
 }
 
-void close_matrix_actions(unsigned int *nb_sm, unsigned int nb_sm_before_avf, rtems_id avf_task_id,
-                           ring_node *node_for_averaging, ring_node *ringNode,
-                           unsigned long long int time )
-{
-    unsigned char *timePtr;
-    unsigned char *coarseTimePtr;
-    unsigned char *fineTimePtr;
-    rtems_status_code status_code;
-
-    timePtr = (unsigned char *) &time;
-    coarseTimePtr = (unsigned char *) &node_for_averaging->coarseTime;
-    fineTimePtr = (unsigned char *) &node_for_averaging->fineTime;
-
-    *nb_sm = *nb_sm + 1;
-    if (*nb_sm == nb_sm_before_avf)
-    {
-        node_for_averaging = ringNode;
-        coarseTimePtr[0] = timePtr[2];
-        coarseTimePtr[1] = timePtr[3];
-        coarseTimePtr[2] = timePtr[4];
-        coarseTimePtr[3] = timePtr[5];
-        fineTimePtr[2] = timePtr[6];
-        fineTimePtr[3] = timePtr[7];
-        if (rtems_event_send( avf_task_id, RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
-        {
-            status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
-        }
-        *nb_sm = 0;
-    }
-}
-
 unsigned char getSID( rtems_event_set event )
 {
     unsigned char sid;
diff --git a/src/tc_handler.c b/src/tc_handler.c
--- a/src/tc_handler.c
+++ b/src/tc_handler.c
@@ -466,9 +466,6 @@ int stop_current_mode( void )
     LEON_Mask_interrupt( IRQ_WAVEFORM_PICKER );     // mask waveform picker interrupt
     LEON_Mask_interrupt( IRQ_SPECTRAL_MATRIX );    // clear spectral matrix interrupt
 
-    // reset lfr VHDL module
-    reset_lfr();
-
     // (2) reset waveform picker registers
     reset_wfp_burst_enable();                       // reset burst and enable bits
     reset_wfp_status();                             // reset all the status bits
@@ -477,6 +474,9 @@ int stop_current_mode( void )
     set_sm_irq_onNewMatrix( 0 );               // stop the spectral matrices
     reset_sm_status();
 
+    // reset lfr VHDL module
+    reset_lfr();
+
     reset_extractSWF();                             // reset the extractSWF flag to false
 
     // (4) clear interruptions
@@ -769,7 +769,7 @@ void launch_waveform_picker( unsigned ch
         waveform_picker_regs->start_date = transitionCoarseTime;
     }
 
-    PRINTF1("commutation coarse time = %d\n", transitionCoarseTime)
+    PRINTF1("commutation coarse time = %x\n", transitionCoarseTime)
 }
 
 void launch_spectral_matrix( void )
diff --git a/src/wf_handler.c b/src/wf_handler.c
--- a/src/wf_handler.c
+++ b/src/wf_handler.c
@@ -41,6 +41,50 @@ ring_node ring_node_wf_snap_extracted;
 //*********************
 // Interrupt SubRoutine
 
+ring_node * getRingNodeToSendCWF( unsigned char frequencyChannel)
+{
+    ring_node *node;
+
+    node = NULL;
+    switch ( frequencyChannel ) {
+    case 1:
+        node = ring_node_to_send_cwf_f1;
+        break;
+    case 2:
+        node = ring_node_to_send_cwf_f2;
+        break;
+    case 3:
+        node = ring_node_to_send_cwf_f3;
+        break;
+    default:
+        break;
+    }
+
+    return node;
+}
+
+ring_node * getRingNodeToSendSWF( unsigned char frequencyChannel)
+{
+    ring_node *node;
+
+    node = NULL;
+    switch ( frequencyChannel ) {
+    case 0:
+        node = ring_node_to_send_swf_f0;
+        break;
+    case 1:
+        node = ring_node_to_send_swf_f1;
+        break;
+    case 2:
+        node = ring_node_to_send_swf_f2;
+        break;
+    default:
+        break;
+    }
+
+    return node;
+}
+
 void reset_extractSWF( void )
 {
     extractSWF = false;
@@ -157,30 +201,37 @@ inline void waveforms_isr_normal( void )
 
 inline void waveforms_isr_burst( void )
 {
+    unsigned char status;
     rtems_status_code spare_status;
 
-    if ( (waveform_picker_regs->status & 0x30) != 0 ){ // [0100] check the f2 full bit
-        // (1) change the receiving buffer for the waveform picker
+    status = (waveform_picker_regs->status & 0x30) >> 4;   // [0011 0000] get the status_ready_matrix_f0_x bits
+
+    switch(status)
+    {
+    case 1:
         ring_node_to_send_cwf_f2    = current_ring_node_f2->previous;
         current_ring_node_f2        = current_ring_node_f2->next;
-        if ( (waveform_picker_regs->status & 0x10) == 0x10)
-        {
-            ring_node_to_send_cwf_f2->coarseTime    = waveform_picker_regs->f2_0_coarse_time;
-            ring_node_to_send_cwf_f2->fineTime      = waveform_picker_regs->f2_0_fine_time;
-            waveform_picker_regs->addr_data_f2_0    = current_ring_node_f2->buffer_address;
-            waveform_picker_regs->status            = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]
-        }
-        else if ( (waveform_picker_regs->status & 0x20) == 0x20)
-        {
-            ring_node_to_send_cwf_f2->coarseTime    = waveform_picker_regs->f2_1_coarse_time;
-            ring_node_to_send_cwf_f2->fineTime      = waveform_picker_regs->f2_1_fine_time;
-            waveform_picker_regs->addr_data_f2_1    = current_ring_node_f2->buffer_address;
-            waveform_picker_regs->status            = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]
-        }
-        // (2) send an event for the waveforms transmission
+        ring_node_to_send_cwf_f2->coarseTime    = waveform_picker_regs->f2_0_coarse_time;
+        ring_node_to_send_cwf_f2->fineTime      = waveform_picker_regs->f2_0_fine_time;
+        waveform_picker_regs->addr_data_f2_0    = current_ring_node_f2->buffer_address;
+        waveform_picker_regs->status            = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]
         if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) {
             spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );
         }
+        break;
+    case 2:
+        ring_node_to_send_cwf_f2    = current_ring_node_f2->previous;
+        current_ring_node_f2        = current_ring_node_f2->next;
+        ring_node_to_send_cwf_f2->coarseTime    = waveform_picker_regs->f2_1_coarse_time;
+        ring_node_to_send_cwf_f2->fineTime      = waveform_picker_regs->f2_1_fine_time;
+        waveform_picker_regs->addr_data_f2_1    = current_ring_node_f2->buffer_address;
+        waveform_picker_regs->status            = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]
+        if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) {
+            spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );
+        }
+        break;
+    default:
+        break;
     }
 }
 
@@ -442,13 +493,13 @@ rtems_task wfrm_task(rtems_task_argument
                             RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
         if(resynchronisationEngaged == false)
         {   // engage resynchronisation
-//            snapshot_resynchronization( (unsigned char *)  ring_node_to_send_swf_f0->coarseTime );
+            snapshot_resynchronization( (unsigned char *)  &ring_node_to_send_swf_f0->coarseTime );
             resynchronisationEngaged = true;
         }
         else
         {   // reset delta_snapshot to the nominal value
             PRINTF("no resynchronisation, reset delta_snapshot to the nominal value\n")
-//            set_wfp_delta_snapshot();
+            set_wfp_delta_snapshot();
             resynchronisationEngaged = false;
         }
         //
@@ -532,12 +583,11 @@ rtems_task cwf3_task(rtems_task_argument
             {
                 PRINTF("send CWF_LONG_F3\n")
                 ring_node_to_send_cwf_f3->sid = SID_NORM_CWF_LONG_F3;
-                status =  rtems_message_queue_send( queue_id, &ring_node_to_send_cwf_f2, sizeof( ring_node* ) );
+                status =  rtems_message_queue_send( queue_id, &ring_node_to_send_cwf_f3, sizeof( ring_node* ) );
             }
             else
             {
                 PRINTF("send CWF_F3 (light)\n")
-                ring_node_to_send_cwf_f3->sid = SID_NORM_CWF_F3;
                 send_waveform_CWF3_light( ring_node_to_send_cwf_f3, &ring_node_cwf3_light, queue_id );
             }
 
@@ -564,6 +614,7 @@ rtems_task cwf2_task(rtems_task_argument
     rtems_event_set event_out;
     rtems_id queue_id;
     rtems_status_code status;
+    ring_node *ring_node_to_send;
 
     status =  get_message_queue_id_send( &queue_id );
     if (status != RTEMS_SUCCESSFUL)
@@ -577,21 +628,26 @@ rtems_task cwf2_task(rtems_task_argument
         // wait for an RTEMS_EVENT
         rtems_event_receive( RTEMS_EVENT_MODE_BURST | RTEMS_EVENT_MODE_SBM2,
                             RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
+        ring_node_to_send = getRingNodeToSendCWF( 2 );
+        printf("ring_node_to_send_cwf === coarse = %x, fine = %x\n", ring_node_to_send->coarseTime, ring_node_to_send->fineTime);
+        printf("**0** %x . %x", waveform_ring_f2[0].coarseTime, waveform_ring_f2[0].fineTime);
+        printf(" **1** %x . %x", waveform_ring_f2[1].coarseTime, waveform_ring_f2[1].fineTime);
+        printf(" **2** %x . %x", waveform_ring_f2[2].coarseTime, waveform_ring_f2[2].fineTime);
+        printf(" **3** %x . %x", waveform_ring_f2[3].coarseTime, waveform_ring_f2[3].fineTime);
+        printf(" **4** %x . %x\n", waveform_ring_f2[4].coarseTime, waveform_ring_f2[4].fineTime);
         if (event_out == RTEMS_EVENT_MODE_BURST)
         {
-//            send_waveform_CWF( ring_node_to_send_cwf_f2, SID_BURST_CWF_F2, headerCWF_F2_BURST, queue_id );
-            ring_node_to_send_cwf_f2->sid = SID_BURST_CWF_F2;
-            status =  rtems_message_queue_send( queue_id, &ring_node_to_send_cwf_f2, sizeof( ring_node* ) );
+            ring_node_to_send->sid = SID_BURST_CWF_F2;
+            status =  rtems_message_queue_send( queue_id, &ring_node_to_send, sizeof( ring_node* ) );
         }
         if (event_out == RTEMS_EVENT_MODE_SBM2)
         {
-//            send_waveform_CWF( ring_node_to_send_cwf_f2, SID_SBM2_CWF_F2, headerCWF_F2_SBM2, queue_id );
-            ring_node_to_send_cwf_f2->sid = SID_SBM2_CWF_F2;
-            status =  rtems_message_queue_send( queue_id, &ring_node_to_send_cwf_f2, sizeof( ring_node* ) );
+            ring_node_to_send->sid = SID_SBM2_CWF_F2;
+            status =  rtems_message_queue_send( queue_id, &ring_node_to_send, sizeof( ring_node* ) );
             // launch snapshot extraction if needed
             if (extractSWF == true)
             {
-                ring_node_to_send_swf_f2 = ring_node_to_send_cwf_f2;
+                ring_node_to_send_swf_f2 = ring_node_to_send;
                 // extract the snapshot
                 build_snapshot_from_ring( ring_node_to_send_swf_f2, 2 );
                 // send the snapshot when built
@@ -623,7 +679,7 @@ rtems_task cwf1_task(rtems_task_argument
     rtems_id queue_id;
     rtems_status_code status;
 
-//    init_header_continuous_wf_table( SID_SBM1_CWF_F1, headerCWF_F1 );
+    ring_node * ring_node_to_send_cwf;
 
     status =  get_message_queue_id_send( &queue_id );
     if (status != RTEMS_SUCCESSFUL)
@@ -637,12 +693,19 @@ rtems_task cwf1_task(rtems_task_argument
         // wait for an RTEMS_EVENT
         rtems_event_receive( RTEMS_EVENT_MODE_SBM1,
                             RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
+        ring_node_to_send_cwf = getRingNodeToSendCWF( 1 );
+        printf("ring_node_to_send_cwf === coarse = %x, fine = %x\n", ring_node_to_send_cwf->coarseTime, ring_node_to_send_cwf->fineTime);
+        printf("**0** %x . %x", waveform_ring_f1[0].coarseTime, waveform_ring_f1[0].fineTime);
+        printf(" **1** %x . %x", waveform_ring_f1[1].coarseTime, waveform_ring_f1[1].fineTime);
+        printf(" **2** %x . %x", waveform_ring_f1[2].coarseTime, waveform_ring_f1[2].fineTime);
+        printf(" **3** %x . %x", waveform_ring_f1[3].coarseTime, waveform_ring_f1[3].fineTime);
+        printf(" **4** %x . %x\n\n", waveform_ring_f1[4].coarseTime, waveform_ring_f1[4].fineTime);
         ring_node_to_send_cwf_f1->sid = SID_SBM1_CWF_F1;
-        status =  rtems_message_queue_send( queue_id, &ring_node_to_send_cwf_f1, sizeof( ring_node* ) );
+        status =  rtems_message_queue_send( queue_id, &ring_node_to_send_cwf, sizeof( ring_node* ) );
         // launch snapshot extraction if needed
         if (extractSWF == true)
         {
-            ring_node_to_send_swf_f1 = ring_node_to_send_cwf_f1;
+            ring_node_to_send_swf_f1 = ring_node_to_send_cwf;
             // launch the snapshot extraction
             status = rtems_event_send( Task_id[TASKID_SWBD], RTEMS_EVENT_MODE_SBM1 );
             extractSWF = false;
@@ -750,18 +813,17 @@ void init_ring(ring_node ring[], unsigne
 
 void WFP_reset_current_ring_nodes( void )
 {
-    current_ring_node_f0      = waveform_ring_f0;
-    ring_node_to_send_swf_f0  = waveform_ring_f0;
+    current_ring_node_f0      = waveform_ring_f0[0].next;
+    current_ring_node_f1      = waveform_ring_f1[0].next;
+    current_ring_node_f2      = waveform_ring_f2[0].next;
+    current_ring_node_f3      = waveform_ring_f3[0].next;
 
-    current_ring_node_f1      = waveform_ring_f1;
-    ring_node_to_send_cwf_f1  = waveform_ring_f1;
+    ring_node_to_send_swf_f0  = waveform_ring_f0;
     ring_node_to_send_swf_f1  = waveform_ring_f1;
-
-    current_ring_node_f2      = waveform_ring_f2;
-    ring_node_to_send_cwf_f2  = waveform_ring_f2;
     ring_node_to_send_swf_f2  = waveform_ring_f2;
 
-    current_ring_node_f3      = waveform_ring_f3;
+    ring_node_to_send_cwf_f1  = waveform_ring_f1;
+    ring_node_to_send_cwf_f2  = waveform_ring_f2;
     ring_node_to_send_cwf_f3  = waveform_ring_f3;
 }
 
@@ -782,13 +844,10 @@ int send_waveform_CWF3_light( ring_node 
     unsigned int i;
     int ret;
     rtems_status_code status;
-    spw_ioctl_pkt_send spw_ioctl_send_CWF;
+
     char *sample;
     int *dataPtr;
 
-    spw_ioctl_send_CWF.hlen = TM_HEADER_LEN + 4 + 10; // + 4 is for the protocole extra header, + 10 is for the auxiliary header
-    spw_ioctl_send_CWF.options = 0;
-
     ret = LFR_DEFAULT;
 
     dataPtr     = (int*) ring_node_to_send->buffer_address;
@@ -1076,21 +1135,17 @@ void reset_wfp_status( void )
 void reset_wfp_buffer_addresses( void )
 {
     // F0
-    waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->buffer_address; // 0x08
-    current_ring_node_f0 = current_ring_node_f0->next;
-    waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address; // 0x0c
+    waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->previous->buffer_address;  // 0x08
+    waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address;            // 0x0c
     // F1
-    waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->buffer_address; // 0x10
-    current_ring_node_f1 = current_ring_node_f1->next;
-    waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address; // 0x14
+    waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->previous->buffer_address;  // 0x10
+    waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address;            // 0x14
     // F2
-    waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address; // 0x18
-    current_ring_node_f2 = current_ring_node_f2->next;
-    waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address; // 0x1c
+    waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->previous->buffer_address;  // 0x18
+    waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address;            // 0x1c
     // F3
-    waveform_picker_regs->addr_data_f3_0 = current_ring_node_f3->buffer_address; // 0x20
-    current_ring_node_f3 = current_ring_node_f3->next;
-    waveform_picker_regs->addr_data_f3_1 = current_ring_node_f3->buffer_address; // 0x24
+    waveform_picker_regs->addr_data_f3_0 = current_ring_node_f3->previous->buffer_address;  // 0x20
+    waveform_picker_regs->addr_data_f3_1 = current_ring_node_f3->buffer_address;            // 0x24
 }
 
 void reset_waveform_picker_regs( void )
diff --git a/testbenches/fsw_matrices_handling/deployment.pri b/testbenches/fsw_matrices_handling/deployment.pri
new file mode 100644
--- /dev/null
+++ b/testbenches/fsw_matrices_handling/deployment.pri
@@ -0,0 +1,191 @@
+# This file was generated by an application wizard of Qt Creator.
+# The code below handles deployment to Android and Maemo, aswell as copying
+# of the application data to shadow build directories on desktop.
+# It is recommended not to modify this file, since newer versions of Qt Creator
+# may offer an updated version of it.
+
+defineTest(qtcAddDeployment) {
+for(deploymentfolder, DEPLOYMENTFOLDERS) {
+    item = item$${deploymentfolder}
+    greaterThan(QT_MAJOR_VERSION, 4) {
+        itemsources = $${item}.files
+    } else {
+        itemsources = $${item}.sources
+    }
+    $$itemsources = $$eval($${deploymentfolder}.source)
+    itempath = $${item}.path
+    $$itempath= $$eval($${deploymentfolder}.target)
+    export($$itemsources)
+    export($$itempath)
+    DEPLOYMENT += $$item
+}
+
+MAINPROFILEPWD = $$PWD
+
+android-no-sdk {
+    for(deploymentfolder, DEPLOYMENTFOLDERS) {
+        item = item$${deploymentfolder}
+        itemfiles = $${item}.files
+        $$itemfiles = $$eval($${deploymentfolder}.source)
+        itempath = $${item}.path
+        $$itempath = /data/user/qt/$$eval($${deploymentfolder}.target)
+        export($$itemfiles)
+        export($$itempath)
+        INSTALLS += $$item
+    }
+
+    target.path = /data/user/qt
+
+    export(target.path)
+    INSTALLS += target
+} else:android {
+    for(deploymentfolder, DEPLOYMENTFOLDERS) {
+        item = item$${deploymentfolder}
+        itemfiles = $${item}.files
+        $$itemfiles = $$eval($${deploymentfolder}.source)
+        itempath = $${item}.path
+        $$itempath = /assets/$$eval($${deploymentfolder}.target)
+        export($$itemfiles)
+        export($$itempath)
+        INSTALLS += $$item
+    }
+
+    x86 {
+        target.path = /libs/x86
+    } else: armeabi-v7a {
+        target.path = /libs/armeabi-v7a
+    } else {
+        target.path = /libs/armeabi
+    }
+
+    export(target.path)
+    INSTALLS += target
+} else:win32 {
+    copyCommand =
+    for(deploymentfolder, DEPLOYMENTFOLDERS) {
+        source = $$MAINPROFILEPWD/$$eval($${deploymentfolder}.source)
+        source = $$replace(source, /, \\)
+        sourcePathSegments = $$split(source, \\)
+        target = $$OUT_PWD/$$eval($${deploymentfolder}.target)/$$last(sourcePathSegments)
+        target = $$replace(target, /, \\)
+        target ~= s,\\\\\\.?\\\\,\\,
+        !isEqual(source,$$target) {
+            !isEmpty(copyCommand):copyCommand += &&
+            isEqual(QMAKE_DIR_SEP, \\) {
+                copyCommand += $(COPY_DIR) \"$$source\" \"$$target\"
+            } else {
+                source = $$replace(source, \\\\, /)
+                target = $$OUT_PWD/$$eval($${deploymentfolder}.target)
+                target = $$replace(target, \\\\, /)
+                copyCommand += test -d \"$$target\" || mkdir -p \"$$target\" && cp -r \"$$source\" \"$$target\"
+            }
+        }
+    }
+    !isEmpty(copyCommand) {
+        copyCommand = @echo Copying application data... && $$copyCommand
+        copydeploymentfolders.commands = $$copyCommand
+        first.depends = $(first) copydeploymentfolders
+        export(first.depends)
+        export(copydeploymentfolders.commands)
+        QMAKE_EXTRA_TARGETS += first copydeploymentfolders
+    }
+} else:ios {
+    copyCommand =
+    for(deploymentfolder, DEPLOYMENTFOLDERS) {
+        source = $$MAINPROFILEPWD/$$eval($${deploymentfolder}.source)
+        source = $$replace(source, \\\\, /)
+        target = $CODESIGNING_FOLDER_PATH/$$eval($${deploymentfolder}.target)
+        target = $$replace(target, \\\\, /)
+        sourcePathSegments = $$split(source, /)
+        targetFullPath = $$target/$$last(sourcePathSegments)
+        targetFullPath ~= s,/\\.?/,/,
+        !isEqual(source,$$targetFullPath) {
+            !isEmpty(copyCommand):copyCommand += &&
+            copyCommand += mkdir -p \"$$target\"
+            copyCommand += && cp -r \"$$source\" \"$$target\"
+        }
+    }
+    !isEmpty(copyCommand) {
+        copyCommand = echo Copying application data... && $$copyCommand
+        !isEmpty(QMAKE_POST_LINK): QMAKE_POST_LINK += ";"
+        QMAKE_POST_LINK += "$$copyCommand"
+        export(QMAKE_POST_LINK)
+    }
+} else:unix {
+    maemo5 {
+        desktopfile.files = $${TARGET}.desktop
+        desktopfile.path = /usr/share/applications/hildon
+        icon.files = $${TARGET}64.png
+        icon.path = /usr/share/icons/hicolor/64x64/apps
+    } else:!isEmpty(MEEGO_VERSION_MAJOR) {
+        desktopfile.files = $${TARGET}_harmattan.desktop
+        desktopfile.path = /usr/share/applications
+        icon.files = $${TARGET}80.png
+        icon.path = /usr/share/icons/hicolor/80x80/apps
+    } else { # Assumed to be a Desktop Unix
+        copyCommand =
+        for(deploymentfolder, DEPLOYMENTFOLDERS) {
+            source = $$MAINPROFILEPWD/$$eval($${deploymentfolder}.source)
+            source = $$replace(source, \\\\, /)
+            macx {
+                target = $$OUT_PWD/$${TARGET}.app/Contents/Resources/$$eval($${deploymentfolder}.target)
+            } else {
+                target = $$OUT_PWD/$$eval($${deploymentfolder}.target)
+            }
+            target = $$replace(target, \\\\, /)
+            sourcePathSegments = $$split(source, /)
+            targetFullPath = $$target/$$last(sourcePathSegments)
+            targetFullPath ~= s,/\\.?/,/,
+            !isEqual(source,$$targetFullPath) {
+                !isEmpty(copyCommand):copyCommand += &&
+                copyCommand += $(MKDIR) \"$$target\"
+                copyCommand += && $(COPY_DIR) \"$$source\" \"$$target\"
+            }
+        }
+        !isEmpty(copyCommand) {
+            copyCommand = @echo Copying application data... && $$copyCommand
+            copydeploymentfolders.commands = $$copyCommand
+            first.depends = $(first) copydeploymentfolders
+            export(first.depends)
+            export(copydeploymentfolders.commands)
+            QMAKE_EXTRA_TARGETS += first copydeploymentfolders
+        }
+    }
+    !isEmpty(target.path) {
+        installPrefix = $${target.path}
+    } else {
+        installPrefix = /opt/$${TARGET}
+    }
+    for(deploymentfolder, DEPLOYMENTFOLDERS) {
+        item = item$${deploymentfolder}
+        itemfiles = $${item}.files
+        $$itemfiles = $$eval($${deploymentfolder}.source)
+        itempath = $${item}.path
+        $$itempath = $${installPrefix}/$$eval($${deploymentfolder}.target)
+        export($$itemfiles)
+        export($$itempath)
+        INSTALLS += $$item
+    }
+
+    !isEmpty(desktopfile.path) {
+        export(icon.files)
+        export(icon.path)
+        export(desktopfile.files)
+        export(desktopfile.path)
+        INSTALLS += icon desktopfile
+    }
+
+    isEmpty(target.path) {
+        target.path = $${installPrefix}/bin
+        export(target.path)
+    }
+    INSTALLS += target
+}
+
+export (ICON)
+export (INSTALLS)
+export (DEPLOYMENT)
+export (LIBS)
+export (QMAKE_EXTRA_TARGETS)
+}
+
diff --git a/testbenches/fsw_matrices_handling/fsw_matrices_handling.pro b/testbenches/fsw_matrices_handling/fsw_matrices_handling.pro
new file mode 100644
--- /dev/null
+++ b/testbenches/fsw_matrices_handling/fsw_matrices_handling.pro
@@ -0,0 +1,13 @@
+TEMPLATE = app
+CONFIG += console
+CONFIG -= app_bundle
+CONFIG -= qt
+
+SOURCES += main.c
+
+include(deployment.pri)
+qtcAddDeployment()
+
+HEADERS += \
+    functions.h
+
diff --git a/testbenches/fsw_matrices_handling/functions.h b/testbenches/fsw_matrices_handling/functions.h
new file mode 100644
--- /dev/null
+++ b/testbenches/fsw_matrices_handling/functions.h
@@ -0,0 +1,65 @@
+#define NB_VALUES_PER_SM 25
+#define NB_BINS_PER_SM   128
+
+#define NB_BINS_COMPRESSED_SM_F0    11
+#define ASM_F0_INDICE_START         17      // 88 bins
+#define ASM_F0_INDICE_STOP          104     // 2 packets of 44 bins
+#define NB_BINS_TO_AVERAGE_ASM_F0   8
+
+void ASM_reorganize_and_divide( float *averaged_spec_mat, float *averaged_spec_mat_reorganized, float divider )
+{
+    int frequencyBin;
+    int asmComponent;
+    unsigned int offsetASM;
+    unsigned int offsetASMReorganized;
+
+    // BUILD DATA
+    for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++)
+    {
+        for( frequencyBin = 0; frequencyBin < NB_BINS_PER_SM; frequencyBin++ )
+        {
+            offsetASMReorganized =
+                    frequencyBin * NB_VALUES_PER_SM
+                    + asmComponent;
+            offsetASM            =
+                    asmComponent * NB_BINS_PER_SM
+                    + frequencyBin;
+            averaged_spec_mat_reorganized[offsetASMReorganized  ] =
+                    averaged_spec_mat[ offsetASM ] / divider;
+        }
+    }
+}
+
+void ASM_compress_reorganize_and_divide(float *averaged_spec_mat, float *compressed_spec_mat , float divider,
+                                 unsigned char nbBinsCompressedMatrix, unsigned char nbBinsToAverage, unsigned char ASMIndexStart )
+{
+    int frequencyBin;
+    int asmComponent;
+    int offsetASM;
+    int offsetCompressed;
+    int k;
+
+    // BUILD DATA
+    for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++)
+    {
+        for( frequencyBin = 0; frequencyBin < nbBinsCompressedMatrix; frequencyBin++ )
+        {
+            offsetCompressed =  // NO TIME OFFSET
+                    frequencyBin * NB_VALUES_PER_SM
+                    + asmComponent;
+            offsetASM =         // NO TIME OFFSET
+                    asmComponent * NB_BINS_PER_SM
+                    + ASMIndexStart
+                    + frequencyBin * nbBinsToAverage;
+            compressed_spec_mat[ offsetCompressed ] = 0;
+            for ( k = 0; k < nbBinsToAverage; k++ )
+            {
+                compressed_spec_mat[offsetCompressed ] =
+                        ( compressed_spec_mat[ offsetCompressed ]
+                        + averaged_spec_mat[ offsetASM + k ] );
+            }
+            compressed_spec_mat[ offsetCompressed ] =
+                    compressed_spec_mat[ offsetCompressed ] / (divider * nbBinsToAverage);
+        }
+    }
+}
diff --git a/testbenches/fsw_matrices_handling/main.c b/testbenches/fsw_matrices_handling/main.c
new file mode 100644
--- /dev/null
+++ b/testbenches/fsw_matrices_handling/main.c
@@ -0,0 +1,64 @@
+#include <stdio.h>
+
+#include "functions.h"
+
+int main(void)
+{
+    printf("Hello World!\n");
+
+    unsigned int asmComponent;
+    unsigned int frequencyBin;
+    unsigned int offset_input_ASM;
+
+    float input_ASM             [ NB_VALUES_PER_SM * NB_BINS_PER_SM           ];
+    float output_ASM            [ NB_VALUES_PER_SM * NB_BINS_PER_SM           ];
+    float output_ASM_compressed [ NB_VALUES_PER_SM * NB_BINS_COMPRESSED_SM_F0 ];
+
+    //*******
+    // TEST 1
+
+    offset_input_ASM = 0;
+
+    for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++)
+    {
+        for (frequencyBin = 0; frequencyBin < NB_BINS_PER_SM; frequencyBin++)
+        {
+            offset_input_ASM = asmComponent * NB_BINS_PER_SM + frequencyBin;
+            input_ASM[ offset_input_ASM ] = asmComponent;
+        }
+    }
+
+    ASM_reorganize_and_divide( input_ASM, output_ASM,
+                               1 ); // divider
+
+    ASM_compress_reorganize_and_divide( input_ASM, output_ASM_compressed,
+                                        1,  // divider
+                                        NB_BINS_COMPRESSED_SM_F0,
+                                        NB_BINS_TO_AVERAGE_ASM_F0,
+                                        ASM_F0_INDICE_START);
+
+    //*******
+    // TEST 2
+    offset_input_ASM = 0;
+
+    for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++)
+    {
+        for (frequencyBin = 0; frequencyBin < NB_BINS_PER_SM; frequencyBin++)
+        {
+            offset_input_ASM = asmComponent * NB_BINS_PER_SM + frequencyBin;
+            input_ASM[ offset_input_ASM ] = asmComponent * NB_BINS_PER_SM + frequencyBin;
+        }
+    }
+
+    ASM_reorganize_and_divide( input_ASM, output_ASM,
+                               1 ); // divider
+
+    ASM_compress_reorganize_and_divide( input_ASM, output_ASM_compressed,
+                                        10,  // divider
+                                        NB_BINS_COMPRESSED_SM_F0,
+                                        NB_BINS_TO_AVERAGE_ASM_F0,
+                                        ASM_F0_INDICE_START);
+
+    return 0;
+}
+