HG_REPOSITORIES/LPP/INSTRUMENTATION/SOLO_LFR/DEV_PLE Commit - r122:be6c6d813285

AVF1 and PRC1 tasks are functional now

paul -

r122:be6c6d813285 VHDLib206

parent child

Context file:

r122:be6c6d813285

Collapse all files

FSW-qt/Makefile +1 -1

             #############################################################################
             # Makefile for building: bin/fsw
-            # Generated by qmake (2.01a) (Qt 4.8.5) on: Tue Apr 22 18:10:21 2014
+            # Generated by qmake (2.01a) (Qt 4.8.5) on: Thu Apr 24 22:14:00 2014
             # Project:  fsw-qt.pro
             # Template: app
             # Command: /usr/bin/qmake-qt4 -spec /usr/lib64/qt4/mkspecs/linux-g++ -o Makefile fsw-qt.pro

FSW-qt/fsw-qt.pro.user +1 -1

             <?xml version="1.0" encoding="UTF-8"?>
             <!DOCTYPE QtCreatorProject>
-            <!-- Written by QtCreator 3.0.1, 2014-04-22T18:12:39. -->
+            <!-- Written by QtCreator 3.0.1, 2014-04-24T22:30:22. -->
             <qtcreator>
              <data>
               <variable>ProjectExplorer.Project.ActiveTarget</variable>

header/fsw_params.h +12 -13

             } ring_node;
             typedef struct {
-                unsigned int norm_bp1_f0;
+                unsigned int norm_bp1;
-                unsigned int norm_bp2_f0;
+                unsigned int norm_bp2;
-                unsigned int norm_asm_f0;
+                unsigned int norm_asm;
-                unsigned int burst_sbm_bp1_f0;
+                unsigned int burst_sbm_bp1;
-                unsigned int burst_sbm_bp2_f0;
+                unsigned int burst_sbm_bp2;
-                unsigned int burst_bp1_f0;
+                unsigned int burst_bp1;
-                unsigned int burst_bp2_f0;
+                unsigned int burst_bp2;
-                unsigned int sbm1_bp1_f0;
+                unsigned int sbm1_bp1;
-                unsigned int sbm1_bp2_f0;
+                unsigned int sbm1_bp2;
-                unsigned int sbm2_bp1_f0;
+                unsigned int sbm2_bp1;
-                unsigned int sbm2_bp2_f0;
+                unsigned int sbm2_bp2;
             } nb_sm_before_bp_asm_f0;
             typedef struct {
             #define TASKID_PRC1 17
             #define TASK_PRIORITY_SPIQ 5
-            //#define TASK_PRIORITY_SMIQ 10
             #define TASK_PRIORITY_WTDG 20
             #define TASK_PRIORITY_HOUS 30
             #define TASK_PRIORITY_CWF1 35   // CWF1 and CWF2 are never running together
             #define TASK_PRIORITY_RECV 50
             #define TASK_PRIORITY_ACTN 50
             #define TASK_PRIORITY_AVF0 60
+            #define TASK_PRIORITY_AVF1 70
             #define TASK_PRIORITY_PRC0 100
             #define TASK_PRIORITY_PRC1 100
-            #define TASK_PRIORITY_AVF1 60
             #define TASK_PRIORITY_STAT 200
             #define TASK_PRIORITY_DUMB 200

header/fsw_params_processing.h +7 -17

             //
             #define NB_BINS_PER_ASM_F1  104
             #define NB_BINS_PER_PKT_ASM_F1  52
-            #define TOTAL_SIZE_ASM_F1   2600    // 25 * 104
+            #define TOTAL_SIZE_ASM_F1_IN_BYTES   5200    // 25 * 104 * 2
             #define ASM_F1_INDICE_START 6       // 104 bins
             #define ASM_F1_INDICE_STOP  109     // 2 packets of 52 bins
             //
             #define NB_BINS_PER_ASM_F2  96
             #define NB_BINS_PER_PKT_ASM_F2  48
-            #define TOTAL_SIZE_ASM_F2   2400    // 25 * 96
+            #define TOTAL_SIZE_ASM_F2_IN_BYTES   4800    // 25 * 96 * 2
             #define ASM_F2_INDICE_START 7       // 96 bins
             #define ASM_F2_INDICE_STOP  102     // 2 packets of 48 bins
             //
             #define NB_BINS_TO_AVERAGE_ASM_SBM_F1   4
             #define NB_BINS_TO_AVERAGE_ASM_SBM_F2   4
             //
-            #define TOTAL_SIZE_COMPRESSED_ASM_F0    275     // 11 * 25 WORDS
+            #define TOTAL_SIZE_COMPRESSED_ASM_NORM_F0     275     // 11 * 25 WORDS
-            #define TOTAL_SIZE_COMPRESSED_ASM_F1    325     // 13 * 25 WORDS
+            #define TOTAL_SIZE_COMPRESSED_ASM_NORM_F1     325     // 13 * 25 WORDS
-            #define TOTAL_SIZE_COMPRESSED_ASM_F2    300     // 12 * 25 WORDS
+            #define TOTAL_SIZE_COMPRESSED_ASM_F2     300     // 12 * 25 WORDS
-            #define TOTAL_SIZE_COMPRESSED_ASM_SBM1  550     // 22 * 25 WORDS
+            #define TOTAL_SIZE_COMPRESSED_ASM_SBM_F0 550     // 22 * 25 WORDS
+            #define TOTAL_SIZE_COMPRESSED_ASM_SBM_F1 650     // 26 * 25 WORDS
             // NORM
             #define NB_SM_BEFORE_NORM_BP1_F0        384     // 96 * 4
-            #define NB_SM_BEFORE_NORM_BP2_F0        1920    // 96 * 20
-            #define NB_SM_BEFORE_NORM_ASM_F0        384     // 384 matrices at f0 = 4.00 second
-            // BURST
-            #define NB_SM_BEFORE_BURST_BP1_F0       96      // 96  matrices at f0 = 1.00 second
-            #define NB_SM_BEFORE_BURST_BP2_F0       480     // 480 matrices at f0 = 5.00 second
-            // SBM1
-            #define NB_SM_BEFORE_SBM1_BP1_F0        24      // 24  matrices at f0 = 0.25 second
-            #define NB_SM_BEFORE_SBM1_BP2_F0        96      // 96  matrices at f0 = 1.00 second
-            // SBM2
-            #define NB_SM_BEFORE_SBM2_BP1_F0        96      // 96  matrices at f0 = 1.00 second
-            #define NB_SM_BEFORE_SBM2_BP2_F0        480     // 480 matrices at f0 = 5.00 second
             // GENERAL
             #define NB_SM_BEFORE_AVF0               8
             #define NB_SM_BEFORE_AVF1               8

src/fsw_processing.c +103 -61

             #include "fsw_processing_globals.c"
             unsigned int nb_sm_f0;
+            unsigned int nb_sm_f0_aux;
+            unsigned int nb_sm_f1;
             //************************
             // spectral matrices rings
             float asm_f0_reorganized   [ TOTAL_SIZE_SM ];
             char  asm_f0_char          [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ];
-            float compressed_sm_norm_f0[ TOTAL_SIZE_COMPRESSED_ASM_F0   ];
+            float compressed_sm_norm_f0[ TOTAL_SIZE_COMPRESSED_ASM_NORM_F0];
-            float compressed_sm_sbm    [ TOTAL_SIZE_COMPRESSED_ASM_SBM1 ];
+            float compressed_sm_sbm_f0 [ TOTAL_SIZE_COMPRESSED_ASM_SBM_F0 ];
+            float asm_f1_reorganized   [ TOTAL_SIZE_SM ];
+            char  asm_f1_char          [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ];
+            float compressed_sm_norm_f1[ TOTAL_SIZE_COMPRESSED_ASM_NORM_F1];
+            float compressed_sm_sbm_f1 [ TOTAL_SIZE_COMPRESSED_ASM_SBM_F1 ];
             //***********************************************************
             // Interrupt Service Routine for spectral matrices processing
             void reset_nb_sm_f0( unsigned char lfrMode )
             {
                 nb_sm_f0 = 0;
+                nb_sm_f0_aux = 0;
-                nb_sm_before_f0.norm_bp1_f0 = parameter_dump_packet.sy_lfr_n_bp_p0 * 96;
+                nb_sm_before_f0.norm_bp1 = parameter_dump_packet.sy_lfr_n_bp_p0 * 96;
-                nb_sm_before_f0.norm_bp2_f0 = parameter_dump_packet.sy_lfr_n_bp_p1 * 96;
+                nb_sm_before_f0.norm_bp2 = parameter_dump_packet.sy_lfr_n_bp_p1 * 96;
-                nb_sm_before_f0.norm_asm_f0 = (parameter_dump_packet.sy_lfr_n_asm_p[0] * 256 + parameter_dump_packet.sy_lfr_n_asm_p[1]) * 96;
+                nb_sm_before_f0.norm_asm = (parameter_dump_packet.sy_lfr_n_asm_p[0] * 256 + parameter_dump_packet.sy_lfr_n_asm_p[1]) * 96;
-                nb_sm_before_f0.sbm1_bp1_f0 =  parameter_dump_packet.sy_lfr_s1_bp_p0 * 24;
+                nb_sm_before_f0.sbm1_bp1 =  parameter_dump_packet.sy_lfr_s1_bp_p0 * 24;
-                nb_sm_before_f0.sbm1_bp2_f0 =  parameter_dump_packet.sy_lfr_s1_bp_p1 * 96;
+                nb_sm_before_f0.sbm1_bp2 =  parameter_dump_packet.sy_lfr_s1_bp_p1 * 96;
-                nb_sm_before_f0.sbm2_bp1_f0 =  parameter_dump_packet.sy_lfr_s2_bp_p0 * 96;
+                nb_sm_before_f0.sbm2_bp1 =  parameter_dump_packet.sy_lfr_s2_bp_p0 * 96;
-                nb_sm_before_f0.sbm2_bp2_f0 =  parameter_dump_packet.sy_lfr_s2_bp_p1 * 96;
+                nb_sm_before_f0.sbm2_bp2 =  parameter_dump_packet.sy_lfr_s2_bp_p1 * 96;
-                nb_sm_before_f0.burst_bp1_f0 =  parameter_dump_packet.sy_lfr_b_bp_p0 * 96;
+                nb_sm_before_f0.burst_bp1 =  parameter_dump_packet.sy_lfr_b_bp_p0 * 96;
-                nb_sm_before_f0.burst_bp2_f0 =  parameter_dump_packet.sy_lfr_b_bp_p1 * 96;
+                nb_sm_before_f0.burst_bp2 =  parameter_dump_packet.sy_lfr_b_bp_p1 * 96;
                 if (lfrMode == LFR_MODE_SBM1)
                 {
-                    nb_sm_before_f0.burst_sbm_bp1_f0 =  nb_sm_before_f0.sbm1_bp1_f0;
+                    nb_sm_before_f0.burst_sbm_bp1 =  nb_sm_before_f0.sbm1_bp1;
-                    nb_sm_before_f0.burst_sbm_bp2_f0 =  nb_sm_before_f0.sbm1_bp2_f0;
+                    nb_sm_before_f0.burst_sbm_bp2 =  nb_sm_before_f0.sbm1_bp2;
                 }
                 else if (lfrMode == LFR_MODE_SBM2)
                 {
-                    nb_sm_before_f0.burst_sbm_bp1_f0 =  nb_sm_before_f0.sbm2_bp1_f0;
+                    nb_sm_before_f0.burst_sbm_bp1 =  nb_sm_before_f0.sbm2_bp1;
-                    nb_sm_before_f0.burst_sbm_bp2_f0 =  nb_sm_before_f0.sbm2_bp2_f0;
+                    nb_sm_before_f0.burst_sbm_bp2 =  nb_sm_before_f0.sbm2_bp2;
                 }
                 else if (lfrMode == LFR_MODE_BURST)
                 {
-                    nb_sm_before_f0.burst_sbm_bp1_f0 =  nb_sm_before_f0.burst_bp1_f0;
+                    nb_sm_before_f0.burst_sbm_bp1 =  nb_sm_before_f0.burst_bp1;
-                    nb_sm_before_f0.burst_sbm_bp2_f0 =  nb_sm_before_f0.burst_bp2_f0;
+                    nb_sm_before_f0.burst_sbm_bp2 =  nb_sm_before_f0.burst_bp2;
                 }
                 else
                 {
-                    nb_sm_before_f0.burst_sbm_bp1_f0 =  nb_sm_before_f0.burst_bp1_f0;
+                    nb_sm_before_f0.burst_sbm_bp1 =  nb_sm_before_f0.burst_bp1;
-                    nb_sm_before_f0.burst_sbm_bp2_f0 =  nb_sm_before_f0.burst_bp2_f0;
+                    nb_sm_before_f0.burst_sbm_bp2 =  nb_sm_before_f0.burst_bp2;
                 }
             }
             void reset_nb_sm_f1( unsigned char lfrMode )
             {
+                nb_sm_f1 = 0;
                 nb_sm_before_f1.norm_bp1  = parameter_dump_packet.sy_lfr_n_bp_p0 * 16;
                 nb_sm_before_f1.norm_bp2  = parameter_dump_packet.sy_lfr_n_bp_p1 * 16;
                 nb_sm_before_f1.norm_asm  = (parameter_dump_packet.sy_lfr_n_asm_p[0] * 256 + parameter_dump_packet.sy_lfr_n_asm_p[1]) * 16;
             rtems_isr spectral_matrices_isr_simu( rtems_vector_number vector )
             {
-                if (nb_sm_f0 == (NB_SM_BEFORE_AVF0-1) )
+                //***
+                // F0
+                nb_sm_f0 = nb_sm_f0 + 1;
+                if (nb_sm_f0 == NB_SM_BEFORE_AVF0 )
                 {
                     ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0;
                     if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
                     }
                     nb_sm_f0 = 0;
                 }
-                else
+                //***
+                // F1
+                nb_sm_f0_aux = nb_sm_f0_aux + 1;
+                if (nb_sm_f0_aux == 6)
                 {
-                    nb_sm_f0 = nb_sm_f0 + 1;
+                    nb_sm_f0_aux = 0;
+                    nb_sm_f1 = nb_sm_f1 + 1;
+                }
+                if (nb_sm_f1 == NB_SM_BEFORE_AVF1 )
+                {
+                    ring_node_for_averaging_sm_f1 = current_ring_node_sm_f1;
+                    if (rtems_event_send( Task_id[TASKID_AVF1], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
+                    {
+                        rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
+                    }
+                    nb_sm_f1 = 0;
                 }
             }
                 asm_msg msgForMATR;
                 ring_node_sm *ring_node_tab[8];
-                static unsigned int nb_norm_bp1;
+                unsigned int nb_norm_bp1;
-                static unsigned int nb_norm_bp2;
+                unsigned int nb_norm_bp2;
-                static unsigned int nb_norm_asm;
+                unsigned int nb_norm_asm;
-                static unsigned int nb_sbm_bp1;
+                unsigned int nb_sbm_bp1;
-                static unsigned int nb_sbm_bp2;
+                unsigned int nb_sbm_bp2;
                 nb_norm_bp1 = 0;
                 nb_norm_bp2 = 0;
                     msgForMATR.event      = 0x00;  // this composite event will be sent to the MATR task
                     msgForMATR.burst_sbm  = current_ring_node_asm_burst_sbm_f0;
                     msgForMATR.norm       = current_ring_node_asm_norm_f0;
-                    msgForMATR.coarseTime = ( (unsigned int *) (ring_node_tab[0]->buffer_address) )[0];
+            //        msgForMATR.coarseTime = ( (unsigned int *) (ring_node_tab[0]->buffer_address) )[0];
-                    msgForMATR.fineTime   = ( (unsigned int *) (ring_node_tab[0]->buffer_address) )[1];
+            //        msgForMATR.fineTime   = ( (unsigned int *) (ring_node_tab[0]->buffer_address) )[1];
+                    msgForMATR.coarseTime = time_management_regs->coarse_time;
+                    msgForMATR.fineTime   = time_management_regs->fine_time;
-                    if (nb_sbm_bp1 == nb_sm_before_f0.burst_sbm_bp1_f0)
+                    if (nb_sbm_bp1 == nb_sm_before_f0.burst_sbm_bp1)
                     {
                         nb_sbm_bp1 = 0;
                         // set another ring for the ASM storage
                         }
                     }
-                    if (nb_sbm_bp2 == nb_sm_before_f0.burst_sbm_bp2_f0)
+                    if (nb_sbm_bp2 == nb_sm_before_f0.burst_sbm_bp2)
                     {
                         nb_sbm_bp2 = 0;
                         if ( (lfrCurrentMode == LFR_MODE_BURST)
                         }
                     }
-                    if (nb_norm_bp1 == nb_sm_before_f0.norm_bp1_f0)
+                    if (nb_norm_bp1 == nb_sm_before_f0.norm_bp1)
                     {
                         nb_norm_bp1 = 0;
                         // set another ring for the ASM storage
                         }
                     }
-                    if (nb_norm_bp2 == nb_sm_before_f0.norm_bp2_f0)
+                    if (nb_norm_bp2 == nb_sm_before_f0.norm_bp2)
                     {
                         nb_norm_bp2 = 0;
                         if ( (lfrCurrentMode == LFR_MODE_NORMAL)
                         }
                     }
-                    if (nb_norm_asm == nb_sm_before_f0.norm_asm_f0)
+                    if (nb_norm_asm == nb_sm_before_f0.norm_asm)
                     {
                         nb_norm_asm = 0;
                         if ( (lfrCurrentMode == LFR_MODE_NORMAL)
                     if (incomingMsg->event & RTEMS_EVENT_BURST_SBM_BP1_F0 )
                     {
                         // 1)  compress the matrix for Basic Parameters calculation
-                        ASM_compress_reorganize_and_divide( incomingMsg->burst_sbm->matrix, compressed_sm_sbm,
+                        ASM_compress_reorganize_and_divide( incomingMsg->burst_sbm->matrix, compressed_sm_sbm_f0,
-                                                     nb_sm_before_f0.burst_sbm_bp1_f0,
+                                                     nb_sm_before_f0.burst_sbm_bp1,
                                                      NB_BINS_COMPRESSED_SM_SBM_F0, NB_BINS_TO_AVERAGE_ASM_SBM_F0,
                                                      ASM_F0_INDICE_START);
                         // 2) compute the BP1 set
                     {
                         // 1)  compress the matrix for Basic Parameters calculation
                         ASM_compress_reorganize_and_divide( incomingMsg->norm->matrix, compressed_sm_norm_f0,
-                                                     nb_sm_before_f0.norm_bp1_f0,
+                                                     nb_sm_before_f0.norm_bp1,
                                                      NB_BINS_COMPRESSED_SM_F0, NB_BINS_TO_AVERAGE_ASM_F0,
                                                      ASM_F0_INDICE_START );
                         // 2) compute the BP1 set
                                   PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0 + PACKET_LENGTH_DELTA);
                         if (incomingMsg->event & RTEMS_EVENT_NORM_BP2_F0)
                         {
-                            // 1) compute the BP2 set
+                            // 1) compute the BP2 set using the same ASM as the one used for BP1
                             // 2) send the BP2 set
                             set_time( packet_norm_bp2_f0.header.time,            (unsigned char *) &incomingMsg->coarseTime );
                     if (incomingMsg->event & RTEMS_EVENT_NORM_ASM_F0)
                     {
                         // 1) reorganize the ASM and divide
-                        ASM_reorganize_and_divide( incomingMsg->norm->matrix, asm_f0_reorganized, NB_SM_BEFORE_NORM_BP1_F0 );
+                        ASM_reorganize_and_divide( incomingMsg->norm->matrix,
+                                                   asm_f0_reorganized,
+                                                   nb_sm_before_f0.norm_bp1 );
                         // 2) convert the float array in a char array
                         ASM_convert( asm_f0_reorganized, asm_f0_char);
                         // 3) send the spectral matrix packets
                 asm_msg msgForMATR;
                 ring_node_sm *ring_node_tab[8];
-                static unsigned int nb_norm_bp1;
+                unsigned int nb_norm_bp1;
-                static unsigned int nb_norm_bp2;
+                unsigned int nb_norm_bp2;
-                static unsigned int nb_norm_asm;
+                unsigned int nb_norm_asm;
-                static unsigned int nb_sbm_bp1;
+                unsigned int nb_sbm_bp1;
-                static unsigned int nb_sbm_bp2;
+                unsigned int nb_sbm_bp2;
                 nb_norm_bp1 = 0;
                 nb_norm_bp2 = 0;
                     msgForMATR.event      = 0x00;  // this composite event will be sent to the PRC1 task
                     msgForMATR.burst_sbm  = current_ring_node_asm_burst_sbm_f1;
                     msgForMATR.norm       = current_ring_node_asm_norm_f1;
-                    msgForMATR.coarseTime = ( (unsigned int *) (ring_node_tab[0]->buffer_address) )[0];
+            //        msgForMATR.coarseTime = ( (unsigned int *) (ring_node_tab[0]->buffer_address) )[0];
-                    msgForMATR.fineTime   = ( (unsigned int *) (ring_node_tab[0]->buffer_address) )[1];
+            //        msgForMATR.fineTime   = ( (unsigned int *) (ring_node_tab[0]->buffer_address) )[1];
+                    msgForMATR.coarseTime = time_management_regs->coarse_time;
+                    msgForMATR.fineTime   = time_management_regs->fine_time;
                     if (nb_sbm_bp1 == nb_sm_before_f1.burst_sbm_bp1)
                     {
                         if ( (lfrCurrentMode == LFR_MODE_NORMAL)
                              || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )
                         {
-                            msgForMATR.event = msgForMATR.event | RTEMS_EVENT_NORM_BP1_F0;
+                            msgForMATR.event = msgForMATR.event | RTEMS_EVENT_NORM_BP1_F1;
                         }
                     }
                 //
                 spw_ioctl_pkt_send spw_ioctl_send_ASM;
                 rtems_status_code status;
-                rtems_id queue_id;
+                rtems_id queue_id_send;
                 rtems_id queue_id_q_p1;
                 Header_TM_LFR_SCIENCE_ASM_t headerASM;
                 bp_packet_with_spare packet_norm_bp1;
                 }
                 else
                 {
-                    PRINTF1("ERR *** in PRC1 *** unexpected lfrRequestedMode passed as argument = %d\n", (unsigned int) lfrRequestedMode)
+                    PRINTF1("in PRC1 *** lfrRequestedMode is %d, several headers not initialized\n", (unsigned int) lfrRequestedMode)
                 }
-                status =  get_message_queue_id_send( &queue_id );
+                status = get_message_queue_id_send( &queue_id_send );
                 if (status != RTEMS_SUCCESSFUL)
                 {
                     PRINTF1("in PRC1 *** ERR get_message_queue_id_send %d\n", status)
                     if (incomingMsg->event & RTEMS_EVENT_BURST_SBM_BP1_F1 )
                     {
                         // 1)  compress the matrix for Basic Parameters calculation
-                        ASM_compress_reorganize_and_divide( incomingMsg->burst_sbm->matrix, compressed_sm_sbm,
+                        ASM_compress_reorganize_and_divide( incomingMsg->burst_sbm->matrix, compressed_sm_sbm_f1,
                                                      nb_sm_before_f1.burst_sbm_bp1,
                                                      NB_BINS_COMPRESSED_SM_SBM_F1, NB_BINS_TO_AVERAGE_ASM_SBM_F1,
                                                      ASM_F1_INDICE_START);
                         // 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->fineTime   );
-                        BP_send( (char *) &packet_sbm_bp1.header, queue_id,
+                        BP_send( (char *) &packet_sbm_bp1.header, queue_id_send,
                                   PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F1 + PACKET_LENGTH_DELTA);
                         // 4) compute the BP2 set if needed
                         if ( incomingMsg->event & RTEMS_EVENT_BURST_SBM_BP2_F1 )
                             // 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->fineTime   );
-                            BP_send( (char *) &packet_sbm_bp2.header, queue_id,
+                            BP_send( (char *) &packet_sbm_bp2.header, queue_id_send,
                                       PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F1 + PACKET_LENGTH_DELTA);
                         }
                     }
                     if (incomingMsg->event & RTEMS_EVENT_NORM_BP1_F1)
                     {
                         // 1)  compress the matrix for Basic Parameters calculation
-                        ASM_compress_reorganize_and_divide( incomingMsg->norm->matrix, compressed_sm_norm_f0,
+                        ASM_compress_reorganize_and_divide( incomingMsg->norm->matrix, compressed_sm_norm_f1,
-                                                     nb_sm_before_f0.norm_bp1_f0,
+                                                     nb_sm_before_f0.norm_bp1,
                                                      NB_BINS_COMPRESSED_SM_F0, NB_BINS_TO_AVERAGE_ASM_F0,
                                                      ASM_F0_INDICE_START );
                         // 2) compute the BP1 set
                         // 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->fineTime   );
-                        BP_send( (char *) &packet_norm_bp1.header, queue_id,
+                        BP_send( (char *) &packet_norm_bp1.header, queue_id_send,
                                   PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F1 + PACKET_LENGTH_DELTA);
                         if (incomingMsg->event & RTEMS_EVENT_NORM_BP2_F1)
                         {
                             // 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->fineTime   );
-                            BP_send( (char *) &packet_norm_bp2.header, queue_id,
+                            BP_send( (char *) &packet_norm_bp2.header, queue_id_send,
                                       PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F1 + PACKET_LENGTH_DELTA);
                         }
                     }
                     if (incomingMsg->event & RTEMS_EVENT_NORM_ASM_F1)
                     {
                         // 1) reorganize the ASM and divide
-                        ASM_reorganize_and_divide( incomingMsg->norm->matrix, asm_f0_reorganized, NB_SM_BEFORE_NORM_BP1_F0 );
+                        ASM_reorganize_and_divide( incomingMsg->norm->matrix,
+                                                   asm_f1_reorganized,
+                                                   nb_sm_before_f0.norm_bp1 );
                         // 2) convert the float array in a char array
-                        ASM_convert( asm_f0_reorganized, asm_f0_char);
+                        ASM_convert( asm_f1_reorganized, asm_f1_char);
                         // 3) send the spectral matrix packets
                         set_time( headerASM.time           , (unsigned char *) &incomingMsg->coarseTime );
                         set_time( headerASM.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
-                        ASM_send( &headerASM, asm_f0_char, SID_NORM_ASM_F0, &spw_ioctl_send_ASM, queue_id);
+                        ASM_send( &headerASM, asm_f1_char, SID_NORM_ASM_F1, &spw_ioctl_send_ASM, queue_id_send);
                     }
                 }
                     switch(sid)
                     {
                     case SID_NORM_ASM_F0:
-                        spw_ioctl_send->dlen = TOTAL_SIZE_ASM_F0_IN_BYTES / 2;
+                        spw_ioctl_send->dlen = TOTAL_SIZE_ASM_F0_IN_BYTES / 2;  // 2 packets will be sent
                         spw_ioctl_send->data = &spectral_matrix[
                                 ( (ASM_F0_INDICE_START + (i*NB_BINS_PER_PKT_ASM_F0) ) * NB_VALUES_PER_SM ) * 2
                                 ];
                         header->pa_lfr_asm_blk_nr[1] = (unsigned char)    (NB_BINS_PER_PKT_ASM_F0);        // BLK_NR LSB
                         break;
                     case SID_NORM_ASM_F1:
+                        spw_ioctl_send->dlen = TOTAL_SIZE_ASM_F1_IN_BYTES / 2;  // 2 packets will be sent
+                        spw_ioctl_send->data = &spectral_matrix[
+                                ( (ASM_F1_INDICE_START + (i*NB_BINS_PER_PKT_ASM_F1) ) * NB_VALUES_PER_SM ) * 2
+                                ];
+                        length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F1;
+                        header->pa_lfr_asm_blk_nr[0] = (unsigned char)  ( (NB_BINS_PER_PKT_ASM_F1) >> 8 ); // BLK_NR MSB
+                        header->pa_lfr_asm_blk_nr[1] = (unsigned char)    (NB_BINS_PER_PKT_ASM_F1);        // BLK_NR LSB
                         break;
                     case SID_NORM_ASM_F2:
                         break;

src/tc_handler.c +1 -1

                     status = restart_science_tasks( mode );
                     launch_waveform_picker( mode, transitionCoarseTime );
             //        launch_spectral_matrix( );
-            //        launch_spectral_matrix_simu( );
+                    launch_spectral_matrix_simu( );
                 }
                 else if ( mode == LFR_MODE_STANDBY )
                 {

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages