diff --git a/FSW-qt/fsw-qt.pro.user b/FSW-qt/fsw-qt.pro.user --- a/FSW-qt/fsw-qt.pro.user +++ b/FSW-qt/fsw-qt.pro.user @@ -1,6 +1,6 @@ - + ProjectExplorer.Project.ActiveTarget diff --git a/header/ccsds_types.h b/header/ccsds_types.h --- a/header/ccsds_types.h +++ b/header/ccsds_types.h @@ -209,8 +209,8 @@ enum apid_destid{ #define PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0 (126 - CCSDS_TC_TM_PACKET_OFFSET) // 11 * 9 + 27 - 7 #define PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0 (356 - CCSDS_TC_TM_PACKET_OFFSET) // 11 * 30 + 25 - 7 #define PACKET_LENGTH_TM_LFR_SCIENCE_BURST_BP2_F1 (806 - CCSDS_TC_TM_PACKET_OFFSET) // 26 * 30 + 26 - 7 -#define PACKET_LENGTH_TM_LFR_SCIENCE_SBM1_BP1_F0 (224 - CCSDS_TC_TM_PACKET_OFFSET) // 22 * 9 + 26 - 7 -#define PACKET_LENGTH_TM_LFR_SCIENCE_SBM1_BP2_F0 (686 - CCSDS_TC_TM_PACKET_OFFSET) // 22 * 30 + 26 - 7 +#define PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0 (224 - CCSDS_TC_TM_PACKET_OFFSET) // 22 * 9 + 26 - 7 +#define PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0 (686 - CCSDS_TC_TM_PACKET_OFFSET) // 22 * 30 + 26 - 7 #define PACKET_LENGTH_DELTA 11 // 7 + 4 diff --git a/header/fsw_misc.h b/header/fsw_misc.h --- a/header/fsw_misc.h +++ b/header/fsw_misc.h @@ -34,6 +34,7 @@ rtems_task dumb_task( rtems_task_argumen void init_housekeeping_parameters( void ); void increment_seq_counter( unsigned char *packet_sequence_control); void getTime( unsigned char *time); +unsigned long long int getTimeAsUnsignedLongLongInt( ); void send_dumb_hk( void ); #endif // FSW_MISC_H_INCLUDED diff --git a/header/fsw_params.h b/header/fsw_params.h --- a/header/fsw_params.h +++ b/header/fsw_params.h @@ -18,6 +18,29 @@ typedef struct ring_node unsigned int status; } ring_node; +typedef struct { + unsigned int f0; + unsigned int norm_bp1_f0; + unsigned int norm_bp2_f0; + unsigned int norm_asm_f0; + unsigned int sbm_bp1_f0; + unsigned int sbm_bp2_f0; +} nb_sm_t; + +typedef struct { + unsigned int norm_bp1_f0; + unsigned int norm_bp2_f0; + unsigned int norm_asm_f0; + unsigned int burst_sbm_bp1_f0; + unsigned int burst_sbm_bp2_f0; + unsigned int burst_bp1_f0; + unsigned int burst_bp2_f0; + unsigned int sbm1_bp1_f0; + unsigned int sbm1_bp2_f0; + unsigned int sbm2_bp1_f0; + unsigned int sbm2_bp2_f0; +} nb_sm_before_bp_t; + //************************ // flight software version // this parameters is handled by the Qt project options @@ -55,17 +78,17 @@ typedef struct ring_node #define THR_MODE_NORMAL 1 #define THR_MODE_BURST 2 -#define RTEMS_EVENT_MODE_STANDBY RTEMS_EVENT_0 -#define RTEMS_EVENT_MODE_NORMAL RTEMS_EVENT_1 -#define RTEMS_EVENT_MODE_BURST RTEMS_EVENT_2 -#define RTEMS_EVENT_MODE_SBM1 RTEMS_EVENT_3 -#define RTEMS_EVENT_MODE_SBM2 RTEMS_EVENT_4 -#define RTEMS_EVENT_MODE_SBM2_WFRM RTEMS_EVENT_5 -#define RTEMS_EVENT_NORM_BP1_F0 RTEMS_EVENT_6 -#define RTEMS_EVENT_NORM_BP2_F0 RTEMS_EVENT_7 -#define RTEMS_EVENT_NORM_ASM_F0 RTEMS_EVENT_8 -#define RTEMS_EVENT_SBM1_BP1_F0 RTEMS_EVENT_9 -#define RTEMS_EVENT_SBM1_BP2_F0 RTEMS_EVENT_10 +#define RTEMS_EVENT_MODE_STANDBY RTEMS_EVENT_0 +#define RTEMS_EVENT_MODE_NORMAL RTEMS_EVENT_1 +#define RTEMS_EVENT_MODE_BURST RTEMS_EVENT_2 +#define RTEMS_EVENT_MODE_SBM1 RTEMS_EVENT_3 +#define RTEMS_EVENT_MODE_SBM2 RTEMS_EVENT_4 +#define RTEMS_EVENT_MODE_SBM2_WFRM RTEMS_EVENT_5 +#define RTEMS_EVENT_NORM_BP1_F0 RTEMS_EVENT_6 +#define RTEMS_EVENT_NORM_BP2_F0 RTEMS_EVENT_7 +#define RTEMS_EVENT_NORM_ASM_F0 RTEMS_EVENT_8 +#define RTEMS_EVENT_BURST_SBM_BP1_F0 RTEMS_EVENT_9 +#define RTEMS_EVENT_BURST_SBM_BP2_F0 RTEMS_EVENT_10 //**************************** // LFR DEFAULT MODE PARAMETERS @@ -126,7 +149,7 @@ typedef struct ring_node //***** // TIME -#define CLKDIV_SM_SIMULATOR (10000 - 1) // 10 ms +#define CLKDIV_SM_SIMULATOR (10416 - 1) // 10 ms => nominal is 1/96 = 0.010416667, 10417 - 1 = 10416 #define TIMER_SM_SIMULATOR 1 #define HK_PERIOD 100 // 100 * 10ms => 1s #define SY_LFR_TIME_SYN_TIMEOUT_in_ms 2000 diff --git a/header/fsw_params_nb_bytes.h b/header/fsw_params_nb_bytes.h --- a/header/fsw_params_nb_bytes.h +++ b/header/fsw_params_nb_bytes.h @@ -12,10 +12,16 @@ #define DATAFIELD_POS_SY_LFR_N_CWF_LONG_F3 8 // TC_LFR_LOAD_BURST_PAR +#define DATAFIELD_POS_SY_LFR_B_BP_P0 0 +#define DATAFIELD_POS_SY_LFR_B_BP_P1 1 // TC_LFR_LOAD_SBM1_PAR +#define DATAFIELD_POS_SY_LFR_S1_BP_P0 0 +#define DATAFIELD_POS_SY_LFR_S1_BP_P1 1 // TC_LFR_LOAD_SBM2_PAR +#define DATAFIELD_POS_SY_LFR_S2_BP_P0 0 +#define DATAFIELD_POS_SY_LFR_S2_BP_P1 1 // TC_LFR_UPDATE_INFO #define BYTE_POS_UPDATE_INFO_PARAMETERS_SET5 34 diff --git a/header/fsw_params_processing.h b/header/fsw_params_processing.h --- a/header/fsw_params_processing.h +++ b/header/fsw_params_processing.h @@ -9,11 +9,10 @@ #define TOTAL_SIZE_NORM_BP1_F2 108 // 12 * 9 = 108 #define TOTAL_SIZE_SBM1_BP1_F0 198 // 22 * 9 = 198 // -#define NB_RING_NODES_ASM_F0 12 // AT LEAST 3 -#define NB_RING_NODES_ASM_F1 2 // AT LEAST 3 -#define NB_RING_NODES_ASM_F2 2 // AT LEAST 3 -#define NB_RING_NODES_SBM1_BP1 10 // AT LEAST 3 -#define NB_RING_NODES_SBM1_BP2 5 // AT LEAST 3 +#define NB_RING_NODES_SM_F0 12 // AT LEAST 3 +#define NB_RING_NODES_SM_F1 3 // AT LEAST 3 +#define NB_RING_NODES_SM_F2 3 // AT LEAST 3 +#define NB_RING_NODES_ASM_BURST_SBM_F0 10 // AT LEAST 3 // #define NB_BINS_PER_ASM_F0 88 #define NB_BINS_PER_PKT_ASM_F0 44 @@ -36,22 +35,32 @@ #define NB_BINS_COMPRESSED_SM_F0 11 #define NB_BINS_COMPRESSED_SM_F1 13 #define NB_BINS_COMPRESSED_SM_F2 12 -#define NB_BINS_COMPRESSED_SM_SBM1_F0 22 +#define NB_BINS_COMPRESSED_SM_SBM_F0 22 + // -#define NB_BINS_TO_AVERAGE_ASM_F0 8 -#define NB_BINS_TO_AVERAGE_ASM_F1 8 -#define NB_BINS_TO_AVERAGE_ASM_F2 8 -#define NB_BINS_TO_AVERAGE_ASM_SBM1_F0 4 +#define NB_BINS_TO_AVERAGE_ASM_F0 8 +#define NB_BINS_TO_AVERAGE_ASM_F1 8 +#define NB_BINS_TO_AVERAGE_ASM_F2 8 +#define NB_BINS_TO_AVERAGE_ASM_SBM_F0 4 // #define TOTAL_SIZE_COMPRESSED_ASM_F0 275 // 11 * 25 WORDS #define TOTAL_SIZE_COMPRESSED_ASM_F1 325 // 13 * 25 WORDS #define TOTAL_SIZE_COMPRESSED_ASM_F2 300 // 12 * 25 WORDS #define TOTAL_SIZE_COMPRESSED_ASM_SBM1 550 // 22 * 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 -#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 +// 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 #endif // FSW_PARAMS_PROCESSING_H diff --git a/header/fsw_processing.h b/header/fsw_processing.h --- a/header/fsw_processing.h +++ b/header/fsw_processing.h @@ -14,34 +14,35 @@ typedef struct ring_node_sm { struct ring_node_sm *previous; + struct ring_node_sm *next; int buffer_address; - struct ring_node_sm *next; unsigned int status; unsigned int coarseTime; unsigned int fineTime; } ring_node_sm; -typedef struct ring_node_bp +typedef struct ring_node_asm { - struct ring_node_bp *previous; - struct ring_node_bp *next; + struct ring_node_asm *previous; + struct ring_node_asm *next; + float asm_burst_sbm_f0[ TIME_OFFSET + TOTAL_SIZE_SM ]; unsigned int status; - unsigned int coarseTime; - unsigned int fineTime; - Header_TM_LFR_SCIENCE_BP_t header; - unsigned char data[ 30 * 22 ]; // MAX size is 22 * 30 TM_LFR_SCIENCE_BURST_BP2_F1 -} ring_node_bp; +} ring_node_asm; -typedef struct ring_node_bp_with_spare +typedef struct bp_packet { - struct ring_node_bp_with_spare *previous; - struct ring_node_bp_with_spare *next; - unsigned int status; - unsigned int coarseTime; - unsigned int fineTime; + Header_TM_LFR_SCIENCE_BP_t header; + unsigned char data[ 30 * 22 ]; // MAX size is 22 * 30 [TM_LFR_SCIENCE_BURST_BP2_F1] +} bp_packet; + +typedef struct bp_packet_with_spare +{ Header_TM_LFR_SCIENCE_BP_with_spare_t header; - unsigned char data[ 9 * 22 ]; -} ring_node_bp_with_spare; + unsigned char data[ 9 * 13 ]; // only for TM_LFR_SCIENCE_NORMAL_BP1_F0 and F1 +} bp_packet_with_spare; + +extern nb_sm_t nb_sm; +extern nb_sm_before_bp_t nb_sm_before_bp; extern volatile int sm_f0[ ]; extern volatile int sm_f1[ ]; @@ -57,23 +58,23 @@ extern spectral_matrix_regs_t *spectral_ extern rtems_name misc_name[5]; extern rtems_id Task_id[20]; /* array of task ids */ -void init_sm_rings( void ); -void reset_current_sm_ring_nodes( void ); -void reset_current_bp_ring_nodes( void ); - // ISR -void reset_nb_sm_f0( void ); +void reset_nb_sm_f0( unsigned char lfrMode ); rtems_isr spectral_matrices_isr( rtems_vector_number vector ); rtems_isr spectral_matrices_isr_simu( rtems_vector_number vector ); // RTEMS TASKS -rtems_task avf0_task(rtems_task_argument argument); -rtems_task smiq_task(rtems_task_argument argument); // added to test the spectral matrix simulator -rtems_task matr_task(rtems_task_argument argument); +rtems_task smiq_task( rtems_task_argument argument ); // added to test the spectral matrix simulator +rtems_task avf0_task( rtems_task_argument lfrRequestedMode ); +rtems_task matr_task( rtems_task_argument lfrRequestedMode ); -//***************************** -// Spectral matrices processing - +//****************** +// Spectral Matrices +void SM_init_rings( void ); +void ASM_init_ring( void ); +void SM_reset_current_ring_nodes( void ); +void ASM_reset_current_ring_node( void ); +void ASM_init_header( Header_TM_LFR_SCIENCE_ASM_t *header); void SM_average(float *averaged_spec_mat_f0, float *averaged_spec_mat_f1, ring_node_sm *ring_node_tab[], unsigned int firstTimeF0, unsigned int firstTimeF1 ); @@ -86,23 +87,23 @@ void ASM_convert(volatile float *input_m void ASM_send(Header_TM_LFR_SCIENCE_ASM_t *header, char *spectral_matrix, unsigned int sid, spw_ioctl_pkt_send *spw_ioctl_send, rtems_id queue_id); +//***************** +// Basic Parameters + +void BP_reset_current_ring_nodes( void ); +void BP_init_header(Header_TM_LFR_SCIENCE_BP_t *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, + unsigned int apid, unsigned char sid, + unsigned int packetLength, unsigned char blkNr ); void BP_send(char *data, rtems_id queue_id , unsigned int nbBytesToSend ); -void init_header_asm( Header_TM_LFR_SCIENCE_ASM_t *header); -void init_bp_ring_sbm1_bp1( void ); -void init_bp_ring_sbm1_bp2( void ); -void init_headers_bp_ring_sbm1_bp1(); -void init_header_bp(Header_TM_LFR_SCIENCE_BP_t *header, - unsigned int apid, unsigned char sid, - unsigned int packetLength , unsigned char blkNr); -void init_header_bp_with_spare(Header_TM_LFR_SCIENCE_BP_with_spare_t *header, - unsigned int apid, unsigned char sid, - unsigned int packetLength, unsigned char blkNr ); - +//****************** +// general functions void reset_spectral_matrix_regs( void ); - -void set_time( unsigned char *time, unsigned int coarseTime, unsigned int fineTime ); +void set_time(unsigned char *time, unsigned char *timeInBuffer ); #endif // FSW_PROCESSING_H_INCLUDED diff --git a/header/tc_handler.h b/header/tc_handler.h --- a/header/tc_handler.h +++ b/header/tc_handler.h @@ -37,7 +37,7 @@ int check_mode_transition( unsigned char int check_transition_date( unsigned int transitionCoarseTime ); int stop_current_mode( void ); int enter_mode( unsigned char mode , unsigned int transitionCoarseTime ); -int restart_science_tasks(); +int restart_science_tasks(unsigned char lfrRequestedMode ); int suspend_science_tasks(); void launch_waveform_picker(unsigned char mode , unsigned int transitionCoarseTime); void launch_spectral_matrix( unsigned char mode ); diff --git a/header/tc_load_dump_parameters.h b/header/tc_load_dump_parameters.h --- a/header/tc_load_dump_parameters.h +++ b/header/tc_load_dump_parameters.h @@ -9,6 +9,9 @@ #include "tm_lfr_tc_exe.h" #include "fsw_misc.h" +extern nb_sm_t nb_sm; +extern nb_sm_before_bp_t nb_sm_before_bp; + int action_load_common_par( ccsdsTelecommandPacket_t *TC ); int action_load_normal_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time); int action_load_burst_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time); @@ -16,6 +19,7 @@ int action_load_sbm1_par(ccsdsTelecomman int action_load_sbm2_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time); int action_dump_par(rtems_id queue_id ); +// NORMAL int set_sy_lfr_n_swf_l(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time); int set_sy_lfr_n_swf_p( ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time ); int set_sy_lfr_n_asm_p( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); @@ -23,6 +27,18 @@ int set_sy_lfr_n_bp_p0( ccsdsTelecommand int set_sy_lfr_n_bp_p1( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); int set_sy_lfr_n_cwf_long_f3(ccsdsTelecommandPacket_t *TC, rtems_id queue_id); +// BURST +int set_sy_lfr_b_bp_p0( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); +int set_sy_lfr_b_bp_p1( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); + +// SBM1 +int set_sy_lfr_s1_bp_p0( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); +int set_sy_lfr_s1_bp_p1( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); + +// SBM2 +int set_sy_lfr_s2_bp_p0( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); +int set_sy_lfr_s2_bp_p1( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); + // TC_LFR_UPDATE_INFO unsigned int check_update_info_hk_lfr_mode( unsigned char mode ); unsigned int check_update_info_hk_tds_mode( unsigned char mode ); diff --git a/src/fsw_globals.c b/src/fsw_globals.c --- a/src/fsw_globals.c +++ b/src/fsw_globals.c @@ -45,11 +45,16 @@ volatile int wf_cont_f3_a [ (NB_SAMPL volatile int wf_cont_f3_b [ (NB_SAMPLES_PER_SNAPSHOT) * NB_WORDS_SWF_BLK + TIME_OFFSET ] __attribute__((aligned(0x100))); char wf_cont_f3_light[ (NB_SAMPLES_PER_SNAPSHOT) * NB_BYTES_CWF3_LIGHT_BLK + TIME_OFFSET_IN_BYTES ] __attribute__((aligned(0x100))); +//*********************************** // SPECTRAL MATRICES GLOBAL VARIABLES + +nb_sm_t nb_sm; +nb_sm_before_bp_t nb_sm_before_bp; + // alignment constraints for the spectral matrices buffers => the first data after the time (8 bytes) shall be aligned on 0x00 -volatile int sm_f0[ NB_RING_NODES_ASM_F0 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); -volatile int sm_f1[ NB_RING_NODES_ASM_F1 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); -volatile int sm_f2[ NB_RING_NODES_ASM_F2 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); +volatile int sm_f0[ NB_RING_NODES_SM_F0 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); +volatile int sm_f1[ NB_RING_NODES_SM_F1 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); +volatile int sm_f2[ NB_RING_NODES_SM_F2 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); // APB CONFIGURATION REGISTERS time_management_regs_t *time_management_regs = (time_management_regs_t*) REGS_ADDR_TIME_MANAGEMENT; diff --git a/src/fsw_init.c b/src/fsw_init.c --- a/src/fsw_init.c +++ b/src/fsw_init.c @@ -97,9 +97,8 @@ rtems_task Init( rtems_task_argument ign init_housekeeping_parameters(); init_waveform_rings(); // initialize the waveform rings - init_sm_rings(); // initialize spectral matrices rings - init_bp_ring_sbm1_bp1(); // initialize basic parameter ring for SBM1 BP1 set - init_bp_ring_sbm1_bp2(); // initialize basic parameter ring for SBM1 BP2 set + SM_init_rings(); // initialize spectral matrices rings + ASM_init_ring(); // initialize the average spectral matrix ring (just for burst, sbm1 and sbm2 asm @ f0 storage) reset_wfp_burst_enable(); reset_wfp_status(); diff --git a/src/fsw_misc.c b/src/fsw_misc.c --- a/src/fsw_misc.c +++ b/src/fsw_misc.c @@ -363,6 +363,19 @@ void getTime( unsigned char *time) time[5] = (unsigned char) (time_management_regs->fine_time); } +unsigned long long int getTimeAsUnsignedLongLongInt( ) +{ + /** This function write the current local time in the time buffer passed in argument. + * + */ + unsigned long long int time; + + time = ( (unsigned long long int) (time_management_regs->coarse_time & 0x7fffffff) << 16 ) + + time_management_regs->fine_time; + + return time; +} + void send_dumb_hk( void ) { Packet_TM_LFR_HK_t dummy_hk_packet; diff --git a/src/fsw_processing.c b/src/fsw_processing.c --- a/src/fsw_processing.c +++ b/src/fsw_processing.c @@ -13,56 +13,426 @@ //************************ // spectral matrices rings -ring_node_sm sm_ring_f0[ NB_RING_NODES_ASM_F0 ]; -ring_node_sm sm_ring_f1[ NB_RING_NODES_ASM_F1 ]; -ring_node_sm sm_ring_f2[ NB_RING_NODES_ASM_F2 ]; +ring_node_sm sm_ring_f0[ NB_RING_NODES_SM_F0 ]; +ring_node_sm sm_ring_f1[ NB_RING_NODES_SM_F1 ]; +ring_node_sm sm_ring_f2[ NB_RING_NODES_SM_F2 ]; ring_node_sm *current_ring_node_sm_f0; ring_node_sm *ring_node_for_averaging_sm_f0; ring_node_sm *current_ring_node_sm_f1; ring_node_sm *current_ring_node_sm_f2; -//********************** -// basic parameter rings -ring_node_bp *current_node_sbm1_bp1_f0; -ring_node_bp *current_node_sbm1_bp2_f0; -ring_node_bp bp_ring_sbm1_bp1[ NB_RING_NODES_SBM1_BP1 ]; -ring_node_bp bp_ring_sbm1_bp2[ NB_RING_NODES_SBM1_BP2 ]; +ring_node_asm asm_ring_burst_sbm_f0[ NB_RING_NODES_ASM_BURST_SBM_F0 ]; +ring_node_asm *current_ring_node_asm_burst_sbm_f0; +ring_node_asm *ring_node_for_processing_asm_burst_sbm_f0; //***** // NORM // F0 float asm_norm_f0 [ TIME_OFFSET + TOTAL_SIZE_SM ]; float asm_f0_reorganized [ TIME_OFFSET + TOTAL_SIZE_SM ]; -char asm_f0_char [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ]; +char asm_f0_char [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ]; float compressed_sm_norm_f0[ TIME_OFFSET + TOTAL_SIZE_COMPRESSED_ASM_F0 ]; //***** // SBM1 -float asm_sbm1_f0 [ TIME_OFFSET + TOTAL_SIZE_SM ]; -float compressed_sm_sbm1[ TIME_OFFSET + TOTAL_SIZE_COMPRESSED_ASM_SBM1 ]; +float asm_sbm_f0 [ TIME_OFFSET + TOTAL_SIZE_SM ]; +float compressed_sm_sbm[ TIME_OFFSET + TOTAL_SIZE_COMPRESSED_ASM_SBM1 ]; unsigned char LFR_BP1_F0[ TIME_OFFSET_IN_BYTES + TOTAL_SIZE_NORM_BP1_F0 * 2 ]; unsigned char LFR_BP1_F1[ TIME_OFFSET_IN_BYTES + TOTAL_SIZE_NORM_BP1_F1 ]; unsigned char LFR_BP1_F2[ TIME_OFFSET_IN_BYTES + TOTAL_SIZE_NORM_BP1_F2 ]; -unsigned int nb_sm_f0; +//*********************************************************** +// Interrupt Service Routine for spectral matrices processing +void reset_nb_sm_f0( unsigned char lfrMode ) +{ + nb_sm.f0 = 0; + nb_sm.norm_bp1_f0 = 0; + nb_sm.norm_bp2_f0 = 0; + nb_sm.norm_asm_f0 = 0; + nb_sm.sbm_bp1_f0 = 0; + nb_sm.sbm_bp2_f0 = 0; + + nb_sm_before_bp.norm_bp1_f0 = parameter_dump_packet.sy_lfr_n_bp_p0 * 96; + nb_sm_before_bp.norm_bp2_f0 = parameter_dump_packet.sy_lfr_n_bp_p1 * 96; + nb_sm_before_bp.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_bp.sbm1_bp1_f0 = parameter_dump_packet.sy_lfr_s1_bp_p0 * 24; + nb_sm_before_bp.sbm1_bp2_f0 = parameter_dump_packet.sy_lfr_s1_bp_p1 * 96; + nb_sm_before_bp.sbm2_bp1_f0 = parameter_dump_packet.sy_lfr_s2_bp_p0 * 96; + nb_sm_before_bp.sbm2_bp2_f0 = parameter_dump_packet.sy_lfr_s2_bp_p1 * 96; + nb_sm_before_bp.burst_bp1_f0 = parameter_dump_packet.sy_lfr_b_bp_p0 * 96; + nb_sm_before_bp.burst_bp2_f0 = parameter_dump_packet.sy_lfr_b_bp_p1 * 96; + + if (lfrMode == LFR_MODE_SBM1) + { + nb_sm_before_bp.burst_sbm_bp1_f0 = nb_sm_before_bp.sbm1_bp1_f0; + nb_sm_before_bp.burst_sbm_bp2_f0 = nb_sm_before_bp.sbm1_bp2_f0; + } + else if (lfrMode == LFR_MODE_SBM2) + { + nb_sm_before_bp.burst_sbm_bp1_f0 = nb_sm_before_bp.sbm2_bp1_f0; + nb_sm_before_bp.burst_sbm_bp2_f0 = nb_sm_before_bp.sbm2_bp2_f0; + } + else if (lfrMode == LFR_MODE_BURST) + { + nb_sm_before_bp.burst_sbm_bp1_f0 = nb_sm_before_bp.burst_bp1_f0; + nb_sm_before_bp.burst_sbm_bp2_f0 = nb_sm_before_bp.burst_bp2_f0; + } + else + { + nb_sm_before_bp.burst_sbm_bp1_f0 = nb_sm_before_bp.burst_bp1_f0; + nb_sm_before_bp.burst_sbm_bp2_f0 = nb_sm_before_bp.burst_bp2_f0; + } +} + +rtems_isr spectral_matrices_isr( rtems_vector_number vector ) +{ +// rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 ); + +// if ( (spectral_matrix_regs->status & 0x1) == 0x01) +// { +// current_ring_node_sm_f0 = current_ring_node_sm_f0->next; +// spectral_matrix_regs->matrixF0_Address0 = current_ring_node_sm_f0->buffer_address; +// spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffffe; // 1110 +// nb_sm_f0 = nb_sm_f0 + 1; +// } +// else if ( (spectral_matrix_regs->status & 0x2) == 0x02) +// { +// current_ring_node_sm_f0 = current_ring_node_sm_f0->next; +// spectral_matrix_regs->matrixFO_Address1 = current_ring_node_sm_f0->buffer_address; +// spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffffd; // 1101 +// nb_sm_f0 = nb_sm_f0 + 1; +// } + +// if ( (spectral_matrix_regs->status & 0x30) != 0x00) +// { +// rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 ); +// spectral_matrix_regs->status = spectral_matrix_regs->status & 0xffffffcf; // 1100 1111 +// } + +// spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffff3; // 0011 + +// if (nb_sm_f0 == (NB_SM_BEFORE_AVF0-1) ) +// { +// ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0; +// if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) +// { +// rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 ); +// } +// nb_sm_f0 = 0; +// } +// else +// { +// nb_sm.nb_sm_f0 = nb_sm.nb_sm_f0 + 1; +// } +} + +rtems_isr spectral_matrices_isr_simu( rtems_vector_number vector ) +{ + if (nb_sm.f0 == (NB_SM_BEFORE_AVF0-1) ) + { + ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0; + if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) + { + rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 ); + } + nb_sm.f0 = 0; + } + else + { + nb_sm.f0 = nb_sm.f0 + 1; + } +} + +//************ +// RTEMS TASKS + +rtems_task smiq_task( rtems_task_argument argument ) // process the Spectral Matrices IRQ +{ + rtems_event_set event_out; + + BOOT_PRINTF("in SMIQ *** \n") + + while(1){ + rtems_event_receive(RTEMS_EVENT_0, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT0 + } +} + +rtems_task avf0_task( rtems_task_argument lfrRequestedMode ) +{ + int i; + + rtems_event_set event_out; + rtems_event_set event_for_matr; + rtems_status_code status; + ring_node_sm *ring_node_tab[8]; + unsigned long long int localTime; + + reset_nb_sm_f0( lfrRequestedMode ); // reset the sm counters that drive the BP and ASM computations / transmissions + + BOOT_PRINTF1("in AVFO *** lfrRequestedMode = %d\n", lfrRequestedMode) + + while(1){ + rtems_event_receive(RTEMS_EVENT_0, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT0 + ring_node_tab[NB_SM_BEFORE_AVF0-1] = ring_node_for_averaging_sm_f0; + 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; + } + + localTime = getTimeAsUnsignedLongLongInt( ); + + // compute the average and store it in the averaged_sm_f1 buffer + SM_average( asm_norm_f0, current_ring_node_asm_burst_sbm_f0->asm_burst_sbm_f0, + ring_node_tab, + nb_sm.norm_bp1_f0, nb_sm.sbm_bp1_f0 ); + + localTime = getTimeAsUnsignedLongLongInt( ) - localTime; + + // update nb_average + nb_sm.norm_bp1_f0 = nb_sm.norm_bp1_f0 + NB_SM_BEFORE_AVF0; + nb_sm.norm_bp2_f0 = nb_sm.norm_bp2_f0 + NB_SM_BEFORE_AVF0; + nb_sm.norm_asm_f0 = nb_sm.norm_asm_f0 + NB_SM_BEFORE_AVF0; + nb_sm.sbm_bp1_f0 = nb_sm.sbm_bp1_f0 + NB_SM_BEFORE_AVF0; + nb_sm.sbm_bp2_f0 = nb_sm.sbm_bp2_f0 + NB_SM_BEFORE_AVF0; + + //*********************************************************** + // build a composite event that will be sent to the MATR task + event_for_matr = 0x00; + + if (nb_sm.sbm_bp1_f0 == nb_sm_before_bp.burst_sbm_bp1_f0) + { + nb_sm.sbm_bp1_f0 = 0; + // the ring node is ready for BP calculations + ring_node_for_processing_asm_burst_sbm_f0 = current_ring_node_asm_burst_sbm_f0; + // set another ring for the ASM storage + current_ring_node_asm_burst_sbm_f0 = current_ring_node_asm_burst_sbm_f0->next; + if ( (lfrCurrentMode == LFR_MODE_BURST) + || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) ) + { + event_for_matr = event_for_matr | RTEMS_EVENT_BURST_SBM_BP1_F0; + } + } + + if (nb_sm.sbm_bp2_f0 == nb_sm_before_bp.burst_sbm_bp2_f0) + { + nb_sm.sbm_bp2_f0 = 0; + if ( (lfrCurrentMode == LFR_MODE_BURST) + || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) ) + { + event_for_matr = event_for_matr | RTEMS_EVENT_BURST_SBM_BP2_F0; + } + } -void init_sm_rings( void ) + if (nb_sm.norm_bp1_f0 == nb_sm_before_bp.norm_bp1_f0) + { + nb_sm.norm_bp1_f0 = 0; + if (lfrCurrentMode == LFR_MODE_NORMAL) + { + event_for_matr = event_for_matr | RTEMS_EVENT_NORM_BP1_F0; + } + } + + if (nb_sm.norm_bp2_f0 == nb_sm_before_bp.norm_bp2_f0) + { + nb_sm.norm_bp2_f0 = 0; + if ( (lfrCurrentMode == LFR_MODE_NORMAL) + || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) ) + { + event_for_matr = event_for_matr | RTEMS_EVENT_NORM_BP2_F0; + } + } + + if (nb_sm.norm_asm_f0 == nb_sm_before_bp.norm_asm_f0) + { + nb_sm.norm_asm_f0 = 0; + if ( (lfrCurrentMode == LFR_MODE_NORMAL) + || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) ) + { +// PRINTF1("%lld\n", localTime) + event_for_matr = event_for_matr | RTEMS_EVENT_NORM_ASM_F0; + } + } + + //********************************* + // send the composite event to MATR + status = rtems_event_send( Task_id[TASKID_MATR], event_for_matr ); + if (status != RTEMS_SUCCESSFUL) { + printf("in AVF0 *** Error sending RTEMS_EVENT_0, code %d\n", status); + } + } +} + +rtems_task matr_task( rtems_task_argument lfrRequestedMode ) +{ + spw_ioctl_pkt_send spw_ioctl_send_ASM; + rtems_event_set event_out; + rtems_status_code status; + rtems_id queue_id; + Header_TM_LFR_SCIENCE_ASM_t headerASM; + bp_packet_with_spare current_node_norm_bp1_f0; + bp_packet current_node_norm_bp2_f0; + bp_packet current_node_sbm_bp1_f0; + bp_packet current_node_sbm_bp2_f0; + unsigned long long int localTime; + + ASM_init_header( &headerASM ); + + //************* + // NORM headers + BP_init_header_with_spare( ¤t_node_norm_bp1_f0.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( ¤t_node_norm_bp2_f0.header, + APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP2_F0, + PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0, NB_BINS_COMPRESSED_SM_F0); + + //**************************** + // BURST SBM1 and SBM2 headers + if ( (lfrRequestedMode == LFR_MODE_BURST) + || (lfrRequestedMode == LFR_MODE_NORMAL) || (lfrRequestedMode == LFR_MODE_STANDBY) ) + { + BP_init_header( ¤t_node_sbm_bp1_f0.header, + 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( ¤t_node_sbm_bp2_f0.header, + 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( ¤t_node_sbm_bp1_f0.header, + 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( ¤t_node_sbm_bp2_f0.header, + 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( ¤t_node_sbm_bp1_f0.header, + 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( ¤t_node_sbm_bp2_f0.header, + APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP2_F0, + PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0); + } + else + { + PRINTF1("ERR *** in MATR *** unexpected lfrRequestedMode passed as argument = %d\n", (unsigned int) lfrRequestedMode) + } + + status = get_message_queue_id_send( &queue_id ); + if (status != RTEMS_SUCCESSFUL) + { + PRINTF1("in MATR *** ERR get_message_queue_id_send %d\n", status) + } + + BOOT_PRINTF1("in MATR *** lfrRequestedMode = %d\n", lfrRequestedMode) + + while(1){ + rtems_event_receive( RTEMS_EVENT_NORM_BP1_F0 | RTEMS_EVENT_NORM_BP2_F0 | RTEMS_EVENT_NORM_ASM_F0 + | RTEMS_EVENT_BURST_SBM_BP1_F0 | RTEMS_EVENT_BURST_SBM_BP2_F0, + RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out); + localTime = getTimeAsUnsignedLongLongInt( ); + //**************** + //**************** + // BURST SBM1 SBM2 + //**************** + //**************** + if ( event_out & RTEMS_EVENT_BURST_SBM_BP1_F0 ) + { + // 1) compress the matrix for Basic Parameters calculation + ASM_compress_reorganize_and_divide( current_ring_node_asm_burst_sbm_f0->asm_burst_sbm_f0, compressed_sm_sbm, + nb_sm_before_bp.burst_sbm_bp1_f0, + NB_BINS_COMPRESSED_SM_SBM_F0, NB_BINS_TO_AVERAGE_ASM_SBM_F0, + ASM_F0_INDICE_START); + // 2) compute the BP1 set + + // 3) send the BP1 set + set_time( current_node_sbm_bp1_f0.header.time, (unsigned char *) &compressed_sm_sbm ); + set_time( current_node_sbm_bp1_f0.header.acquisitionTime, (unsigned char *) &compressed_sm_sbm ); + BP_send( (char *) ¤t_node_sbm_bp1_f0.header, queue_id, + PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0 + PACKET_LENGTH_DELTA); + // 4) compute the BP2 set if needed + if ( event_out & RTEMS_EVENT_BURST_SBM_BP2_F0 ) + { + // 1) compute the BP2 set + + // 2) send the BP2 set + set_time( current_node_sbm_bp2_f0.header.time, (unsigned char *) &compressed_sm_sbm ); + set_time( current_node_sbm_bp2_f0.header.acquisitionTime, (unsigned char *) &compressed_sm_sbm ); + BP_send( (char *) ¤t_node_sbm_bp2_f0.header, queue_id, + PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0 + PACKET_LENGTH_DELTA); + } + } + + //***** + //***** + // NORM + //***** + //***** + if (event_out & RTEMS_EVENT_NORM_BP1_F0) + { + // 1) compress the matrix for Basic Parameters calculation + ASM_compress_reorganize_and_divide( asm_norm_f0, compressed_sm_norm_f0, + nb_sm_before_bp.norm_bp1_f0, + 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( current_node_norm_bp1_f0.header.time, (unsigned char *) &compressed_sm_norm_f0 ); + set_time( current_node_norm_bp1_f0.header.acquisitionTime, (unsigned char *) &compressed_sm_norm_f0 ); + BP_send( (char *) ¤t_node_norm_bp1_f0.header, queue_id, + PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0 + PACKET_LENGTH_DELTA); + if (event_out & RTEMS_EVENT_NORM_BP2_F0) + { + // 1) compute the BP2 set + + // 2) send the BP2 set + set_time( current_node_norm_bp2_f0.header.time, (unsigned char *) &compressed_sm_norm_f0 ); + set_time( current_node_norm_bp2_f0.header.acquisitionTime, (unsigned char *) &compressed_sm_norm_f0 ); + BP_send( (char *) ¤t_node_norm_bp2_f0.header, queue_id, + PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0 + PACKET_LENGTH_DELTA); + } + } + + if (event_out & RTEMS_EVENT_NORM_ASM_F0) + { + // 1) reorganize the ASM and divide + ASM_reorganize_and_divide( asm_norm_f0, asm_f0_reorganized, NB_SM_BEFORE_NORM_BP1_F0 ); + // 2) convert the float array in a char array + ASM_convert( asm_f0_reorganized, asm_f0_char); + // 3) send the spectral matrix packets + ASM_send( &headerASM, asm_f0_char, SID_NORM_ASM_F0, &spw_ioctl_send_ASM, queue_id); +// localTime = getTimeAsUnsignedLongLongInt( ) - localTime; +// PRINTF1("in MATR *** %lld\n", localTime) + } + + } +} + +//****************** +// Spectral Matrices + +void SM_init_rings( void ) { unsigned char i; // F0 RING sm_ring_f0[0].next = (ring_node_sm*) &sm_ring_f0[1]; - sm_ring_f0[0].previous = (ring_node_sm*) &sm_ring_f0[NB_RING_NODES_ASM_F0-1]; + sm_ring_f0[0].previous = (ring_node_sm*) &sm_ring_f0[NB_RING_NODES_SM_F0-1]; sm_ring_f0[0].buffer_address = (int) &sm_f0[ 0 ]; - sm_ring_f0[NB_RING_NODES_ASM_F0-1].next = (ring_node_sm*) &sm_ring_f0[0]; - sm_ring_f0[NB_RING_NODES_ASM_F0-1].previous = (ring_node_sm*) &sm_ring_f0[NB_RING_NODES_ASM_F0-2]; - sm_ring_f0[NB_RING_NODES_ASM_F0-1].buffer_address = - (int) &sm_f0[ (NB_RING_NODES_ASM_F0-1) * TOTAL_SIZE_SM ]; + sm_ring_f0[NB_RING_NODES_SM_F0-1].next = (ring_node_sm*) &sm_ring_f0[0]; + sm_ring_f0[NB_RING_NODES_SM_F0-1].previous = (ring_node_sm*) &sm_ring_f0[NB_RING_NODES_SM_F0-2]; + sm_ring_f0[NB_RING_NODES_SM_F0-1].buffer_address = + (int) &sm_f0[ (NB_RING_NODES_SM_F0-1) * TOTAL_SIZE_SM ]; - for(i=1; imatrixF0_Address0 @%x\n", spectral_matrix_regs->matrixF0_Address0) } -void reset_current_sm_ring_nodes( void ) +void ASM_init_ring( void ) +{ + unsigned char i; + + asm_ring_burst_sbm_f0[0].next = (ring_node_asm*) &asm_ring_burst_sbm_f0[1]; + asm_ring_burst_sbm_f0[0].previous = (ring_node_asm*) &asm_ring_burst_sbm_f0[NB_RING_NODES_ASM_BURST_SBM_F0-1]; + + asm_ring_burst_sbm_f0[NB_RING_NODES_ASM_BURST_SBM_F0-1].next + = (ring_node_asm*) &asm_ring_burst_sbm_f0[0]; + asm_ring_burst_sbm_f0[NB_RING_NODES_ASM_BURST_SBM_F0-1].previous + = (ring_node_asm*) &asm_ring_burst_sbm_f0[NB_RING_NODES_ASM_BURST_SBM_F0-2]; + + for(i=1; istatus & 0x1) == 0x01) - { - current_ring_node_sm_f0 = current_ring_node_sm_f0->next; - spectral_matrix_regs->matrixF0_Address0 = current_ring_node_sm_f0->buffer_address; - spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffffe; // 1110 - nb_sm_f0 = nb_sm_f0 + 1; - } - else if ( (spectral_matrix_regs->status & 0x2) == 0x02) - { - current_ring_node_sm_f0 = current_ring_node_sm_f0->next; - spectral_matrix_regs->matrixFO_Address1 = current_ring_node_sm_f0->buffer_address; - spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffffd; // 1101 - nb_sm_f0 = nb_sm_f0 + 1; - } - - if ( (spectral_matrix_regs->status & 0x30) != 0x00) - { - rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 ); - spectral_matrix_regs->status = spectral_matrix_regs->status & 0xffffffcf; // 1100 1111 - } - - spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffff3; // 0011 - - if (nb_sm_f0 == (NB_SM_BEFORE_AVF0-1) ) - { - ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0; - if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) - { - rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 ); - } - nb_sm_f0 = 0; - } - else - { - nb_sm_f0 = nb_sm_f0 + 1; - } -} - -rtems_isr spectral_matrices_isr_simu( rtems_vector_number vector ) -{ - if (nb_sm_f0 == (NB_SM_BEFORE_AVF0-1) ) - { - ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0; - if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) - { - rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 ); - } - nb_sm_f0 = 0; - } - else - { - nb_sm_f0 = nb_sm_f0 + 1; - } -} - -//************ -// RTEMS TASKS - -rtems_task smiq_task(rtems_task_argument argument) // process the Spectral Matrices IRQ -{ - rtems_event_set event_out; - - BOOT_PRINTF("in SMIQ *** \n") - - while(1){ - rtems_event_receive(RTEMS_EVENT_0, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT0 - } + current_ring_node_asm_burst_sbm_f0 = asm_ring_burst_sbm_f0; + ring_node_for_processing_asm_burst_sbm_f0 = asm_ring_burst_sbm_f0; } -rtems_task avf0_task(rtems_task_argument argument) -{ - int i; - static unsigned int nb_sm_norm_bp1_f0; - static unsigned int nb_sm_norm_bp2_f0; - static unsigned int nb_sm_norm_asm_f0; - static unsigned int nb_sm_sbm1_bp1_f0; - static unsigned int nb_sm_sbm1_bp2_f0; - rtems_event_set event_out; - rtems_event_set event_for_matr; - rtems_status_code status; - ring_node_sm *ring_node_tab[8]; - - nb_sm_norm_bp1_f0 = 0; - nb_sm_norm_bp2_f0 = 0; - nb_sm_norm_asm_f0 = 0; - nb_sm_sbm1_bp1_f0 = 0; - nb_sm_sbm1_bp2_f0 = 0; - - BOOT_PRINTF("in AVFO *** \n") - - while(1){ - rtems_event_receive(RTEMS_EVENT_0, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT0 - ring_node_tab[NB_SM_BEFORE_AVF0-1] = ring_node_for_averaging_sm_f0; - 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; - } - - // copy time information in the asm_f0 buffer - asm_norm_f0[0] = ring_node_tab[7]->coarseTime; - asm_norm_f0[1] = ring_node_tab[7]->fineTime; - asm_sbm1_f0[0] = ring_node_tab[7]->coarseTime; - asm_sbm1_f0[1] = ring_node_tab[7]->fineTime; - - // compute the average and store it in the averaged_sm_f1 buffer - SM_average( asm_norm_f0, asm_sbm1_f0, - ring_node_tab, - nb_sm_norm_bp1_f0, nb_sm_sbm1_bp1_f0 ); - - // update nb_average - nb_sm_norm_bp1_f0 = nb_sm_norm_bp1_f0 + NB_SM_BEFORE_AVF0; - nb_sm_norm_bp2_f0 = nb_sm_norm_bp2_f0 + NB_SM_BEFORE_AVF0; - nb_sm_norm_asm_f0 = nb_sm_norm_asm_f0 + NB_SM_BEFORE_AVF0; - nb_sm_sbm1_bp1_f0 = nb_sm_sbm1_bp1_f0 + NB_SM_BEFORE_AVF0; - nb_sm_sbm1_bp2_f0 = nb_sm_sbm1_bp2_f0 + NB_SM_BEFORE_AVF0; - - //*********************************************************** - // build a composite event that will be sent to the MATR task - event_for_matr = 0x00; - - if (nb_sm_sbm1_bp1_f0 == NB_SM_BEFORE_SBM1_BP1_F0) - { - nb_sm_sbm1_bp1_f0 = 0; - if (lfrCurrentMode == LFR_MODE_SBM1) - { - event_for_matr = event_for_matr | RTEMS_EVENT_SBM1_BP1_F0; - } - } - - if (nb_sm_sbm1_bp2_f0 == NB_SM_BEFORE_SBM1_BP2_F0) - { - nb_sm_sbm1_bp2_f0 = 0; - if (lfrCurrentMode == LFR_MODE_SBM1) - { - event_for_matr = event_for_matr | RTEMS_EVENT_SBM1_BP2_F0; - } - } - - if (nb_sm_norm_bp1_f0 == NB_SM_BEFORE_NORM_BP1_F0) { - nb_sm_norm_bp1_f0 = 0; - if (lfrCurrentMode == LFR_MODE_NORMAL) - { - event_for_matr = event_for_matr | RTEMS_EVENT_NORM_BP1_F0; - } - } - - if (nb_sm_norm_bp2_f0 == NB_SM_BEFORE_NORM_BP2_F0) { - nb_sm_norm_bp2_f0 = 0; - if (lfrCurrentMode == LFR_MODE_NORMAL) - { - event_for_matr = event_for_matr | RTEMS_EVENT_NORM_BP2_F0; - } - } - - if (nb_sm_norm_asm_f0 == NB_SM_BEFORE_NORM_ASM_F0) { - nb_sm_norm_asm_f0 = 0; - if (lfrCurrentMode == LFR_MODE_NORMAL) - { - event_for_matr = event_for_matr | RTEMS_EVENT_NORM_ASM_F0; - } - } - - //********************************* - // send the composite event to MATR - status = rtems_event_send( Task_id[TASKID_MATR], event_for_matr ); - if (status != RTEMS_SUCCESSFUL) { - printf("in AVF0 *** Error sending RTEMS_EVENT_0, code %d\n", status); - } - } -} - -rtems_task matr_task(rtems_task_argument argument) +void ASM_init_header( Header_TM_LFR_SCIENCE_ASM_t *header) { - spw_ioctl_pkt_send spw_ioctl_send_ASM; - rtems_event_set event_out; - rtems_status_code status; - rtems_id queue_id; - Header_TM_LFR_SCIENCE_ASM_t headerASM; - ring_node_bp_with_spare current_node_norm_bp1_f0; - ring_node_bp current_node_norm_bp2_f0; - - init_header_asm( &headerASM ); - init_header_bp_with_spare( ¤t_node_norm_bp1_f0.header, - APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP1_F0, - PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0, NB_BINS_COMPRESSED_SM_F0 ); - init_header_bp( ¤t_node_norm_bp2_f0.header, - APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP2_F0, - PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0, NB_BINS_COMPRESSED_SM_F0); - - status = get_message_queue_id_send( &queue_id ); - if (status != RTEMS_SUCCESSFUL) - { - PRINTF1("in MATR *** ERR get_message_queue_id_send %d\n", status) - } - - BOOT_PRINTF("in MATR *** \n") - - while(1){ - rtems_event_receive( RTEMS_EVENT_NORM_BP1_F0 | RTEMS_EVENT_NORM_BP2_F0 | RTEMS_EVENT_NORM_ASM_F0 - | RTEMS_EVENT_SBM1_BP1_F0 | RTEMS_EVENT_SBM1_BP2_F0, - RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out); - //***** - //***** - // SBM1 - //***** - //***** - if (event_out & RTEMS_EVENT_SBM1_BP1_F0) - { - // 1) compress the matrix for Basic Parameters calculation - ASM_compress_reorganize_and_divide( asm_sbm1_f0, compressed_sm_sbm1, - NB_SM_BEFORE_SBM1_BP1_F0, - NB_BINS_COMPRESSED_SM_SBM1_F0, NB_BINS_TO_AVERAGE_ASM_SBM1_F0, - ASM_F0_INDICE_START); - // 2) compute the BP1 set - - // 3) send the BP1 set - set_time( current_node_sbm1_bp1_f0->header.time, - current_node_sbm1_bp1_f0->coarseTime, current_node_sbm1_bp1_f0->fineTime); - set_time( current_node_sbm1_bp1_f0->header.acquisitionTime, - current_node_sbm1_bp1_f0->coarseTime, current_node_sbm1_bp1_f0->fineTime); - BP_send( (char *) ¤t_node_sbm1_bp1_f0->header, queue_id, - PACKET_LENGTH_TM_LFR_SCIENCE_SBM1_BP1_F0 + PACKET_LENGTH_DELTA); - // 4) update current_node_sbm1_bp1_f0 - current_node_sbm1_bp1_f0 = current_node_sbm1_bp1_f0->next; - if (event_out & RTEMS_EVENT_SBM1_BP2_F0) - { - // 1) compute the BP2 set - - // 2) send the BP2 set - set_time( current_node_sbm1_bp2_f0->header.time, - current_node_sbm1_bp2_f0->coarseTime, current_node_sbm1_bp2_f0->fineTime); - set_time( current_node_sbm1_bp2_f0->header.acquisitionTime, - current_node_sbm1_bp2_f0->coarseTime, current_node_sbm1_bp2_f0->fineTime); - BP_send( (char *) ¤t_node_sbm1_bp2_f0->header, queue_id, - PACKET_LENGTH_TM_LFR_SCIENCE_SBM1_BP1_F0 + PACKET_LENGTH_DELTA); - } - } - - //***** - //***** - // NORM - //***** - //***** - if (event_out & RTEMS_EVENT_NORM_BP1_F0) - { - // 1) compress the matrix for Basic Parameters calculation - ASM_compress_reorganize_and_divide( asm_norm_f0, compressed_sm_norm_f0, - NB_SM_BEFORE_NORM_BP1_F0, - 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( current_node_norm_bp1_f0.header.time, - current_node_norm_bp1_f0.coarseTime, current_node_norm_bp1_f0.fineTime); - set_time( current_node_norm_bp1_f0.header.acquisitionTime, - current_node_norm_bp1_f0.coarseTime, current_node_norm_bp1_f0.fineTime); - BP_send( (char *) ¤t_node_norm_bp1_f0.header, queue_id, - PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0 + PACKET_LENGTH_DELTA); - if (event_out & RTEMS_EVENT_NORM_BP2_F0) - { - // 1) compute the BP2 set - - // 2) send the BP2 set - set_time( current_node_norm_bp2_f0.header.time, - current_node_norm_bp2_f0.coarseTime, current_node_norm_bp2_f0.fineTime); - set_time( current_node_norm_bp2_f0.header.acquisitionTime, - current_node_norm_bp2_f0.coarseTime, current_node_norm_bp2_f0.fineTime); - BP_send( (char *) ¤t_node_norm_bp2_f0.header, queue_id, - PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0 + PACKET_LENGTH_DELTA); - } - } - - if (event_out & RTEMS_EVENT_NORM_ASM_F0) - { - // 1) reorganize the ASM and divide - ASM_reorganize_and_divide( asm_norm_f0, asm_f0_reorganized, NB_SM_BEFORE_NORM_BP1_F0 ); - // 2) convert the float array in a char array - ASM_convert( asm_f0_reorganized, asm_f0_char); - // 3) send the spectral matrix packets - ASM_send( &headerASM, asm_f0_char, SID_NORM_ASM_F0, &spw_ioctl_send_ASM, queue_id); - } - - } + header->targetLogicalAddress = CCSDS_DESTINATION_ID; + header->protocolIdentifier = CCSDS_PROTOCOLE_ID; + header->reserved = 0x00; + header->userApplication = CCSDS_USER_APP; + header->packetID[0] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST >> 8); + header->packetID[1] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST); + header->packetSequenceControl[0] = 0xc0; + header->packetSequenceControl[1] = 0x00; + header->packetLength[0] = 0x00; + header->packetLength[1] = 0x00; + // DATA FIELD HEADER + header->spare1_pusVersion_spare2 = 0x10; + header->serviceType = TM_TYPE_LFR_SCIENCE; // service type + header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype + header->destinationID = TM_DESTINATION_ID_GROUND; + // AUXILIARY DATA HEADER + header->sid = 0x00; + header->biaStatusInfo = 0x00; + header->pa_lfr_pkt_cnt_asm = 0x00; + header->pa_lfr_pkt_nr_asm = 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->pa_lfr_asm_blk_nr[0] = 0x00; // BLK_NR MSB + header->pa_lfr_asm_blk_nr[1] = 0x00; // BLK_NR LSB } -//***************************** -// Spectral matrices processing - void SM_average( float *averaged_spec_mat_f0, float *averaged_spec_mat_f1, ring_node_sm *ring_node_tab[], unsigned int nbAverageNormF0, unsigned int nbAverageSBM1F0 ) { float sum; unsigned int i; + unsigned char *ptr; for(i=0; icoarse_time >> 24); + ptr[1] = (unsigned char) (time_management_regs->coarse_time >> 16); + ptr[2] = (unsigned char) (time_management_regs->coarse_time >> 8 ); + ptr[3] = (unsigned char) (time_management_regs->coarse_time ); + ptr[4] = (unsigned char) (time_management_regs->fine_time >> 24); + ptr[5] = (unsigned char) (time_management_regs->fine_time >> 16); + ptr[6] = (unsigned char) (time_management_regs->fine_time >> 8 ); + ptr[7] = (unsigned char) (time_management_regs->fine_time ); + ptr = (unsigned char *) averaged_spec_mat_f1; + ptr[0] = (unsigned char) (time_management_regs->coarse_time >> 24); + ptr[1] = (unsigned char) (time_management_regs->coarse_time >> 16); + ptr[2] = (unsigned char) (time_management_regs->coarse_time >> 8 ); + ptr[3] = (unsigned char) (time_management_regs->coarse_time ); + ptr[4] = (unsigned char) (time_management_regs->fine_time >> 24); + ptr[5] = (unsigned char) (time_management_regs->fine_time >> 16); + ptr[6] = (unsigned char) (time_management_regs->fine_time >> 8 ); + ptr[7] = (unsigned char) (time_management_regs->fine_time ); + } } void ASM_reorganize_and_divide( float *averaged_spec_mat, float *averaged_spec_mat_reorganized, float divider ) @@ -500,6 +642,11 @@ void ASM_compress_reorganize_and_divide( int offsetCompressed; int k; + // copy the time information + compressed_spec_mat[ 0 ] = averaged_spec_mat[ 0 ]; + compressed_spec_mat[ 1 ] = averaged_spec_mat[ 1 ]; + + // build data for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++) { for( frequencyBin = 0; frequencyBin < nbBinsCompressedMatrix; frequencyBin++ ) @@ -616,111 +763,10 @@ void ASM_send(Header_TM_LFR_SCIENCE_ASM_ } } -void BP_send(char *data, rtems_id queue_id, unsigned int nbBytesToSend ) -{ - rtems_status_code status; - - // SEND PACKET - status = rtems_message_queue_send( queue_id, data, nbBytesToSend); - if (status != RTEMS_SUCCESSFUL) - { - printf("ERR *** in BP_send *** ERR %d\n", (int) status); - } -} - -void init_header_asm( Header_TM_LFR_SCIENCE_ASM_t *header) -{ - header->targetLogicalAddress = CCSDS_DESTINATION_ID; - header->protocolIdentifier = CCSDS_PROTOCOLE_ID; - header->reserved = 0x00; - header->userApplication = CCSDS_USER_APP; - header->packetID[0] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST >> 8); - header->packetID[1] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST); - header->packetSequenceControl[0] = 0xc0; - header->packetSequenceControl[1] = 0x00; - header->packetLength[0] = 0x00; - header->packetLength[1] = 0x00; - // DATA FIELD HEADER - header->spare1_pusVersion_spare2 = 0x10; - header->serviceType = TM_TYPE_LFR_SCIENCE; // service type - header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype - header->destinationID = TM_DESTINATION_ID_GROUND; - // AUXILIARY DATA HEADER - header->sid = 0x00; - header->biaStatusInfo = 0x00; - header->pa_lfr_pkt_cnt_asm = 0x00; - header->pa_lfr_pkt_nr_asm = 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->pa_lfr_asm_blk_nr[0] = 0x00; // BLK_NR MSB - header->pa_lfr_asm_blk_nr[1] = 0x00; // BLK_NR LSB -} - -void init_bp_ring_sbm1_bp1( void ) -{ - unsigned int i; - - //******** - // F0 RING - bp_ring_sbm1_bp1[0].next = (ring_node_bp*) &bp_ring_sbm1_bp1[1]; - bp_ring_sbm1_bp1[0].previous = (ring_node_bp*) &bp_ring_sbm1_bp1[NB_RING_NODES_SBM1_BP1-1]; +//***************** +// Basic Parameters - bp_ring_sbm1_bp1[NB_RING_NODES_SBM1_BP1-1].next = (ring_node_bp*) &bp_ring_sbm1_bp1[0]; - bp_ring_sbm1_bp1[NB_RING_NODES_SBM1_BP1-1].previous = (ring_node_bp*) &bp_ring_sbm1_bp1[NB_RING_NODES_SBM1_BP1-2]; - - for(i=1; ipa_lfr_bp_blk_nr[1] = blkNr; // BLK_NR LSB } -void init_header_bp_with_spare(Header_TM_LFR_SCIENCE_BP_with_spare_t *header, +void BP_init_header_with_spare(Header_TM_LFR_SCIENCE_BP_with_spare_t *header, unsigned int apid, unsigned char sid, unsigned int packetLength , unsigned char blkNr) { @@ -784,6 +830,21 @@ void init_header_bp_with_spare(Header_TM header->pa_lfr_bp_blk_nr[1] = blkNr; // BLK_NR LSB } +void BP_send(char *data, rtems_id queue_id, unsigned int nbBytesToSend ) +{ + rtems_status_code status; + + // SEND PACKET + status = rtems_message_queue_send( queue_id, data, nbBytesToSend); + if (status != RTEMS_SUCCESSFUL) + { + printf("ERR *** in BP_send *** ERR %d\n", (int) status); + } +} + +//****************** +// general functions + void reset_spectral_matrix_regs( void ) { /** This function resets the spectral matrices module registers. @@ -808,17 +869,21 @@ void reset_spectral_matrix_regs( void ) spectral_matrix_regs->matrixF2_Address = current_ring_node_sm_f2->buffer_address; } -//****************** -// general functions - -void set_time( unsigned char *time, unsigned int coarseTime, unsigned int fineTime ) +void set_time( unsigned char *time, unsigned char * timeInBuffer ) { - time[0] = (unsigned char) (coarseTime>>24); - time[1] = (unsigned char) (coarseTime>>16); - time[2] = (unsigned char) (coarseTime>>8); - time[3] = (unsigned char) (coarseTime); - time[4] = (unsigned char) (fineTime>>8); - time[5] = (unsigned char) (fineTime); +// time[0] = timeInBuffer[2]; +// time[1] = timeInBuffer[3]; +// time[2] = timeInBuffer[0]; +// time[3] = timeInBuffer[1]; +// time[4] = timeInBuffer[6]; +// time[5] = timeInBuffer[7]; + + time[0] = timeInBuffer[0]; + time[1] = timeInBuffer[1]; + time[2] = timeInBuffer[2]; + time[3] = timeInBuffer[3]; + time[4] = timeInBuffer[6]; + time[5] = timeInBuffer[7]; } diff --git a/src/tc_handler.c b/src/tc_handler.c --- a/src/tc_handler.c +++ b/src/tc_handler.c @@ -530,7 +530,7 @@ int enter_mode( unsigned char mode, unsi rtems_cpu_usage_reset(); maxCount = 0; #endif - status = restart_science_tasks(); + status = restart_science_tasks( mode ); launch_waveform_picker( mode, transitionCoarseTime ); launch_spectral_matrix_simu( mode ); } @@ -559,7 +559,7 @@ int enter_mode( unsigned char mode, unsi return status; } -int restart_science_tasks() +int restart_science_tasks(unsigned char lfrRequestedMode ) { /** This function is used to restart all science tasks. * @@ -573,12 +573,12 @@ int restart_science_tasks() * */ - rtems_status_code status[6]; + rtems_status_code status[7]; rtems_status_code ret; ret = RTEMS_SUCCESSFUL; - status[0] = rtems_task_restart( Task_id[TASKID_AVF0], 1 ); + status[0] = rtems_task_restart( Task_id[TASKID_AVF0], lfrRequestedMode ); if (status[0] != RTEMS_SUCCESSFUL) { PRINTF1("in restart_science_task *** 0 ERR %d\n", status[0]) @@ -608,8 +608,15 @@ int restart_science_tasks() PRINTF1("in restart_science_task *** 5 ERR %d\n", status[5]) } + status[6] = rtems_task_restart( Task_id[TASKID_MATR], lfrRequestedMode ); + if (status[6] != RTEMS_SUCCESSFUL) + { + PRINTF1("in restart_science_task *** 6 ERR %d\n", status[6]) + } + if ( (status[0] != RTEMS_SUCCESSFUL) || (status[2] != RTEMS_SUCCESSFUL) || - (status[3] != RTEMS_SUCCESSFUL) || (status[4] != RTEMS_SUCCESSFUL) || (status[5] != RTEMS_SUCCESSFUL) ) + (status[3] != RTEMS_SUCCESSFUL) || (status[4] != RTEMS_SUCCESSFUL) || + (status[5] != RTEMS_SUCCESSFUL) || (status[6] != RTEMS_SUCCESSFUL) ) { ret = RTEMS_UNSATISFIED; } @@ -697,9 +704,8 @@ void launch_waveform_picker( unsigned ch void launch_spectral_matrix( unsigned char mode ) { - reset_nb_sm_f0(); - reset_current_sm_ring_nodes(); - reset_current_bp_ring_nodes(); + SM_reset_current_ring_nodes(); + ASM_reset_current_ring_node(); reset_spectral_matrix_regs(); struct grgpio_regs_str *grgpio_regs = (struct grgpio_regs_str *) REGS_ADDR_GRGPIO; @@ -739,9 +745,8 @@ void set_run_matrix_spectral( unsigned c void launch_spectral_matrix_simu( unsigned char mode ) { - reset_nb_sm_f0(); - reset_current_sm_ring_nodes(); - reset_current_bp_ring_nodes(); + SM_reset_current_ring_nodes(); + ASM_reset_current_ring_node(); reset_spectral_matrix_regs(); // Spectral Matrices simulator diff --git a/src/tc_load_dump_parameters.c b/src/tc_load_dump_parameters.c --- a/src/tc_load_dump_parameters.c +++ b/src/tc_load_dump_parameters.c @@ -41,6 +41,9 @@ int action_load_normal_par(ccsdsTelecomm int result; int flag; rtems_status_code status; + unsigned char sy_lfr_n_bp_p0; + unsigned char sy_lfr_n_bp_p1; + float aux; flag = LFR_SUCCESSFUL; @@ -83,6 +86,20 @@ int action_load_normal_par(ccsdsTelecomm } } + //**************************************************************** + // check the consistency between sy_lfr_n_bp_p0 and sy_lfr_n_bp_p1 + if (flag == LFR_SUCCESSFUL) + { + sy_lfr_n_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P0 ]; + sy_lfr_n_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P1 ]; + aux = ( (float ) sy_lfr_n_bp_p1 / sy_lfr_n_bp_p0 ) - floor(sy_lfr_n_bp_p1 / sy_lfr_n_bp_p0); + if (aux != 0) + { + status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_BP_P0+10, sy_lfr_n_bp_p0 ); + flag = LFR_DEFAULT; + } + } + //*************** // sy_lfr_n_bp_p0 if (flag == LFR_SUCCESSFUL) @@ -129,24 +146,56 @@ int action_load_burst_par(ccsdsTelecomma */ int result; - unsigned char lfrMode; + int flag; rtems_status_code status; + unsigned char sy_lfr_b_bp_p0; + unsigned char sy_lfr_b_bp_p1; + float aux; - result = LFR_DEFAULT; - lfrMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4; + flag = LFR_SUCCESSFUL; - if ( lfrMode == LFR_MODE_BURST ) { + if ( lfrCurrentMode == LFR_MODE_BURST ) { status = send_tm_lfr_tc_exe_not_executable( TC, queue_id ); result = LFR_DEFAULT; } - else { - parameter_dump_packet.sy_lfr_b_bp_p0 = TC->dataAndCRC[0]; - parameter_dump_packet.sy_lfr_b_bp_p1 = TC->dataAndCRC[1]; - result = LFR_SUCCESSFUL; + //**************************************************************** + // check the consistency between sy_lfr_b_bp_p0 and sy_lfr_b_bp_p1 + if (flag == LFR_SUCCESSFUL) + { + sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ]; + sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ]; + aux = ( (float ) sy_lfr_b_bp_p1 / sy_lfr_b_bp_p0 ) - floor(sy_lfr_b_bp_p1 / sy_lfr_b_bp_p0); + if (aux != 0) + { + status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_B_BP_P0+10, sy_lfr_b_bp_p0 ); + flag = LFR_DEFAULT; + } } - return result; + //*************** + // sy_lfr_b_bp_p0 + if (flag == LFR_SUCCESSFUL) + { + result = set_sy_lfr_b_bp_p0( TC, queue_id ); + if (result != LFR_SUCCESSFUL) + { + flag = LFR_DEFAULT; + } + } + + //*************** + // sy_lfr_b_bp_p1 + if (flag == LFR_SUCCESSFUL) + { + result = set_sy_lfr_b_bp_p1( TC, queue_id ); + if (result != LFR_SUCCESSFUL) + { + flag = LFR_DEFAULT; + } + } + + return flag; } int action_load_sbm1_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time) @@ -157,25 +206,58 @@ int action_load_sbm1_par(ccsdsTelecomman * @param queue_id is the id of the queue which handles TM related to this execution step * */ - int result; - unsigned char lfrMode; - rtems_status_code status; - result = LFR_DEFAULT; - lfrMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4; + int result; + int flag; + rtems_status_code status; + unsigned char sy_lfr_s1_bp_p0; + unsigned char sy_lfr_s1_bp_p1; + float aux; - if ( lfrMode == LFR_MODE_SBM1 ) { + flag = LFR_SUCCESSFUL; + + if ( lfrCurrentMode == LFR_MODE_SBM1 ) { status = send_tm_lfr_tc_exe_not_executable( TC, queue_id ); result = LFR_DEFAULT; } - else { - parameter_dump_packet.sy_lfr_s1_bp_p0 = TC->dataAndCRC[0]; - parameter_dump_packet.sy_lfr_s1_bp_p1 = TC->dataAndCRC[1]; - result = LFR_SUCCESSFUL; + //****************************************************************** + // check the consistency between sy_lfr_s1_bp_p0 and sy_lfr_s1_bp_p1 + if (flag == LFR_SUCCESSFUL) + { + sy_lfr_s1_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P0 ]; + sy_lfr_s1_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P1 ]; + aux = ( (float ) sy_lfr_s1_bp_p1 / (sy_lfr_s1_bp_p0*0.25) ) - floor(sy_lfr_s1_bp_p1 / (sy_lfr_s1_bp_p0*0.25)); + if (aux != 0) + { + status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S1_BP_P0+10, sy_lfr_s1_bp_p0 ); + flag = LFR_DEFAULT; + } } - return result; + //*************** + // sy_lfr_s1_bp_p0 + if (flag == LFR_SUCCESSFUL) + { + result = set_sy_lfr_s1_bp_p0( TC, queue_id ); + if (result != LFR_SUCCESSFUL) + { + flag = LFR_DEFAULT; + } + } + + //*************** + // sy_lfr_s1_bp_p1 + if (flag == LFR_SUCCESSFUL) + { + result = set_sy_lfr_s1_bp_p1( TC, queue_id ); + if (result != LFR_SUCCESSFUL) + { + flag = LFR_DEFAULT; + } + } + + return flag; } int action_load_sbm2_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time) @@ -188,24 +270,56 @@ int action_load_sbm2_par(ccsdsTelecomman */ int result; - unsigned char lfrMode; + int flag; rtems_status_code status; + unsigned char sy_lfr_s2_bp_p0; + unsigned char sy_lfr_s2_bp_p1; + float aux; - result = LFR_DEFAULT; - lfrMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4; + flag = LFR_SUCCESSFUL; - if ( lfrMode == LFR_MODE_SBM2 ) { + if ( lfrCurrentMode == LFR_MODE_SBM2 ) { status = send_tm_lfr_tc_exe_not_executable( TC, queue_id ); result = LFR_DEFAULT; } - else { - parameter_dump_packet.sy_lfr_s2_bp_p0 = TC->dataAndCRC[0]; - parameter_dump_packet.sy_lfr_s2_bp_p1 = TC->dataAndCRC[1]; - result = LFR_SUCCESSFUL; + //****************************************************************** + // check the consistency between sy_lfr_s2_bp_p0 and sy_lfr_s2_bp_p1 + if (flag == LFR_SUCCESSFUL) + { + sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ]; + sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ]; + aux = ( (float ) sy_lfr_s2_bp_p1 / sy_lfr_s2_bp_p0 ) - floor(sy_lfr_s2_bp_p1 / sy_lfr_s2_bp_p0); + if (aux != 0) + { + status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S2_BP_P0+10, sy_lfr_s2_bp_p0 ); + flag = LFR_DEFAULT; + } } - return result; + //*************** + // sy_lfr_s2_bp_p0 + if (flag == LFR_SUCCESSFUL) + { + result = set_sy_lfr_s2_bp_p0( TC, queue_id ); + if (result != LFR_SUCCESSFUL) + { + flag = LFR_DEFAULT; + } + } + + //*************** + // sy_lfr_s2_bp_p1 + if (flag == LFR_SUCCESSFUL) + { + result = set_sy_lfr_s2_bp_p1( TC, queue_id ); + if (result != LFR_SUCCESSFUL) + { + flag = LFR_DEFAULT; + } + } + + return flag; } int action_dump_par( rtems_id queue_id ) @@ -403,12 +517,118 @@ int set_sy_lfr_n_cwf_long_f3(ccsdsTeleco //********************** // BURST MODE PARAMETERS +int set_sy_lfr_b_bp_p0( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ) +{ + /** This function sets the time between two basic parameter sets, in s (SY_LFR_B_BP_P0). + * + * @param TC points to the TeleCommand packet that is being processed + * @param queue_id is the id of the queue which handles TM related to this execution step + * + */ + + int status; + + status = LFR_SUCCESSFUL; + + parameter_dump_packet.sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ]; + + return status; +} + +int set_sy_lfr_b_bp_p1( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ) +{ + /** This function sets the time between two basic parameter sets, in s (SY_LFR_B_BP_P1). + * + * @param TC points to the TeleCommand packet that is being processed + * @param queue_id is the id of the queue which handles TM related to this execution step + * + */ + + int status; + + status = LFR_SUCCESSFUL; + + parameter_dump_packet.sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ]; + + return status; +} //********************* // SBM1 MODE PARAMETERS +int set_sy_lfr_s1_bp_p0( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ) +{ + /** This function sets the time between two basic parameter sets, in s (SY_LFR_S1_BP_P0). + * + * @param TC points to the TeleCommand packet that is being processed + * @param queue_id is the id of the queue which handles TM related to this execution step + * + */ + + int status; + + status = LFR_SUCCESSFUL; + + parameter_dump_packet.sy_lfr_s1_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P0 ]; + + return status; +} + +int set_sy_lfr_s1_bp_p1( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ) +{ + /** This function sets the time between two basic parameter sets, in s (SY_LFR_S1_BP_P1). + * + * @param TC points to the TeleCommand packet that is being processed + * @param queue_id is the id of the queue which handles TM related to this execution step + * + */ + + int status; + + status = LFR_SUCCESSFUL; + + parameter_dump_packet.sy_lfr_s1_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P1 ]; + + return status; +} //********************* // SBM2 MODE PARAMETERS +int set_sy_lfr_s2_bp_p0( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ) +{ + /** This function sets the time between two basic parameter sets, in s (SY_LFR_S2_BP_P0). + * + * @param TC points to the TeleCommand packet that is being processed + * @param queue_id is the id of the queue which handles TM related to this execution step + * + */ + + int status; + + status = LFR_SUCCESSFUL; + + parameter_dump_packet.sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ]; + + return status; +} + +int set_sy_lfr_s2_bp_p1( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ) +{ + /** This function sets the time between two basic parameter sets, in s (SY_LFR_S2_BP_P1). + * + * @param TC points to the TeleCommand packet that is being processed + * @param queue_id is the id of the queue which handles TM related to this execution step + * + */ + + int status; + + status = LFR_SUCCESSFUL; + + parameter_dump_packet.sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ]; + + return status; +} + //******************* // TC_LFR_UPDATE_INFO