HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/LFR_FSW Commit - r354:6155c628c251

3.2.0.5...

paul -

r354:6155c628c251 R3++

parent child

Context file:

r354:6155c628c251

Collapse all files

.hgsubstate +1 -1

@@ -1,2 +1,2
1	3081d1f9bb20b2b64a192585337a292a9804e0c5 LFR_basic-parameters	1	3081d1f9bb20b2b64a192585337a292a9804e0c5 LFR_basic-parameters
2	5dfc0745a617f0b14b9b4c6d6c12d01f1fb9a801 header/lfr_common_headers	2	26659466eb11170e587645c796142ac8a7fd0add header/lfr_common_headers

header/processing/fsw_processing.h +3 -1

             static inline void ASM_convert(volatile float *input_matrix, char *output_matrix);
+            unsigned char isPolluted( u_int64_t t0, u_int64_t t1, u_int64_t tbad0, u_int64_t tbad1 );
             unsigned char acquisitionTimeIsValid(unsigned int coarseTime, unsigned int fineTime, unsigned char channel);
             void SM_average( float *averaged_spec_mat_NORM, float *averaged_spec_mat_SBM,
                     sum = INIT_FLOAT;
                     for ( k = 0; k < NB_SM_BEFORE_AVF0_F1; k++ )
                     {
-                        if (incomingSMIsValid[k] == 1)
+                        if (incomingSMIsValid[k] == MATRIX_IS_NOT_POLLUTED)
                         {
                             sum = sum + ( (int *) (ring_node_tab[0]->buffer_address) ) [ i ] ;
                         }

src/CMakeLists.txt +1 -1

             set(SW_VERSION_N1 "3" CACHE STRING  "Choose N1 FSW Version." FORCE)
             set(SW_VERSION_N2 "2" CACHE STRING  "Choose N2 FSW Version." FORCE)
             set(SW_VERSION_N3 "0" CACHE STRING  "Choose N3 FSW Version." FORCE)
-            set(SW_VERSION_N4 "3" CACHE STRING  "Choose N4 FSW Version." FORCE)
+            set(SW_VERSION_N4 "5" CACHE STRING  "Choose N4 FSW Version." FORCE)
             if(FSW_verbose)
             	add_definitions(-DPRINT_MESSAGES_ON_CONSOLE)

src/fsw_globals.c 0 -2

             filterPar_t filterPar = {0};
             fbins_masks_t fbins_masks = {0};
-            unsigned int acquisitionDurations[NB_ACQUISITION_DURATION]
-            = {ACQUISITION_DURATION_F0, ACQUISITION_DURATION_F1, ACQUISITION_DURATION_F2};

src/processing/avf2_prc2.c +2 -2

                     sum = ( (int *) (ring_node->buffer_address) ) [ i ];
                     if ( (nbAverageNormF2 == 0) )   // average initialization
                     {
-                        if (keepMatrix == 1)    // keep the matrix and add it to the average
+                        if (keepMatrix == MATRIX_IS_NOT_POLLUTED)   // keep the matrix and add it to the average
                         {
                             averaged_spec_mat_f2[ i ] = sum;
                         }
                     }
                     else
                     {
-                        if (keepMatrix == 1)    // keep the matrix and add it to the average
+                        if (keepMatrix == MATRIX_IS_NOT_POLLUTED)   // keep the matrix and add it to the average
                         {
                             averaged_spec_mat_f2[ i ] = ( averaged_spec_mat_f2[  i ] + sum );
                         }

src/processing/fsw_processing.c +62 -49

@@ -718,82 +718,95 int getFBinMask( int index, unsigned cha
718	return fbin;	718	return fbin;
719	}	719	}
720		720
		721	unsigned char isPolluted( u_int64_t t0, u_int64_t t1, u_int64_t tbad0, u_int64_t tbad1 )
		722	{
		723	unsigned char polluted;
		724
		725	polluted = MATRIX_IS_NOT_POLLUTED;
		726
		727	if ( ((tbad0 < t0) && (t0 < tbad1)) // t0 is inside the polluted range
		728	\|\| ((tbad0 < t1) && (t1 < tbad1)) // t1 is inside the polluted range
		729	\|\| ((t0 < tbad0) && (tbad1 < t1)) // the polluted range is inside the signal range
		730	\|\| ((tbad0 < t0) && (t1 < tbad1))) // the signal range is inside the polluted range
		731	{
		732	polluted = MATRIX_IS_POLLUTED;
		733	}
		734
		735	return polluted;
		736	}
		737
721	unsigned char acquisitionTimeIsValid( unsigned int coarseTime, unsigned int fineTime, unsigned char channel)	738	unsigned char acquisitionTimeIsValid( unsigned int coarseTime, unsigned int fineTime, unsigned char channel)
722	{	739	{
723	u_int64_t ~~acquisitionTStart~~;	740	u_int64_t t0;
724	u_int64_t ~~acquisitionTStop~~;	741	u_int64_t t1;
725	u_int64_t t~~ime~~c~~odeReference~~;	742	u_int64_t tc;
		743	u_int64_t tbad0;
		744	u_int64_t tbad1;
		745
		746	u_int64_t modulusInFineTime;
726	u_int64_t offsetInFineTime;	747	u_int64_t offsetInFineTime;
727	u_int64_t shiftInFineTime;	748	u_int64_t shiftInFineTime;
728	u_int64_t tBadInFineTime;	749	u_int64_t tbadInFineTime;
729	u_int64_t perturbationTStart;	750
730	u_int64_t perturbationTStop;	751	u_int64_t timecodeReference;
		752
731	unsigned char pasFilteringIsEnabled;	753	unsigned char pasFilteringIsEnabled;
732	unsigned char ret;	754	unsigned char ret;
733		755
734	pasFilteringIsEnabled = (filterPar.spare_sy_lfr_pas_filter_enabled & 1); // [0000 0001]	756	pasFilteringIsEnabled = (filterPar.spare_sy_lfr_pas_filter_enabled & 1); // [0000 0001]
735	ret = 1;	757	ret = MATRIX_IS_NOT_POLLUTED;
		758
		759	// compute the acquitionTime range
		760	modulusInFineTime = ((u_int64_t) filterPar.sy_lfr_pas_filter_modulus) * CONST_65536;
		761	offsetInFineTime = ((u_int64_t) filterPar.sy_lfr_pas_filter_offset) * CONST_65536;
		762	shiftInFineTime = ((u_int64_t) filterPar.sy_lfr_pas_filter_shift) * CONST_65536;
		763	tbadInFineTime = ((u_int64_t) filterPar.sy_lfr_pas_filter_tbad) * CONST_65536;
736		764
737	// compute acquisition time from caoarseTime and fineTime	765	// compute acquisition time from caoarseTime and fineTime
738	~~acquisitionTStart~~ = ( ((u_int64_t)coarseTime) << SHIFT_2_BYTES )	766	t0 = ( ((u_int64_t)coarseTime) << SHIFT_2_BYTES ) + (u_int64_t) fineTime;
739	+ (u_int64_t) fineTime;
740	switch(channel)	767	switch(channel)
741	{	768	{
742	case CHANNELF0:	769	case CHANNELF0:
743	~~acquisitionTStop~~ = ~~acquisitionTStart~~ + ACQUISITION_DURATION_F0;	770	t1 = t0 + ACQUISITION_DURATION_F0;
		771	tc = t0 + HALF_ACQUISITION_DURATION_F0;
744	break;	772	break;
745	case CHANNELF1:	773	case CHANNELF1:
746	~~acquisitionTStop~~ = ~~acquisitionTStart~~ + ACQUISITION_DURATION_F1;	774	t1 = t0 + ACQUISITION_DURATION_F1;
		775	tc = t0 + HALF_ACQUISITION_DURATION_F1;
747	break;	776	break;
748	case CHANNELF2:	777	case CHANNELF2:
749	~~acquisitionTStop~~ = ~~acquisitionTStart~~ + ACQUISITION_DURATION_F2;	778	t1 = t0 + ACQUISITION_DURATION_F2;
		779	tc = t0 + HALF_ACQUISITION_DURATION_F2;
750	break;	780	break;
751	}	781	}
752		782
753	// compute the timecode reference	783	// INTERSECTION TEST #1
754	timecodeReference = (u_int64_t) ( (floor( ((double) coarseTime) / ((double) filterPar.sy_lfr_pas_filter_modulus) )	784	timecodeReference = (tc - (tc % modulusInFineTime)) - modulusInFineTime ;
755	* ((double) filterPar.sy_lfr_pas_filter_modulus)) * CONST_65536 );	785	tbad0 = timecodeReference + offsetInFineTime + shiftInFineTime;
756		786	tbad1 = timecodeReference + offsetInFineTime + shiftInFineTime + tbadInFineTime;
757	// compute the acquitionTime range	787	ret = isPolluted( t0, t1, tbad0, tbad1 );
758	offsetInFineTime = ((double) filterPar.sy_lfr_pas_filter_offset) * CONST_65536;
759	shiftInFineTime = ((double) filterPar.sy_lfr_pas_filter_shift) * CONST_65536;
760	tBadInFineTime = ((double) filterPar.sy_lfr_pas_filter_tbad) * CONST_65536;
761
762	perturbationTStart =
763	timecodeReference
764	+ offsetInFineTime
765	+ shiftInFineTime;
766		788
767	perturbationTStop =	789	// INTERSECTION TEST #2
768	timecodeReference	790	timecodeReference = (tc - (tc % modulusInFineTime)) ;
769	+ offsetInFineTime	791	tbad0 = timecodeReference + offsetInFineTime + shiftInFineTime;
770	+ shiftInFineTime	792	tbad1 = timecodeReference + offsetInFineTime + shiftInFineTime + tbadInFineTime;
771	+ tBadInFineTime;	793	if (ret == MATRIX_IS_NOT_POLLUTED)
772
773	if ( (acquisitionTStart >= perturbationTStart)
774	&& (acquisitionTStart <= perturbationTStop)
775	&& (pasFilteringIsEnabled == 1) )
776	{	794	{
777	ret = 0; // the acquisition time is INSIDE the range, the matrix shall be ignored	795	ret = isPolluted( t0, t1, tbad0, tbad1 );
778	}
779	else
780	{
781	ret = 1; // the acquisition time is OUTSIDE the range, the matrix can be used for the averaging
782	}	796	}
783		797
784	// the last sample of the data used to compute the matrix shall not be INSIDE the range, test it now, it depends on the channel	798	// INTERSECTION TEST #3
785	if (ret == 1)	799	timecodeReference = (tc - (tc % modulusInFineTime)) + modulusInFineTime ;
786	{	800	tbad0 = timecodeReference + offsetInFineTime + shiftInFineTime;
787	if ( (acquisitionTStop >= perturbationTStart)	801	tbad1 = timecodeReference + offsetInFineTime + shiftInFineTime + tbadInFineTime;
788	&& (acquisitionTStop <= perturbationTStop)	802	if (ret == MATRIX_IS_NOT_POLLUTED)
789	&& (pasFilteringIsEnabled == 1) )
790	{	803	{
791	ret = 0; // the acquisition time is INSIDE the range, the matrix shall be ignored	804	ret = isPolluted( t0, t1, tbad0, tbad1 );
792	}	805	}
793	else	806
		807	if (pasFilteringIsEnabled == 0)
794	{	808	{
795	ret = 1; // the acquisition time is OUTSIDE the range, the matrix can be used for the averaging	809	ret = MATRIX_IS_NOT_POLLUTED;
796	}
797	}	810	}
798		811
799	return ret;	812	return ret;

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