HG_REPOSITORIES/LPP/INSTRUMENTATION/SOLO_LFR/DEV_PLE Commit - r286:1a92544dda46

reaction wheels filtering implemented

paul -

r286:1a92544dda46 R3_plus

parent child

Context file:

r286:1a92544dda46

Collapse all files

.hgsubstate +1 -1

@@ -1,2 +1,2
1	3081d1f9bb20b2b64a192585337a292a9804e0c5 LFR_basic-parameters	1	3081d1f9bb20b2b64a192585337a292a9804e0c5 LFR_basic-parameters
2	d~~867fbc1a62231ed43bdda3e91b3f45f45806c3d~~ header/lfr_common_headers	2	dad8371a5549f3395f975fddc33098b05fd829f4 header/lfr_common_headers

header/fsw_init.h +1 0

             extern float cp_rpw_sc_rw3_f2;
             extern float cp_rpw_sc_rw4_f1;
             extern float cp_rpw_sc_rw4_f2;
+            extern float sy_lfr_sc_rw_delta_f;
             // RTEMS TASKS
             rtems_task Init( rtems_task_argument argument);

header/grlib_regs.h +1 -1

             // PDB >= 0.1.28, 0x80000f54
             typedef struct{
-                int data_shaping;       // 0x00 00 *** R1 R0 SP1 SP0 BW
+                int data_shaping;       // 0x00 00 *** R2 R1 R0 SP1 SP0 BW
                 int run_burst_enable;   // 0x04 01 *** [run *** burst f2, f1, f0 *** enable f3, f2, f1, f0 ]
                 int addr_data_f0_0;     // 0x08
                 int addr_data_f0_1;     // 0x0c

header/processing/fsw_processing.h +3 0

             extern unsigned char rw_fbins_mask_f0[16];
             extern unsigned char rw_fbins_mask_f1[16];
             extern unsigned char rw_fbins_mask_f2[16];
+            extern unsigned char merged_fbins_mask_f0[16];
+            extern unsigned char merged_fbins_mask_f1[16];
+            extern unsigned char merged_fbins_mask_f2[16];
             // registers
             extern time_management_regs_t *time_management_regs;

header/tc_load_dump_parameters.h +5 -5

             extern float k_coeff_intercalib_f1_norm[ ];
             extern float k_coeff_intercalib_f1_sbm[ ];
             extern float k_coeff_intercalib_f2[ ];
-            extern unsigned char rw_fbins_mask_f0[16];
+            extern fbins_masks_t fbins_masks;
-            extern unsigned char rw_fbins_mask_f1[16];
-            extern unsigned char rw_fbins_mask_f2[16];
             int action_load_common_par( ccsdsTelecommandPacket_t *TC );
             int action_load_normal_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time);
             unsigned int check_update_info_hk_tds_mode( unsigned char mode );
             unsigned int check_update_info_hk_thr_mode( unsigned char mode );
             void getReactionWheelsFrequencies( ccsdsTelecommandPacket_t *TC );
-            void build_rw_fbins_mask( unsigned int channel );
+            void setFBinMask(unsigned char *fbins_mask, float rw_f, unsigned char deltaFreq, unsigned char flag );
-            void build_rw_fbins_masks();
+            void build_sy_lfr_rw_mask( unsigned int channel );
+            void build_sy_lfr_rw_masks();
+            void merge_fbins_masks( void );
             // FBINS_MASK
             int set_sy_lfr_fbins( ccsdsTelecommandPacket_t *TC );

src/fsw_globals.c +3 -3

             float cp_rpw_sc_rw3_f2;
             float cp_rpw_sc_rw4_f1;
             float cp_rpw_sc_rw4_f2;
-            unsigned char rw_fbins_mask_f0[16];
+            float sy_lfr_sc_rw_delta_f;
-            unsigned char rw_fbins_mask_f1[16];
-            unsigned char rw_fbins_mask_f2[16];
+            fbins_masks_t fbins_masks;

src/fsw_init.c +1 0

                 cp_rpw_sc_rw3_f2 = 0.0;
                 cp_rpw_sc_rw4_f1 = 0.0;
                 cp_rpw_sc_rw4_f2 = 0.0;
+                sy_lfr_sc_rw_delta_f = 0.0;
                 update_last_valid_transition_date( DEFAULT_LAST_VALID_TRANSITION_DATE  );
                 // waveform picker initialization

src/processing/fsw_processing.c +3 -3

                 switch(channel)
                 {
                 case 0:
-                    sy_lfr_fbins_fx_word1 = parameter_dump_packet.sy_lfr_fbins_f0_word1;
+                    sy_lfr_fbins_fx_word1 = fbins_masks.merged_fbins_mask_f0;
                     break;
                 case 1:
-                    sy_lfr_fbins_fx_word1 = parameter_dump_packet.sy_lfr_fbins_f1_word1;
+                    sy_lfr_fbins_fx_word1 = fbins_masks.merged_fbins_mask_f1;
                     break;
                 case 2:
-                    sy_lfr_fbins_fx_word1 = parameter_dump_packet.sy_lfr_fbins_f2_word1;
+                    sy_lfr_fbins_fx_word1 = fbins_masks.merged_fbins_mask_f2;
                     break;
                 default:
                     PRINTF("ERR *** in getFBinMask, wrong frequency channel")

src/tc_handler.c +1 -1

                 // REACTION_WHEELS_FREQUENCY, copy the incoming parameters in the local variable (to be copied in HK packets)
                 cp_rpw_sc_rw_f_flags = bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW_F_FLAGS ];
                 getReactionWheelsFrequencies( TC );
-                build_rw_fbins_masks();
+                build_sy_lfr_rw_masks();
                 result = status;

src/tc_load_dump_parameters.c +94 -36

                     parameter_dump_packet.sy_lfr_sc_rw_delta_f[1]           = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + 1 ];
                     parameter_dump_packet.sy_lfr_sc_rw_delta_f[2]           = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + 2 ];
                     parameter_dump_packet.sy_lfr_sc_rw_delta_f[3]           = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + 3 ];
+                    // store the parameter sy_lfr_sc_rw_delta_f as a float
+                    copyFloatByChar( (unsigned char*) &sy_lfr_sc_rw_delta_f,
+                                     (unsigned char*) &parameter_dump_packet.sy_lfr_sc_rw_delta_f[0] );
                 }
                 return flag;
                  */
                 unsigned char * bytePosPtr; // pointer to the beginning of the incoming TC packet
-                unsigned char * floatPtr;   // pointer to the Most Significant Byte of the considered float
                 bytePosPtr = (unsigned char *) &TC->packetID;
                                  (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW4_F2 ] );
             }
-            void setFBinMask( unsigned char *fbins_mask, float freq, unsigned char deltaFreq, unsigned char flag )
+            void setFBinMask( unsigned char *fbins_mask, float rw_f, unsigned char deltaFreq, unsigned char flag )
             {
                 /** This function executes specific actions when a TC_LFR_UPDATE_INFO TeleCommand has been received.
                  *
                  * @param fbins_mask
-                 * @param freq
+                 * @param rw_f is the reaction wheel frequency to filter
-                 * @param deltaFreq
+                 * @param delta_f is the frequency step between the frequency bins, it depends on the frequency channel
                  * @param flag [true] filtering enabled [false] filtering disabled
                  *
                  * @return void
                  *
                  */
-                unsigned int fBelow;
+                float fmin;
+                float fMAX;
+                int binBelow;
+                int binAbove;
+                unsigned int whichByte;
+                unsigned char selectedByte;
+                int bin;
-                // compute the index of the frequency immediately below the reaction wheel frequency
+                whichByte = 0;
-                fBelow = (unsigned int) ( floor( ((double) cp_rpw_sc_rw1_f1) / ((double) deltaFreq)) );
+                bin = 0;
+                // compute the frequency range to filter [ rw_f - delta_f/2; rw_f + delta_f/2 ]
+                fmin = rw_f - sy_lfr_sc_rw_delta_f / 2.;
+                fMAX = rw_f + sy_lfr_sc_rw_delta_f / 2.;
-                if (fBelow < 127) // if fbelow is greater than 127 or equal to 127, this means that the reaction wheel frequency is outside the frequency range
+                // compute the index of the frequency bin immediately below fmin
+                binBelow = (int) ( floor( ((double) fmin) / ((double) deltaFreq)) );
+                // compute the index of the frequency bin immediately above fMAX
+                binAbove = (int) ( ceil( ((double) fMAX) / ((double) deltaFreq)) );
+                for (bin = binBelow; bin <= binAbove; bin++)
                 {
-                    if (flag == 1)
+                    if ( (bin >= 0) && (bin<=127) )
                     {
-            //            rw_fbins_mask[k] = (1 << fBelow) | (1 << fAbove);
+                        if (flag == 1)
+                        {
+                            whichByte = bin >> 3;   // division by 8
+                            selectedByte = (unsigned char) ( 1 << (bin - (whichByte * 8)) );
+                            fbins_mask[whichByte] = fbins_mask[whichByte] & (~selectedByte);
+                        }
                     }
                 }
             }
-            void build_rw_fbins_mask( unsigned int channel )
+            void build_sy_lfr_rw_mask( unsigned int channel )
             {
-                unsigned char rw_fbins_mask[16];
+                unsigned char local_rw_fbins_mask[16];
                 unsigned char *maskPtr;
                 double deltaF;
                 unsigned k;
                 k = 0;
+                maskPtr = NULL;
+                deltaF = 1.;
                 switch (channel)
                 {
                 case 0:
-                    maskPtr = rw_fbins_mask_f0;
+                    maskPtr = parameter_dump_packet.sy_lfr_rw_mask_f0_word1;
                     deltaF = 96.;
                     break;
                 case 1:
-                    maskPtr = rw_fbins_mask_f1;
+                    maskPtr = parameter_dump_packet.sy_lfr_rw_mask_f1_word1;
                     deltaF = 16.;
                     break;
                 case 2:
-                    maskPtr = rw_fbins_mask_f2;
+                    maskPtr = parameter_dump_packet.sy_lfr_rw_mask_f2_word1;
                     deltaF = 1.;
                     break;
                 default:
                 for (k = 0; k < 16; k++)
                 {
-                    rw_fbins_mask[k] = 0x00;
+                    local_rw_fbins_mask[k] = 0xff;
                 }
                 // RW1 F1
-                setFBinMask( rw_fbins_mask, fBelow );
+                setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw1_f1, deltaF, (cp_rpw_sc_rw_f_flags & 0x80) >> 7 );   // [1000 0000]
                 // RW1 F2
+                setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw1_f2, deltaF, (cp_rpw_sc_rw_f_flags & 0x40) >> 6 );   // [0100 0000]
                 // RW2 F1
+                setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw2_f1, deltaF, (cp_rpw_sc_rw_f_flags & 0x20) >> 5 );   // [0010 0000]
                 // RW2 F2
+                setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw2_f2, deltaF, (cp_rpw_sc_rw_f_flags & 0x10) >> 4 );   // [0001 0000]
                 // RW3 F1
+                setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw3_f1, deltaF, (cp_rpw_sc_rw_f_flags & 0x08) >> 3 );   // [0000 1000]
                 // RW3 F2
+                setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw3_f2, deltaF, (cp_rpw_sc_rw_f_flags & 0x04) >> 2 );   // [0000 0100]
                 // RW4 F1
+                setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw4_f1, deltaF, (cp_rpw_sc_rw_f_flags & 0x02) >> 1 );   // [0000 0010]
                 // RW4 F2
+                setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw1_f1, deltaF, (cp_rpw_sc_rw_f_flags & 0x01)       );  // [0000 0001]
                 // update the value of the fbins related to reaction wheels frequency filtering
-                for (k = 0; k < 16; k++)
+                if (maskPtr != NULL)
                 {
-                    maskPtr[k] = rw_fbins_mask[k];
+                    for (k = 0; k < 16; k++)
+                    {
+                        maskPtr[k] = local_rw_fbins_mask[k];
+                    }
                 }
             }
-            void build_rw_fbins_masks()
+            void build_sy_lfr_rw_masks( void )
+            {
+                build_sy_lfr_rw_mask( 0 );
+                build_sy_lfr_rw_mask( 1 );
+                build_sy_lfr_rw_mask( 2 );
+                merge_fbins_masks();
+            }
+            void merge_fbins_masks( void )
             {
-                build_rw_fbins_mask( 0 );
+                unsigned char k;
-                build_rw_fbins_mask( 1 );
-                build_rw_fbins_mask( 2 );
+                unsigned char *fbins_f0;
+                unsigned char *fbins_f1;
+                unsigned char *fbins_f2;
+                unsigned char *rw_mask_f0;
+                unsigned char *rw_mask_f1;
+                unsigned char *rw_mask_f2;
+                fbins_f0 = parameter_dump_packet.sy_lfr_fbins_f0_word1;
+                fbins_f1 = parameter_dump_packet.sy_lfr_fbins_f1_word1;
+                fbins_f2 = parameter_dump_packet.sy_lfr_fbins_f2_word1;
+                rw_mask_f0 = parameter_dump_packet.sy_lfr_rw_mask_f0_word1;
+                rw_mask_f1 = parameter_dump_packet.sy_lfr_rw_mask_f1_word1;
+                rw_mask_f2 = parameter_dump_packet.sy_lfr_rw_mask_f2_word1;
+                for( k=0; k < 16; k++ )
+                {
+                    fbins_masks.merged_fbins_mask_f0[k] = fbins_f0[k] & rw_mask_f0[k];
+                    fbins_masks.merged_fbins_mask_f1[k] = fbins_f1[k] & rw_mask_f1[k];
+                    fbins_masks.merged_fbins_mask_f2[k] = fbins_f2[k] & rw_mask_f2[k];
+                }
             }
             //***********
                 {
                     fbins_mask_dump[k] = fbins_mask_TC[k];
                 }
-                for (k=0; k < NB_FBINS_MASKS; k++)
-                    unsigned char *auxPtr;
-                    auxPtr = &parameter_dump_packet.sy_lfr_fbins_f0_word1[k*NB_BYTES_PER_FBINS_MASK];
                 return status;
             }
                 sy_lfr_pas_filter_enabled   = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_ENABLED ] & 0x01;   // [0000 0001]
                 sy_lfr_pas_filter_modulus   = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_MODULUS ];
                 copyFloatByChar(
-                            (char*) &sy_lfr_pas_filter_tbad,
+                            (unsigned char*) &sy_lfr_pas_filter_tbad,
-                            (char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD ]
+                            (unsigned char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD ]
                             );
                 sy_lfr_pas_filter_offset    = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_OFFSET ];
                 copyFloatByChar(
-                            (char*) &sy_lfr_pas_filter_shift,
+                            (unsigned char*) &sy_lfr_pas_filter_shift,
-                            (char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT ]
+                            (unsigned char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT ]
                             );
                 copyFloatByChar(
-                            (char*) &sy_lfr_sc_rw_delta_f,
+                            (unsigned char*) &sy_lfr_sc_rw_delta_f,
-                            (char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F ]
+                            (unsigned char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F ]
                             );
                 //******************

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