HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/LFR_FSW Commit - r243:e8fa8af1f64c

BP sending filtered depending on the lastValidEnterModeTime

paul -

r243:e8fa8af1f64c R3a

parent child

Context file:

r243:e8fa8af1f64c

Collapse all files

.hgsubstate +1 -1

@@ -1,2 +1,2
1	3081d1f9bb20b2b64a192585337a292a9804e0c5 LFR_basic-parameters	1	3081d1f9bb20b2b64a192585337a292a9804e0c5 LFR_basic-parameters
2	ff85ce82cd9845f180cb578272717bcb76b62cb5 header/lfr_common_headers	2	ce0c2f17257170a8529605f68687c18f23973087 header/lfr_common_headers

header/processing/fsw_processing.h +22 -19

             void BP_reset_current_ring_nodes( void );
             void BP_init_header(bp_packet *packet,
-                                 unsigned int apid, unsigned char sid,
+                                unsigned int apid, unsigned char sid,
-                                 unsigned int packetLength , unsigned char blkNr);
+                                unsigned int packetLength , unsigned char blkNr);
             void BP_init_header_with_spare(bp_packet_with_spare *packet,
-                                            unsigned int apid, unsigned char sid,
+                                           unsigned int apid, unsigned char sid,
-                                            unsigned int packetLength, unsigned char blkNr );
+                                           unsigned int packetLength, unsigned char blkNr );
             void BP_send( char *data,
-                          rtems_id queue_id ,
+                          rtems_id queue_id,
                           unsigned int nbBytesToSend , unsigned int sid );
+            void BP_send_s1_s2(char *data,
+                               rtems_id queue_id,
+                               unsigned int nbBytesToSend, unsigned int sid );
             //******************
             // general functions
                                           asm_msg *msgForMATR );
             static inline void SM_average_debug(float *averaged_spec_mat_NORM, float *averaged_spec_mat_SBM,
-                                          ring_node *ring_node_tab[],
+                                                ring_node *ring_node_tab[],
-                                          unsigned int nbAverageNORM, unsigned int nbAverageSBM,
+                                                unsigned int nbAverageNORM, unsigned int nbAverageSBM,
-                                          asm_msg *msgForMATR );
+                                                asm_msg *msgForMATR );
             void ASM_patch( float *inputASM, float *outputASM );
             void extractReImVectors(float *inputASM, float *outputASM, unsigned int asmComponent );
             static inline void ASM_reorganize_and_divide(float *averaged_spec_mat, float *averaged_spec_mat_reorganized,
-                                           float divider );
+                                                         float divider );
             static inline void ASM_compress_reorganize_and_divide(float *averaged_spec_mat, float *compressed_spec_mat,
-                                              float divider,
+                                                                  float divider,
-                                              unsigned char nbBinsCompressedMatrix, unsigned char nbBinsToAverage , unsigned char ASMIndexStart);
+                                                                  unsigned char nbBinsCompressedMatrix, unsigned char nbBinsToAverage , unsigned char ASMIndexStart);
             static inline void ASM_convert(volatile float *input_matrix, char *output_matrix);
                         averaged_spec_mat_SBM[  i ] = ( averaged_spec_mat_SBM[   i ] + sum );
                         msgForMATR->coarseTimeNORM   = ring_node_tab[0]->coarseTime;
                         msgForMATR->fineTimeNORM     = ring_node_tab[0]->fineTime;
-            //            PRINTF2("ERR *** in SM_average *** unexpected parameters %d %d\n", nbAverageNORM, nbAverageSBM)
+                        //            PRINTF2("ERR *** in SM_average *** unexpected parameters %d %d\n", nbAverageNORM, nbAverageSBM)
                     }
                 }
             }
             void SM_average_debug( float *averaged_spec_mat_NORM, float *averaged_spec_mat_SBM,
-                             ring_node *ring_node_tab[],
+                                   ring_node *ring_node_tab[],
-                             unsigned int nbAverageNORM, unsigned int nbAverageSBM,
+                                   unsigned int nbAverageNORM, unsigned int nbAverageSBM,
-                             asm_msg *msgForMATR )
+                                   asm_msg *msgForMATR )
             {
                 float sum;
                 unsigned int i;
             }
             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 )
+                                                    unsigned char nbBinsCompressedMatrix, unsigned char nbBinsToAverage, unsigned char ASMIndexStart )
             {
                 int frequencyBin;
                 int asmComponent;
                         {
                             compressed_spec_mat[offsetCompressed ] =
                                     ( compressed_spec_mat[ offsetCompressed ]
-                                    + averaged_spec_mat[ offsetASM + k ] );
+                                      + averaged_spec_mat[ offsetASM + k ] );
                         }
                         compressed_spec_mat[ offsetCompressed ] =
                                 compressed_spec_mat[ offsetCompressed ] / (divider * nbBinsToAverage);
             }
             void ASM_compress_reorganize_and_divide_mask(float *averaged_spec_mat, float *compressed_spec_mat,
-                                              float divider,
+                                                         float divider,
-                                              unsigned char nbBinsCompressedMatrix, unsigned char nbBinsToAverage , unsigned char ASMIndexStart, unsigned char channel);
+                                                         unsigned char nbBinsCompressedMatrix, unsigned char nbBinsToAverage , unsigned char ASMIndexStart, unsigned char channel);
             int getFBinMask(int k, unsigned char channel);

header/tc_handler.h +2 -1

             #include "lfr_cpu_usage_report.h"
-            extern unsigned int lastValidTransitionDate;
+            extern unsigned int lastValidEnterModeTime;
+            extern enum lfr_transition_type_t lfrTransitionType;
             //****
             // ISR

src/fsw_globals.c +2 -1

             // MODE PARAMETERS
             Packet_TM_LFR_PARAMETER_DUMP_t parameter_dump_packet;
             struct param_local_str param_local;
-            unsigned int lastValidTransitionDate;
+            unsigned int lastValidEnterModeTime;
+            enum lfr_transition_type_t lfrTransitionType;
             // HK PACKETS
             Packet_TM_LFR_HK_t housekeeping_packet;

src/processing/avf0_prc0.c +2 -2

                         set_time( packet_sbm_bp1.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeSBM );
                         packet_sbm_bp1.biaStatusInfo = pa_bia_status_info;
                         packet_sbm_bp1.sy_lfr_common_parameters = parameter_dump_packet.sy_lfr_common_parameters;
-                        BP_send( (char *) &packet_sbm_bp1, queue_id,
+                        BP_send_s1_s2( (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
                             set_time( packet_sbm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeSBM );
                             packet_sbm_bp2.biaStatusInfo = pa_bia_status_info;
                             packet_sbm_bp2.sy_lfr_common_parameters = parameter_dump_packet.sy_lfr_common_parameters;
-                            BP_send( (char *) &packet_sbm_bp2, queue_id,
+                            BP_send_s1_s2( (char *) &packet_sbm_bp2, queue_id,
                                      PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0 + PACKET_LENGTH_DELTA,
                                      sid);
                         }

src/processing/avf1_prc1.c +2 -2

                         set_time( packet_sbm_bp1.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeSBM );
                         packet_sbm_bp1.biaStatusInfo = pa_bia_status_info;
                         packet_sbm_bp1.sy_lfr_common_parameters = parameter_dump_packet.sy_lfr_common_parameters;
-                        BP_send( (char *) &packet_sbm_bp1, queue_id_send,
+                        BP_send_s1_s2( (char *) &packet_sbm_bp1, queue_id_send,
                                  PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F1 + PACKET_LENGTH_DELTA,
                                  sid );
                         // 4) compute the BP2 set if needed
                             set_time( packet_sbm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeSBM );
                             packet_sbm_bp2.biaStatusInfo = pa_bia_status_info;
                             packet_sbm_bp2.sy_lfr_common_parameters = parameter_dump_packet.sy_lfr_common_parameters;
-                            BP_send( (char *) &packet_sbm_bp2, queue_id_send,
+                            BP_send_s1_s2( (char *) &packet_sbm_bp2, queue_id_send,
                                      PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F1 + PACKET_LENGTH_DELTA,
                                      sid );
                         }

src/processing/fsw_processing.c +28 0

@@ -386,6 +386,34 void BP_send(char *data, rtems_id queue_
386	}	386	}
387	}	387	}
388		388
		389	void BP_send_s1_s2(char *data, rtems_id queue_id, unsigned int nbBytesToSend, unsigned int sid )
		390	{
		391	/** This function is used to send the BP paquets when needed.
		392	*
		393	* @param transitionCoarseTime is the requested transition time contained in the TC_LFR_ENTER_MODE
		394	*
		395	* @return void
		396	*
		397	* SBM1 and SBM2 paquets are sent depending on the type of the LFR mode transition.
		398	* BURST paquets are sent everytime.
		399	*
		400	*/
		401
		402	rtems_status_code status;
		403
		404	// SEND PACKET
		405	// before lastValidTransitionDate, the data are drops even if they are ready
		406	// this guarantees that no SBM packets will be received before the requestion enter mode time
		407	if ( time_management_regs->coarse_time >= lastValidEnterModeTime)
		408	{
		409	status = rtems_message_queue_send( queue_id, data, nbBytesToSend);
		410	if (status != RTEMS_SUCCESSFUL)
		411	{
		412	PRINTF1("ERR * in BP_send * ERR %d\n", (int) status)
		413	}
		414	}
		415	}
		416
389	//******************	417	//******************
390	// general functions	418	// general functions
391		419

src/tc_handler.c +16 -2

                 {
                     PRINTF1("OK  *** in action_enter_mode *** enter mode %d\n", requestedMode);
+                    update_last_valid_transition_date( transitionCoarseTime );
                     switch(requestedMode)
                     {
             void update_last_valid_transition_date(unsigned int transitionCoarseTime)
             {
-                lastValidTransitionDate = transitionCoarseTime;
+                lastValidEnterModeTime = transitionCoarseTime;
             }
             int check_transition_date( unsigned int transitionCoarseTime )
                 int status;
                 status = stop_current_mode();       // STOP THE CURRENT MODE
+                lfrTransitionType = TRANSITION_NOT_SPECIFIC;
             #ifdef PRINT_TASK_STATISTICS
                 rtems_cpu_usage_report();
                 switch( lfrCurrentMode )
                 {
                 case LFR_MODE_STANDBY:
+                    lfrTransitionType = TRANSITION_NOT_SPECIFIC;
                     status = restart_science_tasks( LFR_MODE_NORMAL ); // restart science tasks
                     if (status == RTEMS_SUCCESSFUL)         // relaunch spectral_matrix and waveform_picker modules
                     {
                     }
                     break;
                 case LFR_MODE_BURST:
+                    lfrTransitionType = TRANSITION_NOT_SPECIFIC;
                     status = stop_current_mode();           // stop the current mode
                     status = restart_science_tasks( LFR_MODE_NORMAL ); // restart the science tasks
                     if (status == RTEMS_SUCCESSFUL)         // relaunch spectral_matrix and waveform_picker modules
                     }
                     break;
                 case LFR_MODE_SBM1:
+                    lfrTransitionType = TRANSITION_S1_TO_NORM;
                     restart_asm_activities( LFR_MODE_NORMAL ); //  this is necessary to restart ASM tasks to update the parameters
                     status = LFR_SUCCESSFUL;                   // lfrCurrentMode will be updated after the execution of close_action
                     break;
                 case LFR_MODE_SBM2:
+                    lfrTransitionType = TRANSITION_S2_TO_NORM;
                     restart_asm_activities( LFR_MODE_NORMAL ); //  this is necessary to restart ASM tasks to update the parameters
                     status = LFR_SUCCESSFUL;                   // lfrCurrentMode will be updated after the execution of close_action
                     break;
                 rtems_cpu_usage_reset();
             #endif
+                lfrTransitionType = TRANSITION_NOT_SPECIFIC;
                 status = stop_current_mode();           // stop the current mode
                 status = restart_science_tasks( LFR_MODE_BURST ); // restart the science tasks
                 if (status == RTEMS_SUCCESSFUL)         // relaunch spectral_matrix and waveform_picker modules
                 switch( lfrCurrentMode )
                 {
                 case LFR_MODE_STANDBY:
+                    lfrTransitionType = TRANSITION_NOT_SPECIFIC;
                     status = restart_science_tasks( LFR_MODE_SBM1 ); // restart science tasks
                     if (status == RTEMS_SUCCESSFUL)         // relaunch spectral_matrix and waveform_picker modules
                     {
                     }
                     break;
                 case LFR_MODE_NORMAL:                       // lfrCurrentMode will be updated after the execution of close_action
+                    lfrTransitionType = TRANSITION_NORM_TO_S1;
                     restart_asm_activities( LFR_MODE_SBM1 );
                     status = LFR_SUCCESSFUL;
                     break;
                 case LFR_MODE_BURST:
+                    lfrTransitionType = TRANSITION_NOT_SPECIFIC;
                     status = stop_current_mode();           // stop the current mode
                     status = restart_science_tasks( LFR_MODE_SBM1 ); // restart the science tasks
                     if (status == RTEMS_SUCCESSFUL)         // relaunch spectral_matrix and waveform_picker modules
                     }
                     break;
                 case LFR_MODE_SBM2:
+                    lfrTransitionType = TRANSITION_S2_TO_S1;
                     restart_asm_activities( LFR_MODE_SBM1 );
                     status = LFR_SUCCESSFUL;                // lfrCurrentMode will be updated after the execution of close_action
                     break;
                 switch( lfrCurrentMode )
                 {
                 case LFR_MODE_STANDBY:
+                    lfrTransitionType = TRANSITION_NOT_SPECIFIC;
                     status = restart_science_tasks( LFR_MODE_SBM2 ); // restart science tasks
                     if (status == RTEMS_SUCCESSFUL)         // relaunch spectral_matrix and waveform_picker modules
                     {
                     }
                     break;
                 case LFR_MODE_NORMAL:
+                    lfrTransitionType = TRANSITION_NORM_TO_S2;
                     restart_asm_activities( LFR_MODE_SBM2 );
                     status = LFR_SUCCESSFUL;                // lfrCurrentMode will be updated after the execution of close_action
                     break;
                 case LFR_MODE_BURST:
+                    lfrTransitionType = TRANSITION_NOT_SPECIFIC;
                     status = stop_current_mode();           // stop the current mode
                     status = restart_science_tasks( LFR_MODE_SBM2 ); // restart the science tasks
                     if (status == RTEMS_SUCCESSFUL)         // relaunch spectral_matrix and waveform_picker modules
                     }
                     break;
                 case LFR_MODE_SBM1:
+                    lfrTransitionType = TRANSITION_S1_TO_S2;
                     restart_asm_activities( LFR_MODE_SBM2 );
                     status = LFR_SUCCESSFUL;                // lfrCurrentMode will be updated after the execution of close_action
                     break;

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