##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » USERS » JEANDET » LFR_FSW
RSS

Fork of HG_REPOSITORIES/LPP/INSTRUMENTATION/SOLO_LFR/DEV_PLE

Clone from https://hephaistos.lpp.polytechnique.fr/rhodecode/HG_REPOSITORIES/LPP/INSTRUMENTATION/SOLO_LFR/DEV_PLE

3.1.0.7...
paul -
r337:e784d0191567 R3_plus draft
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,103 +1,103
1 #ifndef TC_LOAD_DUMP_PARAMETERS_H
1 #ifndef TC_LOAD_DUMP_PARAMETERS_H
2 #define TC_LOAD_DUMP_PARAMETERS_H
2 #define TC_LOAD_DUMP_PARAMETERS_H
3
3
4 #include <rtems.h>
4 #include <rtems.h>
5 #include <stdio.h>
5 #include <stdio.h>
6
6
7 #include "fsw_params.h"
7 #include "fsw_params.h"
8 #include "wf_handler.h"
8 #include "wf_handler.h"
9 #include "tm_lfr_tc_exe.h"
9 #include "tm_lfr_tc_exe.h"
10 #include "fsw_misc.h"
10 #include "fsw_misc.h"
11 #include "basic_parameters_params.h"
11 #include "basic_parameters_params.h"
12 #include "avf0_prc0.h"
12 #include "avf0_prc0.h"
13
13
14 #define FLOAT_EQUAL_ZERO 0.001
14 #define FLOAT_EQUAL_ZERO 0.001
15 #define NB_BINS_TO_REMOVE 3
15 #define NB_BINS_TO_REMOVE 3
16 #define FI_INTERVAL_COEFF 0.285
16 #define FI_INTERVAL_COEFF 0.285
17 #define BIN_MIN 0
17 #define BIN_MIN 0
18 #define BIN_MAX 127
18 #define BIN_MAX 127
19 #define DELTAF_F0 96.
19 #define DELTAF_F0 96.
20 #define DELTAF_F1 16.
20 #define DELTAF_F1 16.
21 #define DELTAF_F2 1.
21 #define DELTAF_F2 1.
22
22
23 #define BIT_RW1_F1 0x80
23 #define BIT_RW1_F1 0x80
24 #define BIT_RW1_F2 0x40
24 #define BIT_RW1_F2 0x40
25 #define BIT_RW2_F1 0x20
25 #define BIT_RW2_F1 0x20
26 #define BIT_RW2_F2 0x10
26 #define BIT_RW2_F2 0x10
27 #define BIT_RW3_F1 0x08
27 #define BIT_RW3_F1 0x08
28 #define BIT_RW3_F2 0x04
28 #define BIT_RW3_F2 0x04
29 #define BIT_RW4_F1 0x02
29 #define BIT_RW4_F1 0x02
30 #define BIT_RW4_F2 0x01
30 #define BIT_RW4_F2 0x01
31
31
32 #define SBM_KCOEFF_PER_NORM_KCOEFF 2
32 #define SBM_KCOEFF_PER_NORM_KCOEFF 2
33
33
34 extern unsigned short sequenceCounterParameterDump;
34 extern unsigned short sequenceCounterParameterDump;
35 extern unsigned short sequenceCounters_TM_DUMP[];
35 extern unsigned short sequenceCounters_TM_DUMP[];
36 extern float k_coeff_intercalib_f0_norm[ ];
36 extern float k_coeff_intercalib_f0_norm[ ];
37 extern float k_coeff_intercalib_f0_sbm[ ];
37 extern float k_coeff_intercalib_f0_sbm[ ];
38 extern float k_coeff_intercalib_f1_norm[ ];
38 extern float k_coeff_intercalib_f1_norm[ ];
39 extern float k_coeff_intercalib_f1_sbm[ ];
39 extern float k_coeff_intercalib_f1_sbm[ ];
40 extern float k_coeff_intercalib_f2[ ];
40 extern float k_coeff_intercalib_f2[ ];
41 extern fbins_masks_t fbins_masks;
41 extern fbins_masks_t fbins_masks;
42
42
43 int action_load_common_par( ccsdsTelecommandPacket_t *TC );
43 int action_load_common_par( ccsdsTelecommandPacket_t *TC );
44 int action_load_normal_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time);
44 int action_load_normal_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time);
45 int action_load_burst_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time);
45 int action_load_burst_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time);
46 int action_load_sbm1_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time);
46 int action_load_sbm1_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time);
47 int action_load_sbm2_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time);
47 int action_load_sbm2_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time);
48 int action_load_kcoefficients(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time);
48 int action_load_kcoefficients(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time);
49 int action_load_fbins_mask(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time);
49 int action_load_fbins_mask(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time);
50 int action_load_filter_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time);
50 int action_load_filter_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time);
51 int action_dump_kcoefficients(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time);
51 int action_dump_kcoefficients(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time);
52 int action_dump_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id );
52 int action_dump_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id );
53
53
54 // NORMAL
54 // NORMAL
55 int check_normal_par_consistency( ccsdsTelecommandPacket_t *TC, rtems_id queue_id );
55 int check_normal_par_consistency( ccsdsTelecommandPacket_t *TC, rtems_id queue_id );
56 int set_sy_lfr_n_swf_l( ccsdsTelecommandPacket_t *TC );
56 int set_sy_lfr_n_swf_l( ccsdsTelecommandPacket_t *TC );
57 int set_sy_lfr_n_swf_p( ccsdsTelecommandPacket_t *TC );
57 int set_sy_lfr_n_swf_p( ccsdsTelecommandPacket_t *TC );
58 int set_sy_lfr_n_asm_p( ccsdsTelecommandPacket_t *TC );
58 int set_sy_lfr_n_asm_p( ccsdsTelecommandPacket_t *TC );
59 int set_sy_lfr_n_bp_p0( ccsdsTelecommandPacket_t *TC );
59 int set_sy_lfr_n_bp_p0( ccsdsTelecommandPacket_t *TC );
60 int set_sy_lfr_n_bp_p1( ccsdsTelecommandPacket_t *TC );
60 int set_sy_lfr_n_bp_p1( ccsdsTelecommandPacket_t *TC );
61 int set_sy_lfr_n_cwf_long_f3( ccsdsTelecommandPacket_t *TC );
61 int set_sy_lfr_n_cwf_long_f3( ccsdsTelecommandPacket_t *TC );
62
62
63 // BURST
63 // BURST
64 int set_sy_lfr_b_bp_p0( ccsdsTelecommandPacket_t *TC );
64 int set_sy_lfr_b_bp_p0( ccsdsTelecommandPacket_t *TC );
65 int set_sy_lfr_b_bp_p1( ccsdsTelecommandPacket_t *TC );
65 int set_sy_lfr_b_bp_p1( ccsdsTelecommandPacket_t *TC );
66
66
67 // SBM1
67 // SBM1
68 int set_sy_lfr_s1_bp_p0( ccsdsTelecommandPacket_t *TC );
68 int set_sy_lfr_s1_bp_p0( ccsdsTelecommandPacket_t *TC );
69 int set_sy_lfr_s1_bp_p1( ccsdsTelecommandPacket_t *TC );
69 int set_sy_lfr_s1_bp_p1( ccsdsTelecommandPacket_t *TC );
70
70
71 // SBM2
71 // SBM2
72 int set_sy_lfr_s2_bp_p0( ccsdsTelecommandPacket_t *TC );
72 int set_sy_lfr_s2_bp_p0( ccsdsTelecommandPacket_t *TC );
73 int set_sy_lfr_s2_bp_p1( ccsdsTelecommandPacket_t *TC );
73 int set_sy_lfr_s2_bp_p1( ccsdsTelecommandPacket_t *TC );
74
74
75 // TC_LFR_UPDATE_INFO
75 // TC_LFR_UPDATE_INFO
76 unsigned int check_update_info_hk_lfr_mode( unsigned char mode );
76 unsigned int check_update_info_hk_lfr_mode( unsigned char mode );
77 unsigned int check_update_info_hk_tds_mode( unsigned char mode );
77 unsigned int check_update_info_hk_tds_mode( unsigned char mode );
78 unsigned int check_update_info_hk_thr_mode( unsigned char mode );
78 unsigned int check_update_info_hk_thr_mode( unsigned char mode );
79 void getReactionWheelsFrequencies( ccsdsTelecommandPacket_t *TC );
79 void getReactionWheelsFrequencies( ccsdsTelecommandPacket_t *TC );
80 void setFBinMask(unsigned char *fbins_mask, float rw_f, unsigned char deltaFreq, unsigned char flag );
80 void setFBinMask(unsigned char *fbins_mask, float rw_f, unsigned char deltaFreq, unsigned char flag, float sy_lfr_rw_k );
81 void build_sy_lfr_rw_mask( unsigned int channel );
81 void build_sy_lfr_rw_mask( unsigned int channel );
82 void build_sy_lfr_rw_masks();
82 void build_sy_lfr_rw_masks();
83 void merge_fbins_masks( void );
83 void merge_fbins_masks( void );
84
84
85 // FBINS_MASK
85 // FBINS_MASK
86 int set_sy_lfr_fbins( ccsdsTelecommandPacket_t *TC );
86 int set_sy_lfr_fbins( ccsdsTelecommandPacket_t *TC );
87
87
88 // TC_LFR_LOAD_PARS_FILTER_PAR
88 // TC_LFR_LOAD_PARS_FILTER_PAR
89 int check_sy_lfr_filter_parameters( ccsdsTelecommandPacket_t *TC, rtems_id queue_id );
89 int check_sy_lfr_filter_parameters( ccsdsTelecommandPacket_t *TC, rtems_id queue_id );
90
90
91 // KCOEFFICIENTS
91 // KCOEFFICIENTS
92 int set_sy_lfr_kcoeff(ccsdsTelecommandPacket_t *TC , rtems_id queue_id);
92 int set_sy_lfr_kcoeff(ccsdsTelecommandPacket_t *TC , rtems_id queue_id);
93 void copyFloatByChar( unsigned char *destination, unsigned char *source );
93 void copyFloatByChar( unsigned char *destination, unsigned char *source );
94 void copyInt32ByChar( unsigned char *destination, unsigned char *source );
94 void copyInt32ByChar( unsigned char *destination, unsigned char *source );
95 void copyInt16ByChar( unsigned char *destination, unsigned char *source );
95 void copyInt16ByChar( unsigned char *destination, unsigned char *source );
96 void floatToChar( float value, unsigned char* ptr);
96 void floatToChar( float value, unsigned char* ptr);
97
97
98 void init_parameter_dump( void );
98 void init_parameter_dump( void );
99 void init_kcoefficients_dump( void );
99 void init_kcoefficients_dump( void );
100 void init_kcoefficients_dump_packet( Packet_TM_LFR_KCOEFFICIENTS_DUMP_t *kcoefficients_dump, unsigned char pkt_nr, unsigned char blk_nr );
100 void init_kcoefficients_dump_packet( Packet_TM_LFR_KCOEFFICIENTS_DUMP_t *kcoefficients_dump, unsigned char pkt_nr, unsigned char blk_nr );
101 void increment_seq_counter_destination_id_dump( unsigned char *packet_sequence_control, unsigned char destination_id );
101 void increment_seq_counter_destination_id_dump( unsigned char *packet_sequence_control, unsigned char destination_id );
102
102
103 #endif // TC_LOAD_DUMP_PARAMETERS_H
103 #endif // TC_LOAD_DUMP_PARAMETERS_H
Show file before | Show file after | Hide comments
@@ -1,107 +1,107
1 cmake_minimum_required (VERSION 2.6)
1 cmake_minimum_required (VERSION 2.6)
2 project (fsw)
2 project (fsw)
3
3
4 include(sparc-rtems)
4 include(sparc-rtems)
5 include(cppcheck)
5 include(cppcheck)
6
6
7 include_directories("../header"
7 include_directories("../header"
8 "../header/lfr_common_headers"
8 "../header/lfr_common_headers"
9 "../header/processing"
9 "../header/processing"
10 "../LFR_basic-parameters"
10 "../LFR_basic-parameters"
11 "../src")
11 "../src")
12
12
13 set(SOURCES wf_handler.c
13 set(SOURCES wf_handler.c
14 tc_handler.c
14 tc_handler.c
15 fsw_misc.c
15 fsw_misc.c
16 fsw_init.c
16 fsw_init.c
17 fsw_globals.c
17 fsw_globals.c
18 fsw_spacewire.c
18 fsw_spacewire.c
19 tc_load_dump_parameters.c
19 tc_load_dump_parameters.c
20 tm_lfr_tc_exe.c
20 tm_lfr_tc_exe.c
21 tc_acceptance.c
21 tc_acceptance.c
22 processing/fsw_processing.c
22 processing/fsw_processing.c
23 processing/avf0_prc0.c
23 processing/avf0_prc0.c
24 processing/avf1_prc1.c
24 processing/avf1_prc1.c
25 processing/avf2_prc2.c
25 processing/avf2_prc2.c
26 lfr_cpu_usage_report.c
26 lfr_cpu_usage_report.c
27 ${LFR_BP_SRC}
27 ${LFR_BP_SRC}
28 ../header/wf_handler.h
28 ../header/wf_handler.h
29 ../header/tc_handler.h
29 ../header/tc_handler.h
30 ../header/grlib_regs.h
30 ../header/grlib_regs.h
31 ../header/fsw_misc.h
31 ../header/fsw_misc.h
32 ../header/fsw_init.h
32 ../header/fsw_init.h
33 ../header/fsw_spacewire.h
33 ../header/fsw_spacewire.h
34 ../header/tc_load_dump_parameters.h
34 ../header/tc_load_dump_parameters.h
35 ../header/tm_lfr_tc_exe.h
35 ../header/tm_lfr_tc_exe.h
36 ../header/tc_acceptance.h
36 ../header/tc_acceptance.h
37 ../header/processing/fsw_processing.h
37 ../header/processing/fsw_processing.h
38 ../header/processing/avf0_prc0.h
38 ../header/processing/avf0_prc0.h
39 ../header/processing/avf1_prc1.h
39 ../header/processing/avf1_prc1.h
40 ../header/processing/avf2_prc2.h
40 ../header/processing/avf2_prc2.h
41 ../header/fsw_params_wf_handler.h
41 ../header/fsw_params_wf_handler.h
42 ../header/lfr_cpu_usage_report.h
42 ../header/lfr_cpu_usage_report.h
43 ../header/lfr_common_headers/ccsds_types.h
43 ../header/lfr_common_headers/ccsds_types.h
44 ../header/lfr_common_headers/fsw_params.h
44 ../header/lfr_common_headers/fsw_params.h
45 ../header/lfr_common_headers/fsw_params_nb_bytes.h
45 ../header/lfr_common_headers/fsw_params_nb_bytes.h
46 ../header/lfr_common_headers/fsw_params_processing.h
46 ../header/lfr_common_headers/fsw_params_processing.h
47 ../header/lfr_common_headers/tm_byte_positions.h
47 ../header/lfr_common_headers/tm_byte_positions.h
48 ../LFR_basic-parameters/basic_parameters.h
48 ../LFR_basic-parameters/basic_parameters.h
49 ../LFR_basic-parameters/basic_parameters_params.h
49 ../LFR_basic-parameters/basic_parameters_params.h
50 ../header/GscMemoryLPP.hpp
50 ../header/GscMemoryLPP.hpp
51 )
51 )
52
52
53
53
54 option(FSW_verbose "Enable verbose LFR" OFF)
54 option(FSW_verbose "Enable verbose LFR" OFF)
55 option(FSW_boot_messages "Enable LFR boot messages" OFF)
55 option(FSW_boot_messages "Enable LFR boot messages" OFF)
56 option(FSW_debug_messages "Enable LFR debug messages" OFF)
56 option(FSW_debug_messages "Enable LFR debug messages" OFF)
57 option(FSW_cpu_usage_report "Enable LFR cpu usage report" OFF)
57 option(FSW_cpu_usage_report "Enable LFR cpu usage report" OFF)
58 option(FSW_stack_report "Enable LFR stack report" OFF)
58 option(FSW_stack_report "Enable LFR stack report" OFF)
59 option(FSW_vhdl_dev "?" OFF)
59 option(FSW_vhdl_dev "?" OFF)
60 option(FSW_lpp_dpu_destid "Set to debug at LPP" ON)
60 option(FSW_lpp_dpu_destid "Set to debug at LPP" ON)
61 option(FSW_debug_watchdog "Enable debug watchdog" OFF)
61 option(FSW_debug_watchdog "Enable debug watchdog" OFF)
62 option(FSW_debug_tch "?" OFF)
62 option(FSW_debug_tch "?" OFF)
63
63
64 set(SW_VERSION_N1 "3" CACHE STRING "Choose N1 FSW Version." FORCE)
64 set(SW_VERSION_N1 "3" CACHE STRING "Choose N1 FSW Version." FORCE)
65 set(SW_VERSION_N2 "1" CACHE STRING "Choose N2 FSW Version." FORCE)
65 set(SW_VERSION_N2 "1" CACHE STRING "Choose N2 FSW Version." FORCE)
66 set(SW_VERSION_N3 "0" CACHE STRING "Choose N3 FSW Version." FORCE)
66 set(SW_VERSION_N3 "0" CACHE STRING "Choose N3 FSW Version." FORCE)
67 set(SW_VERSION_N4 "6" CACHE STRING "Choose N4 FSW Version." FORCE)
67 set(SW_VERSION_N4 "7" CACHE STRING "Choose N4 FSW Version." FORCE)
68
68
69 if(FSW_verbose)
69 if(FSW_verbose)
70 add_definitions(-DPRINT_MESSAGES_ON_CONSOLE)
70 add_definitions(-DPRINT_MESSAGES_ON_CONSOLE)
71 endif()
71 endif()
72 if(FSW_boot_messages)
72 if(FSW_boot_messages)
73 add_definitions(-DBOOT_MESSAGES)
73 add_definitions(-DBOOT_MESSAGES)
74 endif()
74 endif()
75 if(FSW_debug_messages)
75 if(FSW_debug_messages)
76 add_definitions(-DDEBUG_MESSAGES)
76 add_definitions(-DDEBUG_MESSAGES)
77 endif()
77 endif()
78 if(FSW_cpu_usage_report)
78 if(FSW_cpu_usage_report)
79 add_definitions(-DPRINT_TASK_STATISTICS)
79 add_definitions(-DPRINT_TASK_STATISTICS)
80 endif()
80 endif()
81 if(FSW_stack_report)
81 if(FSW_stack_report)
82 add_definitions(-DPRINT_STACK_REPORT)
82 add_definitions(-DPRINT_STACK_REPORT)
83 endif()
83 endif()
84 if(FSW_vhdl_dev)
84 if(FSW_vhdl_dev)
85 add_definitions(-DVHDL_DEV)
85 add_definitions(-DVHDL_DEV)
86 endif()
86 endif()
87 if(FSW_lpp_dpu_destid)
87 if(FSW_lpp_dpu_destid)
88 add_definitions(-DLPP_DPU_DESTID)
88 add_definitions(-DLPP_DPU_DESTID)
89 endif()
89 endif()
90 if(FSW_debug_watchdog)
90 if(FSW_debug_watchdog)
91 add_definitions(-DDEBUG_WATCHDOG)
91 add_definitions(-DDEBUG_WATCHDOG)
92 endif()
92 endif()
93 if(FSW_debug_tch)
93 if(FSW_debug_tch)
94 add_definitions(-DDEBUG_TCH)
94 add_definitions(-DDEBUG_TCH)
95 endif()
95 endif()
96
96
97 add_definitions(-DMSB_FIRST_TCH)
97 add_definitions(-DMSB_FIRST_TCH)
98
98
99 add_definitions(-DSWVERSION=-1-0)
99 add_definitions(-DSWVERSION=-1-0)
100 add_definitions(-DSW_VERSION_N1=${SW_VERSION_N1})
100 add_definitions(-DSW_VERSION_N1=${SW_VERSION_N1})
101 add_definitions(-DSW_VERSION_N2=${SW_VERSION_N2})
101 add_definitions(-DSW_VERSION_N2=${SW_VERSION_N2})
102 add_definitions(-DSW_VERSION_N3=${SW_VERSION_N3})
102 add_definitions(-DSW_VERSION_N3=${SW_VERSION_N3})
103 add_definitions(-DSW_VERSION_N4=${SW_VERSION_N4})
103 add_definitions(-DSW_VERSION_N4=${SW_VERSION_N4})
104
104
105 add_executable(fsw ${SOURCES})
105 add_executable(fsw ${SOURCES})
106 add_test_cppcheck(fsw STYLE UNUSED_FUNCTIONS POSSIBLE_ERROR MISSING_INCLUDE)
106 add_test_cppcheck(fsw STYLE UNUSED_FUNCTIONS POSSIBLE_ERROR MISSING_INCLUDE)
107
107
Show file before | Show file after | Hide comments
@@ -1,1671 +1,1693
1 /** Functions to load and dump parameters in the LFR registers.
1 /** Functions to load and dump parameters in the LFR registers.
2 *
2 *
3 * @file
3 * @file
4 * @author P. LEROY
4 * @author P. LEROY
5 *
5 *
6 * A group of functions to handle TC related to parameter loading and dumping.\n
6 * A group of functions to handle TC related to parameter loading and dumping.\n
7 * TC_LFR_LOAD_COMMON_PAR\n
7 * TC_LFR_LOAD_COMMON_PAR\n
8 * TC_LFR_LOAD_NORMAL_PAR\n
8 * TC_LFR_LOAD_NORMAL_PAR\n
9 * TC_LFR_LOAD_BURST_PAR\n
9 * TC_LFR_LOAD_BURST_PAR\n
10 * TC_LFR_LOAD_SBM1_PAR\n
10 * TC_LFR_LOAD_SBM1_PAR\n
11 * TC_LFR_LOAD_SBM2_PAR\n
11 * TC_LFR_LOAD_SBM2_PAR\n
12 *
12 *
13 */
13 */
14
14
15 #include "tc_load_dump_parameters.h"
15 #include "tc_load_dump_parameters.h"
16
16
17 Packet_TM_LFR_KCOEFFICIENTS_DUMP_t kcoefficients_dump_1 = {0};
17 Packet_TM_LFR_KCOEFFICIENTS_DUMP_t kcoefficients_dump_1 = {0};
18 Packet_TM_LFR_KCOEFFICIENTS_DUMP_t kcoefficients_dump_2 = {0};
18 Packet_TM_LFR_KCOEFFICIENTS_DUMP_t kcoefficients_dump_2 = {0};
19 ring_node kcoefficient_node_1 = {0};
19 ring_node kcoefficient_node_1 = {0};
20 ring_node kcoefficient_node_2 = {0};
20 ring_node kcoefficient_node_2 = {0};
21
21
22 int action_load_common_par(ccsdsTelecommandPacket_t *TC)
22 int action_load_common_par(ccsdsTelecommandPacket_t *TC)
23 {
23 {
24 /** This function updates the LFR registers with the incoming common parameters.
24 /** This function updates the LFR registers with the incoming common parameters.
25 *
25 *
26 * @param TC points to the TeleCommand packet that is being processed
26 * @param TC points to the TeleCommand packet that is being processed
27 *
27 *
28 *
28 *
29 */
29 */
30
30
31 parameter_dump_packet.sy_lfr_common_parameters_spare = TC->dataAndCRC[0];
31 parameter_dump_packet.sy_lfr_common_parameters_spare = TC->dataAndCRC[0];
32 parameter_dump_packet.sy_lfr_common_parameters = TC->dataAndCRC[1];
32 parameter_dump_packet.sy_lfr_common_parameters = TC->dataAndCRC[1];
33 set_wfp_data_shaping( );
33 set_wfp_data_shaping( );
34 return LFR_SUCCESSFUL;
34 return LFR_SUCCESSFUL;
35 }
35 }
36
36
37 int action_load_normal_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
37 int action_load_normal_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
38 {
38 {
39 /** This function updates the LFR registers with the incoming normal parameters.
39 /** This function updates the LFR registers with the incoming normal parameters.
40 *
40 *
41 * @param TC points to the TeleCommand packet that is being processed
41 * @param TC points to the TeleCommand packet that is being processed
42 * @param queue_id is the id of the queue which handles TM related to this execution step
42 * @param queue_id is the id of the queue which handles TM related to this execution step
43 *
43 *
44 */
44 */
45
45
46 int result;
46 int result;
47 int flag;
47 int flag;
48 rtems_status_code status;
48 rtems_status_code status;
49
49
50 flag = LFR_SUCCESSFUL;
50 flag = LFR_SUCCESSFUL;
51
51
52 if ( (lfrCurrentMode == LFR_MODE_NORMAL) ||
52 if ( (lfrCurrentMode == LFR_MODE_NORMAL) ||
53 (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) ) {
53 (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) ) {
54 status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
54 status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
55 flag = LFR_DEFAULT;
55 flag = LFR_DEFAULT;
56 }
56 }
57
57
58 // CHECK THE PARAMETERS SET CONSISTENCY
58 // CHECK THE PARAMETERS SET CONSISTENCY
59 if (flag == LFR_SUCCESSFUL)
59 if (flag == LFR_SUCCESSFUL)
60 {
60 {
61 flag = check_normal_par_consistency( TC, queue_id );
61 flag = check_normal_par_consistency( TC, queue_id );
62 }
62 }
63
63
64 // SET THE PARAMETERS IF THEY ARE CONSISTENT
64 // SET THE PARAMETERS IF THEY ARE CONSISTENT
65 if (flag == LFR_SUCCESSFUL)
65 if (flag == LFR_SUCCESSFUL)
66 {
66 {
67 result = set_sy_lfr_n_swf_l( TC );
67 result = set_sy_lfr_n_swf_l( TC );
68 result = set_sy_lfr_n_swf_p( TC );
68 result = set_sy_lfr_n_swf_p( TC );
69 result = set_sy_lfr_n_bp_p0( TC );
69 result = set_sy_lfr_n_bp_p0( TC );
70 result = set_sy_lfr_n_bp_p1( TC );
70 result = set_sy_lfr_n_bp_p1( TC );
71 result = set_sy_lfr_n_asm_p( TC );
71 result = set_sy_lfr_n_asm_p( TC );
72 result = set_sy_lfr_n_cwf_long_f3( TC );
72 result = set_sy_lfr_n_cwf_long_f3( TC );
73 }
73 }
74
74
75 return flag;
75 return flag;
76 }
76 }
77
77
78 int action_load_burst_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
78 int action_load_burst_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
79 {
79 {
80 /** This function updates the LFR registers with the incoming burst parameters.
80 /** This function updates the LFR registers with the incoming burst parameters.
81 *
81 *
82 * @param TC points to the TeleCommand packet that is being processed
82 * @param TC points to the TeleCommand packet that is being processed
83 * @param queue_id is the id of the queue which handles TM related to this execution step
83 * @param queue_id is the id of the queue which handles TM related to this execution step
84 *
84 *
85 */
85 */
86
86
87 int flag;
87 int flag;
88 rtems_status_code status;
88 rtems_status_code status;
89 unsigned char sy_lfr_b_bp_p0;
89 unsigned char sy_lfr_b_bp_p0;
90 unsigned char sy_lfr_b_bp_p1;
90 unsigned char sy_lfr_b_bp_p1;
91 float aux;
91 float aux;
92
92
93 flag = LFR_SUCCESSFUL;
93 flag = LFR_SUCCESSFUL;
94
94
95 if ( lfrCurrentMode == LFR_MODE_BURST ) {
95 if ( lfrCurrentMode == LFR_MODE_BURST ) {
96 status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
96 status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
97 flag = LFR_DEFAULT;
97 flag = LFR_DEFAULT;
98 }
98 }
99
99
100 sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ];
100 sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ];
101 sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ];
101 sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ];
102
102
103 // sy_lfr_b_bp_p0 shall not be lower than its default value
103 // sy_lfr_b_bp_p0 shall not be lower than its default value
104 if (flag == LFR_SUCCESSFUL)
104 if (flag == LFR_SUCCESSFUL)
105 {
105 {
106 if (sy_lfr_b_bp_p0 < DEFAULT_SY_LFR_B_BP_P0 )
106 if (sy_lfr_b_bp_p0 < DEFAULT_SY_LFR_B_BP_P0 )
107 {
107 {
108 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_B_BP_P0 + DATAFIELD_OFFSET, sy_lfr_b_bp_p0 );
108 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_B_BP_P0 + DATAFIELD_OFFSET, sy_lfr_b_bp_p0 );
109 flag = WRONG_APP_DATA;
109 flag = WRONG_APP_DATA;
110 }
110 }
111 }
111 }
112 // sy_lfr_b_bp_p1 shall not be lower than its default value
112 // sy_lfr_b_bp_p1 shall not be lower than its default value
113 if (flag == LFR_SUCCESSFUL)
113 if (flag == LFR_SUCCESSFUL)
114 {
114 {
115 if (sy_lfr_b_bp_p1 < DEFAULT_SY_LFR_B_BP_P1 )
115 if (sy_lfr_b_bp_p1 < DEFAULT_SY_LFR_B_BP_P1 )
116 {
116 {
117 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_B_BP_P1 + DATAFIELD_OFFSET, sy_lfr_b_bp_p1 );
117 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_B_BP_P1 + DATAFIELD_OFFSET, sy_lfr_b_bp_p1 );
118 flag = WRONG_APP_DATA;
118 flag = WRONG_APP_DATA;
119 }
119 }
120 }
120 }
121 //****************************************************************
121 //****************************************************************
122 // check the consistency between sy_lfr_b_bp_p0 and sy_lfr_b_bp_p1
122 // check the consistency between sy_lfr_b_bp_p0 and sy_lfr_b_bp_p1
123 if (flag == LFR_SUCCESSFUL)
123 if (flag == LFR_SUCCESSFUL)
124 {
124 {
125 sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ];
125 sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ];
126 sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ];
126 sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ];
127 aux = ( (float ) sy_lfr_b_bp_p1 / sy_lfr_b_bp_p0 ) - floor(sy_lfr_b_bp_p1 / sy_lfr_b_bp_p0);
127 aux = ( (float ) sy_lfr_b_bp_p1 / sy_lfr_b_bp_p0 ) - floor(sy_lfr_b_bp_p1 / sy_lfr_b_bp_p0);
128 if (aux > FLOAT_EQUAL_ZERO)
128 if (aux > FLOAT_EQUAL_ZERO)
129 {
129 {
130 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_B_BP_P0 + DATAFIELD_OFFSET, sy_lfr_b_bp_p0 );
130 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_B_BP_P0 + DATAFIELD_OFFSET, sy_lfr_b_bp_p0 );
131 flag = LFR_DEFAULT;
131 flag = LFR_DEFAULT;
132 }
132 }
133 }
133 }
134
134
135 // SET THE PARAMETERS
135 // SET THE PARAMETERS
136 if (flag == LFR_SUCCESSFUL)
136 if (flag == LFR_SUCCESSFUL)
137 {
137 {
138 flag = set_sy_lfr_b_bp_p0( TC );
138 flag = set_sy_lfr_b_bp_p0( TC );
139 flag = set_sy_lfr_b_bp_p1( TC );
139 flag = set_sy_lfr_b_bp_p1( TC );
140 }
140 }
141
141
142 return flag;
142 return flag;
143 }
143 }
144
144
145 int action_load_sbm1_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
145 int action_load_sbm1_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
146 {
146 {
147 /** This function updates the LFR registers with the incoming sbm1 parameters.
147 /** This function updates the LFR registers with the incoming sbm1 parameters.
148 *
148 *
149 * @param TC points to the TeleCommand packet that is being processed
149 * @param TC points to the TeleCommand packet that is being processed
150 * @param queue_id is the id of the queue which handles TM related to this execution step
150 * @param queue_id is the id of the queue which handles TM related to this execution step
151 *
151 *
152 */
152 */
153
153
154 int flag;
154 int flag;
155 rtems_status_code status;
155 rtems_status_code status;
156 unsigned char sy_lfr_s1_bp_p0;
156 unsigned char sy_lfr_s1_bp_p0;
157 unsigned char sy_lfr_s1_bp_p1;
157 unsigned char sy_lfr_s1_bp_p1;
158 float aux;
158 float aux;
159
159
160 flag = LFR_SUCCESSFUL;
160 flag = LFR_SUCCESSFUL;
161
161
162 if ( lfrCurrentMode == LFR_MODE_SBM1 ) {
162 if ( lfrCurrentMode == LFR_MODE_SBM1 ) {
163 status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
163 status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
164 flag = LFR_DEFAULT;
164 flag = LFR_DEFAULT;
165 }
165 }
166
166
167 sy_lfr_s1_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P0 ];
167 sy_lfr_s1_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P0 ];
168 sy_lfr_s1_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P1 ];
168 sy_lfr_s1_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P1 ];
169
169
170 // sy_lfr_s1_bp_p0
170 // sy_lfr_s1_bp_p0
171 if (flag == LFR_SUCCESSFUL)
171 if (flag == LFR_SUCCESSFUL)
172 {
172 {
173 if (sy_lfr_s1_bp_p0 < DEFAULT_SY_LFR_S1_BP_P0 )
173 if (sy_lfr_s1_bp_p0 < DEFAULT_SY_LFR_S1_BP_P0 )
174 {
174 {
175 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S1_BP_P0 + DATAFIELD_OFFSET, sy_lfr_s1_bp_p0 );
175 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S1_BP_P0 + DATAFIELD_OFFSET, sy_lfr_s1_bp_p0 );
176 flag = WRONG_APP_DATA;
176 flag = WRONG_APP_DATA;
177 }
177 }
178 }
178 }
179 // sy_lfr_s1_bp_p1
179 // sy_lfr_s1_bp_p1
180 if (flag == LFR_SUCCESSFUL)
180 if (flag == LFR_SUCCESSFUL)
181 {
181 {
182 if (sy_lfr_s1_bp_p1 < DEFAULT_SY_LFR_S1_BP_P1 )
182 if (sy_lfr_s1_bp_p1 < DEFAULT_SY_LFR_S1_BP_P1 )
183 {
183 {
184 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S1_BP_P1 + DATAFIELD_OFFSET, sy_lfr_s1_bp_p1 );
184 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S1_BP_P1 + DATAFIELD_OFFSET, sy_lfr_s1_bp_p1 );
185 flag = WRONG_APP_DATA;
185 flag = WRONG_APP_DATA;
186 }
186 }
187 }
187 }
188 //******************************************************************
188 //******************************************************************
189 // check the consistency between sy_lfr_s1_bp_p0 and sy_lfr_s1_bp_p1
189 // check the consistency between sy_lfr_s1_bp_p0 and sy_lfr_s1_bp_p1
190 if (flag == LFR_SUCCESSFUL)
190 if (flag == LFR_SUCCESSFUL)
191 {
191 {
192 aux = ( (float ) sy_lfr_s1_bp_p1 / (sy_lfr_s1_bp_p0 * S1_BP_P0_SCALE) )
192 aux = ( (float ) sy_lfr_s1_bp_p1 / (sy_lfr_s1_bp_p0 * S1_BP_P0_SCALE) )
193 - floor(sy_lfr_s1_bp_p1 / (sy_lfr_s1_bp_p0 * S1_BP_P0_SCALE));
193 - floor(sy_lfr_s1_bp_p1 / (sy_lfr_s1_bp_p0 * S1_BP_P0_SCALE));
194 if (aux > FLOAT_EQUAL_ZERO)
194 if (aux > FLOAT_EQUAL_ZERO)
195 {
195 {
196 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S1_BP_P0 + DATAFIELD_OFFSET, sy_lfr_s1_bp_p0 );
196 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S1_BP_P0 + DATAFIELD_OFFSET, sy_lfr_s1_bp_p0 );
197 flag = LFR_DEFAULT;
197 flag = LFR_DEFAULT;
198 }
198 }
199 }
199 }
200
200
201 // SET THE PARAMETERS
201 // SET THE PARAMETERS
202 if (flag == LFR_SUCCESSFUL)
202 if (flag == LFR_SUCCESSFUL)
203 {
203 {
204 flag = set_sy_lfr_s1_bp_p0( TC );
204 flag = set_sy_lfr_s1_bp_p0( TC );
205 flag = set_sy_lfr_s1_bp_p1( TC );
205 flag = set_sy_lfr_s1_bp_p1( TC );
206 }
206 }
207
207
208 return flag;
208 return flag;
209 }
209 }
210
210
211 int action_load_sbm2_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
211 int action_load_sbm2_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
212 {
212 {
213 /** This function updates the LFR registers with the incoming sbm2 parameters.
213 /** This function updates the LFR registers with the incoming sbm2 parameters.
214 *
214 *
215 * @param TC points to the TeleCommand packet that is being processed
215 * @param TC points to the TeleCommand packet that is being processed
216 * @param queue_id is the id of the queue which handles TM related to this execution step
216 * @param queue_id is the id of the queue which handles TM related to this execution step
217 *
217 *
218 */
218 */
219
219
220 int flag;
220 int flag;
221 rtems_status_code status;
221 rtems_status_code status;
222 unsigned char sy_lfr_s2_bp_p0;
222 unsigned char sy_lfr_s2_bp_p0;
223 unsigned char sy_lfr_s2_bp_p1;
223 unsigned char sy_lfr_s2_bp_p1;
224 float aux;
224 float aux;
225
225
226 flag = LFR_SUCCESSFUL;
226 flag = LFR_SUCCESSFUL;
227
227
228 if ( lfrCurrentMode == LFR_MODE_SBM2 ) {
228 if ( lfrCurrentMode == LFR_MODE_SBM2 ) {
229 status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
229 status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
230 flag = LFR_DEFAULT;
230 flag = LFR_DEFAULT;
231 }
231 }
232
232
233 sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ];
233 sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ];
234 sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ];
234 sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ];
235
235
236 // sy_lfr_s2_bp_p0
236 // sy_lfr_s2_bp_p0
237 if (flag == LFR_SUCCESSFUL)
237 if (flag == LFR_SUCCESSFUL)
238 {
238 {
239 if (sy_lfr_s2_bp_p0 < DEFAULT_SY_LFR_S2_BP_P0 )
239 if (sy_lfr_s2_bp_p0 < DEFAULT_SY_LFR_S2_BP_P0 )
240 {
240 {
241 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S2_BP_P0 + DATAFIELD_OFFSET, sy_lfr_s2_bp_p0 );
241 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S2_BP_P0 + DATAFIELD_OFFSET, sy_lfr_s2_bp_p0 );
242 flag = WRONG_APP_DATA;
242 flag = WRONG_APP_DATA;
243 }
243 }
244 }
244 }
245 // sy_lfr_s2_bp_p1
245 // sy_lfr_s2_bp_p1
246 if (flag == LFR_SUCCESSFUL)
246 if (flag == LFR_SUCCESSFUL)
247 {
247 {
248 if (sy_lfr_s2_bp_p1 < DEFAULT_SY_LFR_S2_BP_P1 )
248 if (sy_lfr_s2_bp_p1 < DEFAULT_SY_LFR_S2_BP_P1 )
249 {
249 {
250 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S2_BP_P1 + DATAFIELD_OFFSET, sy_lfr_s2_bp_p1 );
250 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S2_BP_P1 + DATAFIELD_OFFSET, sy_lfr_s2_bp_p1 );
251 flag = WRONG_APP_DATA;
251 flag = WRONG_APP_DATA;
252 }
252 }
253 }
253 }
254 //******************************************************************
254 //******************************************************************
255 // check the consistency between sy_lfr_s2_bp_p0 and sy_lfr_s2_bp_p1
255 // check the consistency between sy_lfr_s2_bp_p0 and sy_lfr_s2_bp_p1
256 if (flag == LFR_SUCCESSFUL)
256 if (flag == LFR_SUCCESSFUL)
257 {
257 {
258 sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ];
258 sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ];
259 sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ];
259 sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ];
260 aux = ( (float ) sy_lfr_s2_bp_p1 / sy_lfr_s2_bp_p0 ) - floor(sy_lfr_s2_bp_p1 / sy_lfr_s2_bp_p0);
260 aux = ( (float ) sy_lfr_s2_bp_p1 / sy_lfr_s2_bp_p0 ) - floor(sy_lfr_s2_bp_p1 / sy_lfr_s2_bp_p0);
261 if (aux > FLOAT_EQUAL_ZERO)
261 if (aux > FLOAT_EQUAL_ZERO)
262 {
262 {
263 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S2_BP_P0 + DATAFIELD_OFFSET, sy_lfr_s2_bp_p0 );
263 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S2_BP_P0 + DATAFIELD_OFFSET, sy_lfr_s2_bp_p0 );
264 flag = LFR_DEFAULT;
264 flag = LFR_DEFAULT;
265 }
265 }
266 }
266 }
267
267
268 // SET THE PARAMETERS
268 // SET THE PARAMETERS
269 if (flag == LFR_SUCCESSFUL)
269 if (flag == LFR_SUCCESSFUL)
270 {
270 {
271 flag = set_sy_lfr_s2_bp_p0( TC );
271 flag = set_sy_lfr_s2_bp_p0( TC );
272 flag = set_sy_lfr_s2_bp_p1( TC );
272 flag = set_sy_lfr_s2_bp_p1( TC );
273 }
273 }
274
274
275 return flag;
275 return flag;
276 }
276 }
277
277
278 int action_load_kcoefficients(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
278 int action_load_kcoefficients(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
279 {
279 {
280 /** This function updates the LFR registers with the incoming sbm2 parameters.
280 /** This function updates the LFR registers with the incoming sbm2 parameters.
281 *
281 *
282 * @param TC points to the TeleCommand packet that is being processed
282 * @param TC points to the TeleCommand packet that is being processed
283 * @param queue_id is the id of the queue which handles TM related to this execution step
283 * @param queue_id is the id of the queue which handles TM related to this execution step
284 *
284 *
285 */
285 */
286
286
287 int flag;
287 int flag;
288
288
289 flag = LFR_DEFAULT;
289 flag = LFR_DEFAULT;
290
290
291 flag = set_sy_lfr_kcoeff( TC, queue_id );
291 flag = set_sy_lfr_kcoeff( TC, queue_id );
292
292
293 return flag;
293 return flag;
294 }
294 }
295
295
296 int action_load_fbins_mask(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
296 int action_load_fbins_mask(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
297 {
297 {
298 /** This function updates the LFR registers with the incoming sbm2 parameters.
298 /** This function updates the LFR registers with the incoming sbm2 parameters.
299 *
299 *
300 * @param TC points to the TeleCommand packet that is being processed
300 * @param TC points to the TeleCommand packet that is being processed
301 * @param queue_id is the id of the queue which handles TM related to this execution step
301 * @param queue_id is the id of the queue which handles TM related to this execution step
302 *
302 *
303 */
303 */
304
304
305 int flag;
305 int flag;
306
306
307 flag = LFR_DEFAULT;
307 flag = LFR_DEFAULT;
308
308
309 flag = set_sy_lfr_fbins( TC );
309 flag = set_sy_lfr_fbins( TC );
310
310
311 // once the fbins masks have been stored, they have to be merged with the masks which handle the reaction wheels frequencies filtering
311 // once the fbins masks have been stored, they have to be merged with the masks which handle the reaction wheels frequencies filtering
312 merge_fbins_masks();
312 merge_fbins_masks();
313
313
314 return flag;
314 return flag;
315 }
315 }
316
316
317 int action_load_filter_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
317 int action_load_filter_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
318 {
318 {
319 /** This function updates the LFR registers with the incoming sbm2 parameters.
319 /** This function updates the LFR registers with the incoming sbm2 parameters.
320 *
320 *
321 * @param TC points to the TeleCommand packet that is being processed
321 * @param TC points to the TeleCommand packet that is being processed
322 * @param queue_id is the id of the queue which handles TM related to this execution step
322 * @param queue_id is the id of the queue which handles TM related to this execution step
323 *
323 *
324 */
324 */
325
325
326 int flag;
326 int flag;
327
327
328 flag = LFR_DEFAULT;
328 flag = LFR_DEFAULT;
329
329
330 flag = check_sy_lfr_filter_parameters( TC, queue_id );
330 flag = check_sy_lfr_filter_parameters( TC, queue_id );
331
331
332 if (flag == LFR_SUCCESSFUL)
332 if (flag == LFR_SUCCESSFUL)
333 {
333 {
334 parameter_dump_packet.spare_sy_lfr_pas_filter_enabled = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_ENABLED ];
334 parameter_dump_packet.spare_sy_lfr_pas_filter_enabled = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_ENABLED ];
335 parameter_dump_packet.sy_lfr_pas_filter_modulus = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_MODULUS ];
335 parameter_dump_packet.sy_lfr_pas_filter_modulus = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_MODULUS ];
336 parameter_dump_packet.sy_lfr_pas_filter_tbad[BYTE_0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + BYTE_0 ];
336 parameter_dump_packet.sy_lfr_pas_filter_tbad[BYTE_0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + BYTE_0 ];
337 parameter_dump_packet.sy_lfr_pas_filter_tbad[BYTE_1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + BYTE_1 ];
337 parameter_dump_packet.sy_lfr_pas_filter_tbad[BYTE_1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + BYTE_1 ];
338 parameter_dump_packet.sy_lfr_pas_filter_tbad[BYTE_2] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + BYTE_2 ];
338 parameter_dump_packet.sy_lfr_pas_filter_tbad[BYTE_2] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + BYTE_2 ];
339 parameter_dump_packet.sy_lfr_pas_filter_tbad[BYTE_3] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + BYTE_3 ];
339 parameter_dump_packet.sy_lfr_pas_filter_tbad[BYTE_3] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + BYTE_3 ];
340 parameter_dump_packet.sy_lfr_pas_filter_offset = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_OFFSET ];
340 parameter_dump_packet.sy_lfr_pas_filter_offset = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_OFFSET ];
341 parameter_dump_packet.sy_lfr_pas_filter_shift[BYTE_0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + BYTE_0 ];
341 parameter_dump_packet.sy_lfr_pas_filter_shift[BYTE_0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + BYTE_0 ];
342 parameter_dump_packet.sy_lfr_pas_filter_shift[BYTE_1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + BYTE_1 ];
342 parameter_dump_packet.sy_lfr_pas_filter_shift[BYTE_1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + BYTE_1 ];
343 parameter_dump_packet.sy_lfr_pas_filter_shift[BYTE_2] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + BYTE_2 ];
343 parameter_dump_packet.sy_lfr_pas_filter_shift[BYTE_2] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + BYTE_2 ];
344 parameter_dump_packet.sy_lfr_pas_filter_shift[BYTE_3] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + BYTE_3 ];
344 parameter_dump_packet.sy_lfr_pas_filter_shift[BYTE_3] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + BYTE_3 ];
345 parameter_dump_packet.sy_lfr_sc_rw_delta_f[BYTE_0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + BYTE_0 ];
345 parameter_dump_packet.sy_lfr_sc_rw_delta_f[BYTE_0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + BYTE_0 ];
346 parameter_dump_packet.sy_lfr_sc_rw_delta_f[BYTE_1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + BYTE_1 ];
346 parameter_dump_packet.sy_lfr_sc_rw_delta_f[BYTE_1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + BYTE_1 ];
347 parameter_dump_packet.sy_lfr_sc_rw_delta_f[BYTE_2] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + BYTE_2 ];
347 parameter_dump_packet.sy_lfr_sc_rw_delta_f[BYTE_2] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + BYTE_2 ];
348 parameter_dump_packet.sy_lfr_sc_rw_delta_f[BYTE_3] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + BYTE_3 ];
348 parameter_dump_packet.sy_lfr_sc_rw_delta_f[BYTE_3] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + BYTE_3 ];
349
349
350 //****************************
350 //****************************
351 // store PAS filter parameters
351 // store PAS filter parameters
352 // sy_lfr_pas_filter_enabled
352 // sy_lfr_pas_filter_enabled
353 filterPar.spare_sy_lfr_pas_filter_enabled = parameter_dump_packet.spare_sy_lfr_pas_filter_enabled;
353 filterPar.spare_sy_lfr_pas_filter_enabled = parameter_dump_packet.spare_sy_lfr_pas_filter_enabled;
354 set_sy_lfr_pas_filter_enabled( parameter_dump_packet.spare_sy_lfr_pas_filter_enabled & BIT_PAS_FILTER_ENABLED );
354 set_sy_lfr_pas_filter_enabled( parameter_dump_packet.spare_sy_lfr_pas_filter_enabled & BIT_PAS_FILTER_ENABLED );
355 // sy_lfr_pas_filter_modulus
355 // sy_lfr_pas_filter_modulus
356 filterPar.sy_lfr_pas_filter_modulus = parameter_dump_packet.sy_lfr_pas_filter_modulus;
356 filterPar.sy_lfr_pas_filter_modulus = parameter_dump_packet.sy_lfr_pas_filter_modulus;
357 // sy_lfr_pas_filter_tbad
357 // sy_lfr_pas_filter_tbad
358 copyFloatByChar( (unsigned char*) &filterPar.sy_lfr_pas_filter_tbad,
358 copyFloatByChar( (unsigned char*) &filterPar.sy_lfr_pas_filter_tbad,
359 parameter_dump_packet.sy_lfr_pas_filter_tbad );
359 parameter_dump_packet.sy_lfr_pas_filter_tbad );
360 // sy_lfr_pas_filter_offset
360 // sy_lfr_pas_filter_offset
361 filterPar.sy_lfr_pas_filter_offset = parameter_dump_packet.sy_lfr_pas_filter_offset;
361 filterPar.sy_lfr_pas_filter_offset = parameter_dump_packet.sy_lfr_pas_filter_offset;
362 // sy_lfr_pas_filter_shift
362 // sy_lfr_pas_filter_shift
363 copyFloatByChar( (unsigned char*) &filterPar.sy_lfr_pas_filter_shift,
363 copyFloatByChar( (unsigned char*) &filterPar.sy_lfr_pas_filter_shift,
364 parameter_dump_packet.sy_lfr_pas_filter_shift );
364 parameter_dump_packet.sy_lfr_pas_filter_shift );
365
365
366 //****************************************************
366 //****************************************************
367 // store the parameter sy_lfr_sc_rw_delta_f as a float
367 // store the parameter sy_lfr_sc_rw_delta_f as a float
368 copyFloatByChar( (unsigned char*) &filterPar.sy_lfr_sc_rw_delta_f,
368 copyFloatByChar( (unsigned char*) &filterPar.sy_lfr_sc_rw_delta_f,
369 parameter_dump_packet.sy_lfr_sc_rw_delta_f );
369 parameter_dump_packet.sy_lfr_sc_rw_delta_f );
370 }
370 }
371
371
372 return flag;
372 return flag;
373 }
373 }
374
374
375 int action_dump_kcoefficients(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
375 int action_dump_kcoefficients(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
376 {
376 {
377 /** This function updates the LFR registers with the incoming sbm2 parameters.
377 /** This function updates the LFR registers with the incoming sbm2 parameters.
378 *
378 *
379 * @param TC points to the TeleCommand packet that is being processed
379 * @param TC points to the TeleCommand packet that is being processed
380 * @param queue_id is the id of the queue which handles TM related to this execution step
380 * @param queue_id is the id of the queue which handles TM related to this execution step
381 *
381 *
382 */
382 */
383
383
384 unsigned int address;
384 unsigned int address;
385 rtems_status_code status;
385 rtems_status_code status;
386 unsigned int freq;
386 unsigned int freq;
387 unsigned int bin;
387 unsigned int bin;
388 unsigned int coeff;
388 unsigned int coeff;
389 unsigned char *kCoeffPtr;
389 unsigned char *kCoeffPtr;
390 unsigned char *kCoeffDumpPtr;
390 unsigned char *kCoeffDumpPtr;
391
391
392 // for each sy_lfr_kcoeff_frequency there is 32 kcoeff
392 // for each sy_lfr_kcoeff_frequency there is 32 kcoeff
393 // F0 => 11 bins
393 // F0 => 11 bins
394 // F1 => 13 bins
394 // F1 => 13 bins
395 // F2 => 12 bins
395 // F2 => 12 bins
396 // 36 bins to dump in two packets (30 bins max per packet)
396 // 36 bins to dump in two packets (30 bins max per packet)
397
397
398 //*********
398 //*********
399 // PACKET 1
399 // PACKET 1
400 // 11 F0 bins, 13 F1 bins and 6 F2 bins
400 // 11 F0 bins, 13 F1 bins and 6 F2 bins
401 kcoefficients_dump_1.destinationID = TC->sourceID;
401 kcoefficients_dump_1.destinationID = TC->sourceID;
402 increment_seq_counter_destination_id_dump( kcoefficients_dump_1.packetSequenceControl, TC->sourceID );
402 increment_seq_counter_destination_id_dump( kcoefficients_dump_1.packetSequenceControl, TC->sourceID );
403 for( freq = 0;
403 for( freq = 0;
404 freq < NB_BINS_COMPRESSED_SM_F0;
404 freq < NB_BINS_COMPRESSED_SM_F0;
405 freq++ )
405 freq++ )
406 {
406 {
407 kcoefficients_dump_1.kcoeff_blks[ (freq*KCOEFF_BLK_SIZE) + 1] = freq;
407 kcoefficients_dump_1.kcoeff_blks[ (freq*KCOEFF_BLK_SIZE) + 1] = freq;
408 bin = freq;
408 bin = freq;
409 // printKCoefficients( freq, bin, k_coeff_intercalib_f0_norm);
409 // printKCoefficients( freq, bin, k_coeff_intercalib_f0_norm);
410 for ( coeff=0; coeff<NB_K_COEFF_PER_BIN; coeff++ )
410 for ( coeff=0; coeff<NB_K_COEFF_PER_BIN; coeff++ )
411 {
411 {
412 kCoeffDumpPtr = (unsigned char*) &kcoefficients_dump_1.kcoeff_blks[
412 kCoeffDumpPtr = (unsigned char*) &kcoefficients_dump_1.kcoeff_blks[
413 (freq*KCOEFF_BLK_SIZE) + (coeff*NB_BYTES_PER_FLOAT) + KCOEFF_FREQ
413 (freq*KCOEFF_BLK_SIZE) + (coeff*NB_BYTES_PER_FLOAT) + KCOEFF_FREQ
414 ]; // 2 for the kcoeff_frequency
414 ]; // 2 for the kcoeff_frequency
415 kCoeffPtr = (unsigned char*) &k_coeff_intercalib_f0_norm[ (bin*NB_K_COEFF_PER_BIN) + coeff ];
415 kCoeffPtr = (unsigned char*) &k_coeff_intercalib_f0_norm[ (bin*NB_K_COEFF_PER_BIN) + coeff ];
416 copyFloatByChar( kCoeffDumpPtr, kCoeffPtr );
416 copyFloatByChar( kCoeffDumpPtr, kCoeffPtr );
417 }
417 }
418 }
418 }
419 for( freq = NB_BINS_COMPRESSED_SM_F0;
419 for( freq = NB_BINS_COMPRESSED_SM_F0;
420 freq < ( NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1 );
420 freq < ( NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1 );
421 freq++ )
421 freq++ )
422 {
422 {
423 kcoefficients_dump_1.kcoeff_blks[ (freq*KCOEFF_BLK_SIZE) + 1 ] = freq;
423 kcoefficients_dump_1.kcoeff_blks[ (freq*KCOEFF_BLK_SIZE) + 1 ] = freq;
424 bin = freq - NB_BINS_COMPRESSED_SM_F0;
424 bin = freq - NB_BINS_COMPRESSED_SM_F0;
425 // printKCoefficients( freq, bin, k_coeff_intercalib_f1_norm);
425 // printKCoefficients( freq, bin, k_coeff_intercalib_f1_norm);
426 for ( coeff=0; coeff<NB_K_COEFF_PER_BIN; coeff++ )
426 for ( coeff=0; coeff<NB_K_COEFF_PER_BIN; coeff++ )
427 {
427 {
428 kCoeffDumpPtr = (unsigned char*) &kcoefficients_dump_1.kcoeff_blks[
428 kCoeffDumpPtr = (unsigned char*) &kcoefficients_dump_1.kcoeff_blks[
429 (freq*KCOEFF_BLK_SIZE) + (coeff*NB_BYTES_PER_FLOAT) + KCOEFF_FREQ
429 (freq*KCOEFF_BLK_SIZE) + (coeff*NB_BYTES_PER_FLOAT) + KCOEFF_FREQ
430 ]; // 2 for the kcoeff_frequency
430 ]; // 2 for the kcoeff_frequency
431 kCoeffPtr = (unsigned char*) &k_coeff_intercalib_f1_norm[ (bin*NB_K_COEFF_PER_BIN) + coeff ];
431 kCoeffPtr = (unsigned char*) &k_coeff_intercalib_f1_norm[ (bin*NB_K_COEFF_PER_BIN) + coeff ];
432 copyFloatByChar( kCoeffDumpPtr, kCoeffPtr );
432 copyFloatByChar( kCoeffDumpPtr, kCoeffPtr );
433 }
433 }
434 }
434 }
435 for( freq = ( NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1 );
435 for( freq = ( NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1 );
436 freq < KCOEFF_BLK_NR_PKT1 ;
436 freq < KCOEFF_BLK_NR_PKT1 ;
437 freq++ )
437 freq++ )
438 {
438 {
439 kcoefficients_dump_1.kcoeff_blks[ (freq * KCOEFF_BLK_SIZE) + 1 ] = freq;
439 kcoefficients_dump_1.kcoeff_blks[ (freq * KCOEFF_BLK_SIZE) + 1 ] = freq;
440 bin = freq - (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1);
440 bin = freq - (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1);
441 // printKCoefficients( freq, bin, k_coeff_intercalib_f2);
441 // printKCoefficients( freq, bin, k_coeff_intercalib_f2);
442 for ( coeff = 0; coeff <NB_K_COEFF_PER_BIN; coeff++ )
442 for ( coeff = 0; coeff <NB_K_COEFF_PER_BIN; coeff++ )
443 {
443 {
444 kCoeffDumpPtr = (unsigned char*) &kcoefficients_dump_1.kcoeff_blks[
444 kCoeffDumpPtr = (unsigned char*) &kcoefficients_dump_1.kcoeff_blks[
445 (freq * KCOEFF_BLK_SIZE) + (coeff * NB_BYTES_PER_FLOAT) + KCOEFF_FREQ
445 (freq * KCOEFF_BLK_SIZE) + (coeff * NB_BYTES_PER_FLOAT) + KCOEFF_FREQ
446 ]; // 2 for the kcoeff_frequency
446 ]; // 2 for the kcoeff_frequency
447 kCoeffPtr = (unsigned char*) &k_coeff_intercalib_f2[ (bin*NB_K_COEFF_PER_BIN) + coeff ];
447 kCoeffPtr = (unsigned char*) &k_coeff_intercalib_f2[ (bin*NB_K_COEFF_PER_BIN) + coeff ];
448 copyFloatByChar( kCoeffDumpPtr, kCoeffPtr );
448 copyFloatByChar( kCoeffDumpPtr, kCoeffPtr );
449 }
449 }
450 }
450 }
451 kcoefficients_dump_1.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
451 kcoefficients_dump_1.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
452 kcoefficients_dump_1.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
452 kcoefficients_dump_1.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
453 kcoefficients_dump_1.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
453 kcoefficients_dump_1.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
454 kcoefficients_dump_1.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
454 kcoefficients_dump_1.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
455 kcoefficients_dump_1.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
455 kcoefficients_dump_1.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
456 kcoefficients_dump_1.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
456 kcoefficients_dump_1.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
457 // SEND DATA
457 // SEND DATA
458 kcoefficient_node_1.status = 1;
458 kcoefficient_node_1.status = 1;
459 address = (unsigned int) &kcoefficient_node_1;
459 address = (unsigned int) &kcoefficient_node_1;
460 status = rtems_message_queue_send( queue_id, &address, sizeof( ring_node* ) );
460 status = rtems_message_queue_send( queue_id, &address, sizeof( ring_node* ) );
461 if (status != RTEMS_SUCCESSFUL) {
461 if (status != RTEMS_SUCCESSFUL) {
462 PRINTF1("in action_dump_kcoefficients *** ERR sending packet 1 , code %d", status)
462 PRINTF1("in action_dump_kcoefficients *** ERR sending packet 1 , code %d", status)
463 }
463 }
464
464
465 //********
465 //********
466 // PACKET 2
466 // PACKET 2
467 // 6 F2 bins
467 // 6 F2 bins
468 kcoefficients_dump_2.destinationID = TC->sourceID;
468 kcoefficients_dump_2.destinationID = TC->sourceID;
469 increment_seq_counter_destination_id_dump( kcoefficients_dump_2.packetSequenceControl, TC->sourceID );
469 increment_seq_counter_destination_id_dump( kcoefficients_dump_2.packetSequenceControl, TC->sourceID );
470 for( freq = 0;
470 for( freq = 0;
471 freq < KCOEFF_BLK_NR_PKT2;
471 freq < KCOEFF_BLK_NR_PKT2;
472 freq++ )
472 freq++ )
473 {
473 {
474 kcoefficients_dump_2.kcoeff_blks[ (freq*KCOEFF_BLK_SIZE) + 1 ] = KCOEFF_BLK_NR_PKT1 + freq;
474 kcoefficients_dump_2.kcoeff_blks[ (freq*KCOEFF_BLK_SIZE) + 1 ] = KCOEFF_BLK_NR_PKT1 + freq;
475 bin = freq + KCOEFF_BLK_NR_PKT2;
475 bin = freq + KCOEFF_BLK_NR_PKT2;
476 // printKCoefficients( freq, bin, k_coeff_intercalib_f2);
476 // printKCoefficients( freq, bin, k_coeff_intercalib_f2);
477 for ( coeff=0; coeff<NB_K_COEFF_PER_BIN; coeff++ )
477 for ( coeff=0; coeff<NB_K_COEFF_PER_BIN; coeff++ )
478 {
478 {
479 kCoeffDumpPtr = (unsigned char*) &kcoefficients_dump_2.kcoeff_blks[
479 kCoeffDumpPtr = (unsigned char*) &kcoefficients_dump_2.kcoeff_blks[
480 (freq*KCOEFF_BLK_SIZE) + (coeff*NB_BYTES_PER_FLOAT) + KCOEFF_FREQ ]; // 2 for the kcoeff_frequency
480 (freq*KCOEFF_BLK_SIZE) + (coeff*NB_BYTES_PER_FLOAT) + KCOEFF_FREQ ]; // 2 for the kcoeff_frequency
481 kCoeffPtr = (unsigned char*) &k_coeff_intercalib_f2[ (bin*NB_K_COEFF_PER_BIN) + coeff ];
481 kCoeffPtr = (unsigned char*) &k_coeff_intercalib_f2[ (bin*NB_K_COEFF_PER_BIN) + coeff ];
482 copyFloatByChar( kCoeffDumpPtr, kCoeffPtr );
482 copyFloatByChar( kCoeffDumpPtr, kCoeffPtr );
483 }
483 }
484 }
484 }
485 kcoefficients_dump_2.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
485 kcoefficients_dump_2.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
486 kcoefficients_dump_2.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
486 kcoefficients_dump_2.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
487 kcoefficients_dump_2.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
487 kcoefficients_dump_2.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
488 kcoefficients_dump_2.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
488 kcoefficients_dump_2.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
489 kcoefficients_dump_2.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
489 kcoefficients_dump_2.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
490 kcoefficients_dump_2.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
490 kcoefficients_dump_2.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
491 // SEND DATA
491 // SEND DATA
492 kcoefficient_node_2.status = 1;
492 kcoefficient_node_2.status = 1;
493 address = (unsigned int) &kcoefficient_node_2;
493 address = (unsigned int) &kcoefficient_node_2;
494 status = rtems_message_queue_send( queue_id, &address, sizeof( ring_node* ) );
494 status = rtems_message_queue_send( queue_id, &address, sizeof( ring_node* ) );
495 if (status != RTEMS_SUCCESSFUL) {
495 if (status != RTEMS_SUCCESSFUL) {
496 PRINTF1("in action_dump_kcoefficients *** ERR sending packet 2, code %d", status)
496 PRINTF1("in action_dump_kcoefficients *** ERR sending packet 2, code %d", status)
497 }
497 }
498
498
499 return status;
499 return status;
500 }
500 }
501
501
502 int action_dump_par( ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
502 int action_dump_par( ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
503 {
503 {
504 /** This function dumps the LFR parameters by sending the appropriate TM packet to the dedicated RTEMS message queue.
504 /** This function dumps the LFR parameters by sending the appropriate TM packet to the dedicated RTEMS message queue.
505 *
505 *
506 * @param queue_id is the id of the queue which handles TM related to this execution step.
506 * @param queue_id is the id of the queue which handles TM related to this execution step.
507 *
507 *
508 * @return RTEMS directive status codes:
508 * @return RTEMS directive status codes:
509 * - RTEMS_SUCCESSFUL - message sent successfully
509 * - RTEMS_SUCCESSFUL - message sent successfully
510 * - RTEMS_INVALID_ID - invalid queue id
510 * - RTEMS_INVALID_ID - invalid queue id
511 * - RTEMS_INVALID_SIZE - invalid message size
511 * - RTEMS_INVALID_SIZE - invalid message size
512 * - RTEMS_INVALID_ADDRESS - buffer is NULL
512 * - RTEMS_INVALID_ADDRESS - buffer is NULL
513 * - RTEMS_UNSATISFIED - out of message buffers
513 * - RTEMS_UNSATISFIED - out of message buffers
514 * - RTEMS_TOO_MANY - queue s limit has been reached
514 * - RTEMS_TOO_MANY - queue s limit has been reached
515 *
515 *
516 */
516 */
517
517
518 int status;
518 int status;
519
519
520 increment_seq_counter_destination_id_dump( parameter_dump_packet.packetSequenceControl, TC->sourceID );
520 increment_seq_counter_destination_id_dump( parameter_dump_packet.packetSequenceControl, TC->sourceID );
521 parameter_dump_packet.destinationID = TC->sourceID;
521 parameter_dump_packet.destinationID = TC->sourceID;
522
522
523 // UPDATE TIME
523 // UPDATE TIME
524 parameter_dump_packet.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
524 parameter_dump_packet.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
525 parameter_dump_packet.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
525 parameter_dump_packet.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
526 parameter_dump_packet.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
526 parameter_dump_packet.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
527 parameter_dump_packet.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
527 parameter_dump_packet.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
528 parameter_dump_packet.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
528 parameter_dump_packet.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
529 parameter_dump_packet.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
529 parameter_dump_packet.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
530 // SEND DATA
530 // SEND DATA
531 status = rtems_message_queue_send( queue_id, &parameter_dump_packet,
531 status = rtems_message_queue_send( queue_id, &parameter_dump_packet,
532 PACKET_LENGTH_PARAMETER_DUMP + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES);
532 PACKET_LENGTH_PARAMETER_DUMP + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES);
533 if (status != RTEMS_SUCCESSFUL) {
533 if (status != RTEMS_SUCCESSFUL) {
534 PRINTF1("in action_dump *** ERR sending packet, code %d", status)
534 PRINTF1("in action_dump *** ERR sending packet, code %d", status)
535 }
535 }
536
536
537 return status;
537 return status;
538 }
538 }
539
539
540 //***********************
540 //***********************
541 // NORMAL MODE PARAMETERS
541 // NORMAL MODE PARAMETERS
542
542
543 int check_normal_par_consistency( ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
543 int check_normal_par_consistency( ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
544 {
544 {
545 unsigned char msb;
545 unsigned char msb;
546 unsigned char lsb;
546 unsigned char lsb;
547 int flag;
547 int flag;
548 float aux;
548 float aux;
549 rtems_status_code status;
549 rtems_status_code status;
550
550
551 unsigned int sy_lfr_n_swf_l;
551 unsigned int sy_lfr_n_swf_l;
552 unsigned int sy_lfr_n_swf_p;
552 unsigned int sy_lfr_n_swf_p;
553 unsigned int sy_lfr_n_asm_p;
553 unsigned int sy_lfr_n_asm_p;
554 unsigned char sy_lfr_n_bp_p0;
554 unsigned char sy_lfr_n_bp_p0;
555 unsigned char sy_lfr_n_bp_p1;
555 unsigned char sy_lfr_n_bp_p1;
556 unsigned char sy_lfr_n_cwf_long_f3;
556 unsigned char sy_lfr_n_cwf_long_f3;
557
557
558 flag = LFR_SUCCESSFUL;
558 flag = LFR_SUCCESSFUL;
559
559
560 //***************
560 //***************
561 // get parameters
561 // get parameters
562 msb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L ];
562 msb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L ];
563 lsb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L+1 ];
563 lsb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L+1 ];
564 sy_lfr_n_swf_l = (msb * CONST_256) + lsb;
564 sy_lfr_n_swf_l = (msb * CONST_256) + lsb;
565
565
566 msb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P ];
566 msb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P ];
567 lsb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P+1 ];
567 lsb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P+1 ];
568 sy_lfr_n_swf_p = (msb * CONST_256) + lsb;
568 sy_lfr_n_swf_p = (msb * CONST_256) + lsb;
569
569
570 msb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P ];
570 msb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P ];
571 lsb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P+1 ];
571 lsb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P+1 ];
572 sy_lfr_n_asm_p = (msb * CONST_256) + lsb;
572 sy_lfr_n_asm_p = (msb * CONST_256) + lsb;
573
573
574 sy_lfr_n_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P0 ];
574 sy_lfr_n_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P0 ];
575
575
576 sy_lfr_n_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P1 ];
576 sy_lfr_n_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P1 ];
577
577
578 sy_lfr_n_cwf_long_f3 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_CWF_LONG_F3 ];
578 sy_lfr_n_cwf_long_f3 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_CWF_LONG_F3 ];
579
579
580 //******************
580 //******************
581 // check consistency
581 // check consistency
582 // sy_lfr_n_swf_l
582 // sy_lfr_n_swf_l
583 if (sy_lfr_n_swf_l != DFLT_SY_LFR_N_SWF_L)
583 if (sy_lfr_n_swf_l != DFLT_SY_LFR_N_SWF_L)
584 {
584 {
585 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_SWF_L + DATAFIELD_OFFSET, sy_lfr_n_swf_l );
585 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_SWF_L + DATAFIELD_OFFSET, sy_lfr_n_swf_l );
586 flag = WRONG_APP_DATA;
586 flag = WRONG_APP_DATA;
587 }
587 }
588 // sy_lfr_n_swf_p
588 // sy_lfr_n_swf_p
589 if (flag == LFR_SUCCESSFUL)
589 if (flag == LFR_SUCCESSFUL)
590 {
590 {
591 if ( sy_lfr_n_swf_p < MIN_SY_LFR_N_SWF_P )
591 if ( sy_lfr_n_swf_p < MIN_SY_LFR_N_SWF_P )
592 {
592 {
593 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_SWF_P + DATAFIELD_OFFSET, sy_lfr_n_swf_p );
593 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_SWF_P + DATAFIELD_OFFSET, sy_lfr_n_swf_p );
594 flag = WRONG_APP_DATA;
594 flag = WRONG_APP_DATA;
595 }
595 }
596 }
596 }
597 // sy_lfr_n_bp_p0
597 // sy_lfr_n_bp_p0
598 if (flag == LFR_SUCCESSFUL)
598 if (flag == LFR_SUCCESSFUL)
599 {
599 {
600 if (sy_lfr_n_bp_p0 < DFLT_SY_LFR_N_BP_P0)
600 if (sy_lfr_n_bp_p0 < DFLT_SY_LFR_N_BP_P0)
601 {
601 {
602 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_BP_P0 + DATAFIELD_OFFSET, sy_lfr_n_bp_p0 );
602 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_BP_P0 + DATAFIELD_OFFSET, sy_lfr_n_bp_p0 );
603 flag = WRONG_APP_DATA;
603 flag = WRONG_APP_DATA;
604 }
604 }
605 }
605 }
606 // sy_lfr_n_asm_p
606 // sy_lfr_n_asm_p
607 if (flag == LFR_SUCCESSFUL)
607 if (flag == LFR_SUCCESSFUL)
608 {
608 {
609 if (sy_lfr_n_asm_p == 0)
609 if (sy_lfr_n_asm_p == 0)
610 {
610 {
611 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_ASM_P + DATAFIELD_OFFSET, sy_lfr_n_asm_p );
611 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_ASM_P + DATAFIELD_OFFSET, sy_lfr_n_asm_p );
612 flag = WRONG_APP_DATA;
612 flag = WRONG_APP_DATA;
613 }
613 }
614 }
614 }
615 // sy_lfr_n_asm_p shall be a whole multiple of sy_lfr_n_bp_p0
615 // sy_lfr_n_asm_p shall be a whole multiple of sy_lfr_n_bp_p0
616 if (flag == LFR_SUCCESSFUL)
616 if (flag == LFR_SUCCESSFUL)
617 {
617 {
618 aux = ( (float ) sy_lfr_n_asm_p / sy_lfr_n_bp_p0 ) - floor(sy_lfr_n_asm_p / sy_lfr_n_bp_p0);
618 aux = ( (float ) sy_lfr_n_asm_p / sy_lfr_n_bp_p0 ) - floor(sy_lfr_n_asm_p / sy_lfr_n_bp_p0);
619 if (aux > FLOAT_EQUAL_ZERO)
619 if (aux > FLOAT_EQUAL_ZERO)
620 {
620 {
621 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_ASM_P + DATAFIELD_OFFSET, sy_lfr_n_asm_p );
621 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_ASM_P + DATAFIELD_OFFSET, sy_lfr_n_asm_p );
622 flag = WRONG_APP_DATA;
622 flag = WRONG_APP_DATA;
623 }
623 }
624 }
624 }
625 // sy_lfr_n_bp_p1
625 // sy_lfr_n_bp_p1
626 if (flag == LFR_SUCCESSFUL)
626 if (flag == LFR_SUCCESSFUL)
627 {
627 {
628 if (sy_lfr_n_bp_p1 < DFLT_SY_LFR_N_BP_P1)
628 if (sy_lfr_n_bp_p1 < DFLT_SY_LFR_N_BP_P1)
629 {
629 {
630 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_BP_P1 + DATAFIELD_OFFSET, sy_lfr_n_bp_p1 );
630 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_BP_P1 + DATAFIELD_OFFSET, sy_lfr_n_bp_p1 );
631 flag = WRONG_APP_DATA;
631 flag = WRONG_APP_DATA;
632 }
632 }
633 }
633 }
634 // sy_lfr_n_bp_p1 shall be a whole multiple of sy_lfr_n_bp_p0
634 // sy_lfr_n_bp_p1 shall be a whole multiple of sy_lfr_n_bp_p0
635 if (flag == LFR_SUCCESSFUL)
635 if (flag == LFR_SUCCESSFUL)
636 {
636 {
637 aux = ( (float ) sy_lfr_n_bp_p1 / sy_lfr_n_bp_p0 ) - floor(sy_lfr_n_bp_p1 / sy_lfr_n_bp_p0);
637 aux = ( (float ) sy_lfr_n_bp_p1 / sy_lfr_n_bp_p0 ) - floor(sy_lfr_n_bp_p1 / sy_lfr_n_bp_p0);
638 if (aux > FLOAT_EQUAL_ZERO)
638 if (aux > FLOAT_EQUAL_ZERO)
639 {
639 {
640 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_BP_P1 + DATAFIELD_OFFSET, sy_lfr_n_bp_p1 );
640 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_BP_P1 + DATAFIELD_OFFSET, sy_lfr_n_bp_p1 );
641 flag = LFR_DEFAULT;
641 flag = LFR_DEFAULT;
642 }
642 }
643 }
643 }
644 // sy_lfr_n_cwf_long_f3
644 // sy_lfr_n_cwf_long_f3
645
645
646 return flag;
646 return flag;
647 }
647 }
648
648
649 int set_sy_lfr_n_swf_l( ccsdsTelecommandPacket_t *TC )
649 int set_sy_lfr_n_swf_l( ccsdsTelecommandPacket_t *TC )
650 {
650 {
651 /** This function sets the number of points of a snapshot (sy_lfr_n_swf_l).
651 /** This function sets the number of points of a snapshot (sy_lfr_n_swf_l).
652 *
652 *
653 * @param TC points to the TeleCommand packet that is being processed
653 * @param TC points to the TeleCommand packet that is being processed
654 * @param queue_id is the id of the queue which handles TM related to this execution step
654 * @param queue_id is the id of the queue which handles TM related to this execution step
655 *
655 *
656 */
656 */
657
657
658 int result;
658 int result;
659
659
660 result = LFR_SUCCESSFUL;
660 result = LFR_SUCCESSFUL;
661
661
662 parameter_dump_packet.sy_lfr_n_swf_l[0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L ];
662 parameter_dump_packet.sy_lfr_n_swf_l[0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L ];
663 parameter_dump_packet.sy_lfr_n_swf_l[1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L+1 ];
663 parameter_dump_packet.sy_lfr_n_swf_l[1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L+1 ];
664
664
665 return result;
665 return result;
666 }
666 }
667
667
668 int set_sy_lfr_n_swf_p(ccsdsTelecommandPacket_t *TC )
668 int set_sy_lfr_n_swf_p(ccsdsTelecommandPacket_t *TC )
669 {
669 {
670 /** This function sets the time between two snapshots, in s (sy_lfr_n_swf_p).
670 /** This function sets the time between two snapshots, in s (sy_lfr_n_swf_p).
671 *
671 *
672 * @param TC points to the TeleCommand packet that is being processed
672 * @param TC points to the TeleCommand packet that is being processed
673 * @param queue_id is the id of the queue which handles TM related to this execution step
673 * @param queue_id is the id of the queue which handles TM related to this execution step
674 *
674 *
675 */
675 */
676
676
677 int result;
677 int result;
678
678
679 result = LFR_SUCCESSFUL;
679 result = LFR_SUCCESSFUL;
680
680
681 parameter_dump_packet.sy_lfr_n_swf_p[0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P ];
681 parameter_dump_packet.sy_lfr_n_swf_p[0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P ];
682 parameter_dump_packet.sy_lfr_n_swf_p[1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P+1 ];
682 parameter_dump_packet.sy_lfr_n_swf_p[1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P+1 ];
683
683
684 return result;
684 return result;
685 }
685 }
686
686
687 int set_sy_lfr_n_asm_p( ccsdsTelecommandPacket_t *TC )
687 int set_sy_lfr_n_asm_p( ccsdsTelecommandPacket_t *TC )
688 {
688 {
689 /** This function sets the time between two full spectral matrices transmission, in s (SY_LFR_N_ASM_P).
689 /** This function sets the time between two full spectral matrices transmission, in s (SY_LFR_N_ASM_P).
690 *
690 *
691 * @param TC points to the TeleCommand packet that is being processed
691 * @param TC points to the TeleCommand packet that is being processed
692 * @param queue_id is the id of the queue which handles TM related to this execution step
692 * @param queue_id is the id of the queue which handles TM related to this execution step
693 *
693 *
694 */
694 */
695
695
696 int result;
696 int result;
697
697
698 result = LFR_SUCCESSFUL;
698 result = LFR_SUCCESSFUL;
699
699
700 parameter_dump_packet.sy_lfr_n_asm_p[0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P ];
700 parameter_dump_packet.sy_lfr_n_asm_p[0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P ];
701 parameter_dump_packet.sy_lfr_n_asm_p[1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P+1 ];
701 parameter_dump_packet.sy_lfr_n_asm_p[1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P+1 ];
702
702
703 return result;
703 return result;
704 }
704 }
705
705
706 int set_sy_lfr_n_bp_p0( ccsdsTelecommandPacket_t *TC )
706 int set_sy_lfr_n_bp_p0( ccsdsTelecommandPacket_t *TC )
707 {
707 {
708 /** This function sets the time between two basic parameter sets, in s (DFLT_SY_LFR_N_BP_P0).
708 /** This function sets the time between two basic parameter sets, in s (DFLT_SY_LFR_N_BP_P0).
709 *
709 *
710 * @param TC points to the TeleCommand packet that is being processed
710 * @param TC points to the TeleCommand packet that is being processed
711 * @param queue_id is the id of the queue which handles TM related to this execution step
711 * @param queue_id is the id of the queue which handles TM related to this execution step
712 *
712 *
713 */
713 */
714
714
715 int status;
715 int status;
716
716
717 status = LFR_SUCCESSFUL;
717 status = LFR_SUCCESSFUL;
718
718
719 parameter_dump_packet.sy_lfr_n_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P0 ];
719 parameter_dump_packet.sy_lfr_n_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P0 ];
720
720
721 return status;
721 return status;
722 }
722 }
723
723
724 int set_sy_lfr_n_bp_p1(ccsdsTelecommandPacket_t *TC )
724 int set_sy_lfr_n_bp_p1(ccsdsTelecommandPacket_t *TC )
725 {
725 {
726 /** This function sets the time between two basic parameter sets (autocorrelation + crosscorrelation), in s (sy_lfr_n_bp_p1).
726 /** This function sets the time between two basic parameter sets (autocorrelation + crosscorrelation), in s (sy_lfr_n_bp_p1).
727 *
727 *
728 * @param TC points to the TeleCommand packet that is being processed
728 * @param TC points to the TeleCommand packet that is being processed
729 * @param queue_id is the id of the queue which handles TM related to this execution step
729 * @param queue_id is the id of the queue which handles TM related to this execution step
730 *
730 *
731 */
731 */
732
732
733 int status;
733 int status;
734
734
735 status = LFR_SUCCESSFUL;
735 status = LFR_SUCCESSFUL;
736
736
737 parameter_dump_packet.sy_lfr_n_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P1 ];
737 parameter_dump_packet.sy_lfr_n_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P1 ];
738
738
739 return status;
739 return status;
740 }
740 }
741
741
742 int set_sy_lfr_n_cwf_long_f3(ccsdsTelecommandPacket_t *TC )
742 int set_sy_lfr_n_cwf_long_f3(ccsdsTelecommandPacket_t *TC )
743 {
743 {
744 /** This function allows to switch from CWF_F3 packets to CWF_LONG_F3 packets.
744 /** This function allows to switch from CWF_F3 packets to CWF_LONG_F3 packets.
745 *
745 *
746 * @param TC points to the TeleCommand packet that is being processed
746 * @param TC points to the TeleCommand packet that is being processed
747 * @param queue_id is the id of the queue which handles TM related to this execution step
747 * @param queue_id is the id of the queue which handles TM related to this execution step
748 *
748 *
749 */
749 */
750
750
751 int status;
751 int status;
752
752
753 status = LFR_SUCCESSFUL;
753 status = LFR_SUCCESSFUL;
754
754
755 parameter_dump_packet.sy_lfr_n_cwf_long_f3 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_CWF_LONG_F3 ];
755 parameter_dump_packet.sy_lfr_n_cwf_long_f3 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_CWF_LONG_F3 ];
756
756
757 return status;
757 return status;
758 }
758 }
759
759
760 //**********************
760 //**********************
761 // BURST MODE PARAMETERS
761 // BURST MODE PARAMETERS
762 int set_sy_lfr_b_bp_p0(ccsdsTelecommandPacket_t *TC)
762 int set_sy_lfr_b_bp_p0(ccsdsTelecommandPacket_t *TC)
763 {
763 {
764 /** This function sets the time between two basic parameter sets, in s (SY_LFR_B_BP_P0).
764 /** This function sets the time between two basic parameter sets, in s (SY_LFR_B_BP_P0).
765 *
765 *
766 * @param TC points to the TeleCommand packet that is being processed
766 * @param TC points to the TeleCommand packet that is being processed
767 * @param queue_id is the id of the queue which handles TM related to this execution step
767 * @param queue_id is the id of the queue which handles TM related to this execution step
768 *
768 *
769 */
769 */
770
770
771 int status;
771 int status;
772
772
773 status = LFR_SUCCESSFUL;
773 status = LFR_SUCCESSFUL;
774
774
775 parameter_dump_packet.sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ];
775 parameter_dump_packet.sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ];
776
776
777 return status;
777 return status;
778 }
778 }
779
779
780 int set_sy_lfr_b_bp_p1( ccsdsTelecommandPacket_t *TC )
780 int set_sy_lfr_b_bp_p1( ccsdsTelecommandPacket_t *TC )
781 {
781 {
782 /** This function sets the time between two basic parameter sets, in s (SY_LFR_B_BP_P1).
782 /** This function sets the time between two basic parameter sets, in s (SY_LFR_B_BP_P1).
783 *
783 *
784 * @param TC points to the TeleCommand packet that is being processed
784 * @param TC points to the TeleCommand packet that is being processed
785 * @param queue_id is the id of the queue which handles TM related to this execution step
785 * @param queue_id is the id of the queue which handles TM related to this execution step
786 *
786 *
787 */
787 */
788
788
789 int status;
789 int status;
790
790
791 status = LFR_SUCCESSFUL;
791 status = LFR_SUCCESSFUL;
792
792
793 parameter_dump_packet.sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ];
793 parameter_dump_packet.sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ];
794
794
795 return status;
795 return status;
796 }
796 }
797
797
798 //*********************
798 //*********************
799 // SBM1 MODE PARAMETERS
799 // SBM1 MODE PARAMETERS
800 int set_sy_lfr_s1_bp_p0( ccsdsTelecommandPacket_t *TC )
800 int set_sy_lfr_s1_bp_p0( ccsdsTelecommandPacket_t *TC )
801 {
801 {
802 /** This function sets the time between two basic parameter sets, in s (SY_LFR_S1_BP_P0).
802 /** This function sets the time between two basic parameter sets, in s (SY_LFR_S1_BP_P0).
803 *
803 *
804 * @param TC points to the TeleCommand packet that is being processed
804 * @param TC points to the TeleCommand packet that is being processed
805 * @param queue_id is the id of the queue which handles TM related to this execution step
805 * @param queue_id is the id of the queue which handles TM related to this execution step
806 *
806 *
807 */
807 */
808
808
809 int status;
809 int status;
810
810
811 status = LFR_SUCCESSFUL;
811 status = LFR_SUCCESSFUL;
812
812
813 parameter_dump_packet.sy_lfr_s1_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P0 ];
813 parameter_dump_packet.sy_lfr_s1_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P0 ];
814
814
815 return status;
815 return status;
816 }
816 }
817
817
818 int set_sy_lfr_s1_bp_p1( ccsdsTelecommandPacket_t *TC )
818 int set_sy_lfr_s1_bp_p1( ccsdsTelecommandPacket_t *TC )
819 {
819 {
820 /** This function sets the time between two basic parameter sets, in s (SY_LFR_S1_BP_P1).
820 /** This function sets the time between two basic parameter sets, in s (SY_LFR_S1_BP_P1).
821 *
821 *
822 * @param TC points to the TeleCommand packet that is being processed
822 * @param TC points to the TeleCommand packet that is being processed
823 * @param queue_id is the id of the queue which handles TM related to this execution step
823 * @param queue_id is the id of the queue which handles TM related to this execution step
824 *
824 *
825 */
825 */
826
826
827 int status;
827 int status;
828
828
829 status = LFR_SUCCESSFUL;
829 status = LFR_SUCCESSFUL;
830
830
831 parameter_dump_packet.sy_lfr_s1_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P1 ];
831 parameter_dump_packet.sy_lfr_s1_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P1 ];
832
832
833 return status;
833 return status;
834 }
834 }
835
835
836 //*********************
836 //*********************
837 // SBM2 MODE PARAMETERS
837 // SBM2 MODE PARAMETERS
838 int set_sy_lfr_s2_bp_p0( ccsdsTelecommandPacket_t *TC )
838 int set_sy_lfr_s2_bp_p0( ccsdsTelecommandPacket_t *TC )
839 {
839 {
840 /** This function sets the time between two basic parameter sets, in s (SY_LFR_S2_BP_P0).
840 /** This function sets the time between two basic parameter sets, in s (SY_LFR_S2_BP_P0).
841 *
841 *
842 * @param TC points to the TeleCommand packet that is being processed
842 * @param TC points to the TeleCommand packet that is being processed
843 * @param queue_id is the id of the queue which handles TM related to this execution step
843 * @param queue_id is the id of the queue which handles TM related to this execution step
844 *
844 *
845 */
845 */
846
846
847 int status;
847 int status;
848
848
849 status = LFR_SUCCESSFUL;
849 status = LFR_SUCCESSFUL;
850
850
851 parameter_dump_packet.sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ];
851 parameter_dump_packet.sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ];
852
852
853 return status;
853 return status;
854 }
854 }
855
855
856 int set_sy_lfr_s2_bp_p1( ccsdsTelecommandPacket_t *TC )
856 int set_sy_lfr_s2_bp_p1( ccsdsTelecommandPacket_t *TC )
857 {
857 {
858 /** This function sets the time between two basic parameter sets, in s (SY_LFR_S2_BP_P1).
858 /** This function sets the time between two basic parameter sets, in s (SY_LFR_S2_BP_P1).
859 *
859 *
860 * @param TC points to the TeleCommand packet that is being processed
860 * @param TC points to the TeleCommand packet that is being processed
861 * @param queue_id is the id of the queue which handles TM related to this execution step
861 * @param queue_id is the id of the queue which handles TM related to this execution step
862 *
862 *
863 */
863 */
864
864
865 int status;
865 int status;
866
866
867 status = LFR_SUCCESSFUL;
867 status = LFR_SUCCESSFUL;
868
868
869 parameter_dump_packet.sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ];
869 parameter_dump_packet.sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ];
870
870
871 return status;
871 return status;
872 }
872 }
873
873
874 //*******************
874 //*******************
875 // TC_LFR_UPDATE_INFO
875 // TC_LFR_UPDATE_INFO
876 unsigned int check_update_info_hk_lfr_mode( unsigned char mode )
876 unsigned int check_update_info_hk_lfr_mode( unsigned char mode )
877 {
877 {
878 unsigned int status;
878 unsigned int status;
879
879
880 status = LFR_DEFAULT;
880 status = LFR_DEFAULT;
881
881
882 if ( (mode == LFR_MODE_STANDBY) || (mode == LFR_MODE_NORMAL)
882 if ( (mode == LFR_MODE_STANDBY) || (mode == LFR_MODE_NORMAL)
883 || (mode == LFR_MODE_BURST)
883 || (mode == LFR_MODE_BURST)
884 || (mode == LFR_MODE_SBM1) || (mode == LFR_MODE_SBM2))
884 || (mode == LFR_MODE_SBM1) || (mode == LFR_MODE_SBM2))
885 {
885 {
886 status = LFR_SUCCESSFUL;
886 status = LFR_SUCCESSFUL;
887 }
887 }
888 else
888 else
889 {
889 {
890 status = LFR_DEFAULT;
890 status = LFR_DEFAULT;
891 }
891 }
892
892
893 return status;
893 return status;
894 }
894 }
895
895
896 unsigned int check_update_info_hk_tds_mode( unsigned char mode )
896 unsigned int check_update_info_hk_tds_mode( unsigned char mode )
897 {
897 {
898 unsigned int status;
898 unsigned int status;
899
899
900 status = LFR_DEFAULT;
900 status = LFR_DEFAULT;
901
901
902 if ( (mode == TDS_MODE_STANDBY) || (mode == TDS_MODE_NORMAL)
902 if ( (mode == TDS_MODE_STANDBY) || (mode == TDS_MODE_NORMAL)
903 || (mode == TDS_MODE_BURST)
903 || (mode == TDS_MODE_BURST)
904 || (mode == TDS_MODE_SBM1) || (mode == TDS_MODE_SBM2)
904 || (mode == TDS_MODE_SBM1) || (mode == TDS_MODE_SBM2)
905 || (mode == TDS_MODE_LFM))
905 || (mode == TDS_MODE_LFM))
906 {
906 {
907 status = LFR_SUCCESSFUL;
907 status = LFR_SUCCESSFUL;
908 }
908 }
909 else
909 else
910 {
910 {
911 status = LFR_DEFAULT;
911 status = LFR_DEFAULT;
912 }
912 }
913
913
914 return status;
914 return status;
915 }
915 }
916
916
917 unsigned int check_update_info_hk_thr_mode( unsigned char mode )
917 unsigned int check_update_info_hk_thr_mode( unsigned char mode )
918 {
918 {
919 unsigned int status;
919 unsigned int status;
920
920
921 status = LFR_DEFAULT;
921 status = LFR_DEFAULT;
922
922
923 if ( (mode == THR_MODE_STANDBY) || (mode == THR_MODE_NORMAL)
923 if ( (mode == THR_MODE_STANDBY) || (mode == THR_MODE_NORMAL)
924 || (mode == THR_MODE_BURST))
924 || (mode == THR_MODE_BURST))
925 {
925 {
926 status = LFR_SUCCESSFUL;
926 status = LFR_SUCCESSFUL;
927 }
927 }
928 else
928 else
929 {
929 {
930 status = LFR_DEFAULT;
930 status = LFR_DEFAULT;
931 }
931 }
932
932
933 return status;
933 return status;
934 }
934 }
935
935
936 void getReactionWheelsFrequencies( ccsdsTelecommandPacket_t *TC )
936 void getReactionWheelsFrequencies( ccsdsTelecommandPacket_t *TC )
937 {
937 {
938 /** This function get the reaction wheels frequencies in the incoming TC_LFR_UPDATE_INFO and copy the values locally.
938 /** This function get the reaction wheels frequencies in the incoming TC_LFR_UPDATE_INFO and copy the values locally.
939 *
939 *
940 * @param TC points to the TeleCommand packet that is being processed
940 * @param TC points to the TeleCommand packet that is being processed
941 *
941 *
942 */
942 */
943
943
944 unsigned char * bytePosPtr; // pointer to the beginning of the incoming TC packet
944 unsigned char * bytePosPtr; // pointer to the beginning of the incoming TC packet
945
945
946 bytePosPtr = (unsigned char *) &TC->packetID;
946 bytePosPtr = (unsigned char *) &TC->packetID;
947
947
948 // cp_rpw_sc_rw1_f1
948 // cp_rpw_sc_rw1_f1
949 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw1_f1,
949 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw1_f1,
950 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW1_F1 ] );
950 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW1_F1 ] );
951
951
952 // cp_rpw_sc_rw1_f2
952 // cp_rpw_sc_rw1_f2
953 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw1_f2,
953 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw1_f2,
954 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW1_F2 ] );
954 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW1_F2 ] );
955
955
956 // cp_rpw_sc_rw2_f1
956 // cp_rpw_sc_rw2_f1
957 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw2_f1,
957 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw2_f1,
958 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW2_F1 ] );
958 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW2_F1 ] );
959
959
960 // cp_rpw_sc_rw2_f2
960 // cp_rpw_sc_rw2_f2
961 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw2_f2,
961 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw2_f2,
962 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW2_F2 ] );
962 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW2_F2 ] );
963
963
964 // cp_rpw_sc_rw3_f1
964 // cp_rpw_sc_rw3_f1
965 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw3_f1,
965 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw3_f1,
966 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW3_F1 ] );
966 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW3_F1 ] );
967
967
968 // cp_rpw_sc_rw3_f2
968 // cp_rpw_sc_rw3_f2
969 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw3_f2,
969 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw3_f2,
970 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW3_F2 ] );
970 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW3_F2 ] );
971
971
972 // cp_rpw_sc_rw4_f1
972 // cp_rpw_sc_rw4_f1
973 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw4_f1,
973 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw4_f1,
974 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW4_F1 ] );
974 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW4_F1 ] );
975
975
976 // cp_rpw_sc_rw4_f2
976 // cp_rpw_sc_rw4_f2
977 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw4_f2,
977 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw4_f2,
978 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW4_F2 ] );
978 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW4_F2 ] );
979 }
979 }
980
980
981 void setFBinMask( unsigned char *fbins_mask, float rw_f, unsigned char deltaFreq, unsigned char flag )
981 void setFBinMask( unsigned char *fbins_mask, float rw_f, unsigned char deltaFreq, unsigned char flag, float sy_lfr_rw_k )
982 {
982 {
983 /** This function executes specific actions when a TC_LFR_UPDATE_INFO TeleCommand has been received.
983 /** This function executes specific actions when a TC_LFR_UPDATE_INFO TeleCommand has been received.
984 *
984 *
985 * @param fbins_mask
985 * @param fbins_mask
986 * @param rw_f is the reaction wheel frequency to filter
986 * @param rw_f is the reaction wheel frequency to filter
987 * @param delta_f is the frequency step between the frequency bins, it depends on the frequency channel
987 * @param delta_f is the frequency step between the frequency bins, it depends on the frequency channel
988 * @param flag [true] filtering enabled [false] filtering disabled
988 * @param flag [true] filtering enabled [false] filtering disabled
989 *
989 *
990 * @return void
990 * @return void
991 *
991 *
992 */
992 */
993
993
994 float f_RW_min;
994 float f_RW_min;
995 float f_RW_MAX;
995 float f_RW_MAX;
996 float fi_min;
996 float fi_min;
997 float fi_MAX;
997 float fi_MAX;
998 float fi;
998 float fi;
999 float deltaBelow;
999 float deltaBelow;
1000 float deltaAbove;
1000 float deltaAbove;
1001 float freqToFilterOut;
1001 int binBelow;
1002 int binBelow;
1002 int binAbove;
1003 int binAbove;
1003 int closestBin;
1004 int closestBin;
1004 unsigned int whichByte;
1005 unsigned int whichByte;
1005 int selectedByte;
1006 int selectedByte;
1006 int bin;
1007 int bin;
1007 int binToRemove[NB_BINS_TO_REMOVE];
1008 int binToRemove[NB_BINS_TO_REMOVE];
1008 int k;
1009 int k;
1010 bool filteringSet;
1009
1011
1010 closestBin = 0;
1012 closestBin = 0;
1011 whichByte = 0;
1013 whichByte = 0;
1012 bin = 0;
1014 bin = 0;
1015 filteringSet = false;
1013
1016
1014 for (k = 0; k < NB_BINS_TO_REMOVE; k++)
1017 for (k = 0; k < NB_BINS_TO_REMOVE; k++)
1015 {
1018 {
1016 binToRemove[k] = -1;
1019 binToRemove[k] = -1;
1017 }
1020 }
1018
1021
1019 // compute the frequency range to filter [ rw_f - delta_f/2; rw_f + delta_f/2 ]
1022 // compute the frequency range to filter [ rw_f - delta_f; rw_f + delta_f ]
1020 f_RW_min = rw_f - (filterPar.sy_lfr_sc_rw_delta_f / 2.);
1023 f_RW_min = rw_f - ((filterPar.sy_lfr_sc_rw_delta_f) * sy_lfr_rw_k);
1021 f_RW_MAX = rw_f + (filterPar.sy_lfr_sc_rw_delta_f / 2.);
1024 f_RW_MAX = rw_f + ((filterPar.sy_lfr_sc_rw_delta_f) * sy_lfr_rw_k);
1022
1025
1023 // compute the index of the frequency bin immediately below rw_f
1026 freqToFilterOut = f_RW_min;
1024 binBelow = (int) ( floor( ((double) rw_f) / ((double) deltaFreq)) );
1027 while ( filteringSet == false )
1025 deltaBelow = rw_f - binBelow * deltaFreq;
1028 {
1029 // compute the index of the frequency bin immediately below rw_f
1030 binBelow = (int) ( floor( ((double) freqToFilterOut) / ((double) deltaFreq)) );
1031 deltaBelow = freqToFilterOut - binBelow * deltaFreq;
1026
1032
1027 // compute the index of the frequency bin immediately above rw_f
1033 // compute the index of the frequency bin immediately above rw_f
1028 binAbove = (int) ( ceil( ((double) rw_f) / ((double) deltaFreq)) );
1034 binAbove = (int) ( ceil( ((double) freqToFilterOut) / ((double) deltaFreq)) );
1029 deltaAbove = binAbove * deltaFreq - rw_f;
1035 deltaAbove = binAbove * deltaFreq - freqToFilterOut;
1030
1036
1031 // search the closest bin
1037 // search the closest bin
1032 if (deltaAbove > deltaBelow)
1038 if (deltaAbove > deltaBelow)
1033 {
1039 {
1034 closestBin = binBelow;
1040 closestBin = binBelow;
1035 }
1041 }
1036 else
1042 else
1037 {
1043 {
1038 closestBin = binAbove;
1044 closestBin = binAbove;
1039 }
1045 }
1040
1046
1041 // compute the fi interval [fi - deltaFreq * 0.285, fi + deltaFreq * 0.285]
1047 // compute the fi interval [fi - deltaFreq * 0.285, fi + deltaFreq * 0.285]
1042 fi = closestBin * deltaFreq;
1048 fi = closestBin * deltaFreq;
1043 fi_min = fi - (deltaFreq * FI_INTERVAL_COEFF);
1049 fi_min = fi - (deltaFreq * FI_INTERVAL_COEFF);
1044 fi_MAX = fi + (deltaFreq * FI_INTERVAL_COEFF);
1050 fi_MAX = fi + (deltaFreq * FI_INTERVAL_COEFF);
1051
1052 //**************************************************************************************
1053 // be careful here, one shall take into account that the bin 0 IS DROPPED in the spectra
1054 // thus, the index 0 in a mask corresponds to the bin 1 of the spectrum
1055 //**************************************************************************************
1045
1056
1046 //**************************************************************************************
1057 // 1. IF freqToFilterOut is included in [ fi_min; fi_MAX ]
1047 // be careful here, one shall take into account that the bin 0 IS DROPPED in the spectra
1058 // => remove f_(i), f_(i-1) and f_(i+1)
1048 // thus, the index 0 in a mask corresponds to the bin 1 of the spectrum
1059 if ( ( freqToFilterOut > fi_min ) && ( freqToFilterOut < fi_MAX ) )
1049 //**************************************************************************************
1060 {
1061 binToRemove[0] = (closestBin - 1) - 1;
1062 binToRemove[1] = (closestBin) - 1;
1063 binToRemove[2] = (closestBin + 1) - 1;
1064 }
1065 // 2. ELSE
1066 // => remove the two f_(i) which are around f_RW
1067 else
1068 {
1069 binToRemove[0] = (binBelow) - 1;
1070 binToRemove[1] = (binAbove) - 1;
1071 binToRemove[2] = (-1);
1072 }
1050
1073
1051 // 1. IF [ f_RW_min, f_RW_MAX] is included in [ fi_min; fi_MAX ]
1074 for (k = 0; k < NB_BINS_TO_REMOVE; k++)
1052 // => remove f_(i), f_(i-1) and f_(i+1)
1075 {
1053 if ( ( f_RW_min > fi_min ) && ( f_RW_MAX < fi_MAX ) )
1076 bin = binToRemove[k];
1054 {
1077 if ( (bin >= BIN_MIN) && (bin <= BIN_MAX) )
1055 binToRemove[0] = (closestBin - 1) - 1;
1078 {
1056 binToRemove[1] = (closestBin) - 1;
1079 if (flag == 1)
1057 binToRemove[2] = (closestBin + 1) - 1;
1080 {
1058 }
1081 whichByte = (bin >> SHIFT_3_BITS); // division by 8
1059 // 2. ELSE
1082 selectedByte = ( 1 << (bin - (whichByte * BITS_PER_BYTE)) );
1060 // => remove the two f_(i) which are around f_RW
1083 fbins_mask[BYTES_PER_MASK - 1 - whichByte] =
1061 else
1084 fbins_mask[BYTES_PER_MASK - 1 - whichByte] & ((unsigned char) (~selectedByte)); // bytes are ordered MSB first in the packets
1062 {
1085 }
1063 binToRemove[0] = (binBelow) - 1;
1086 }
1064 binToRemove[1] = (binAbove) - 1;
1087 }
1065 binToRemove[2] = (-1);
1066 }
1067
1088
1068 for (k = 0; k < NB_BINS_TO_REMOVE; k++)
1089 // update freqToFilterOut
1069 {
1090 if ( freqToFilterOut == f_RW_MAX )
1070 bin = binToRemove[k];
1091 {
1071 if ( (bin >= BIN_MIN) && (bin <= BIN_MAX) )
1092 filteringSet = true; // end of the loop
1093 }
1094 else
1072 {
1095 {
1073 if (flag == 1)
1096 freqToFilterOut = freqToFilterOut + deltaFreq;
1074 {
1097 }
1075 whichByte = (bin >> SHIFT_3_BITS); // division by 8
1098
1076 selectedByte = ( 1 << (bin - (whichByte * BITS_PER_BYTE)) );
1099 if ( freqToFilterOut > f_RW_MAX)
1077 fbins_mask[BYTES_PER_MASK - 1 - whichByte] =
1100 {
1078 fbins_mask[BYTES_PER_MASK - 1 - whichByte] & ((unsigned char) (~selectedByte)); // bytes are ordered MSB first in the packets
1101 freqToFilterOut = f_RW_MAX;
1079 }
1080 }
1102 }
1081 }
1103 }
1082 }
1104 }
1083
1105
1084 void build_sy_lfr_rw_mask( unsigned int channel )
1106 void build_sy_lfr_rw_mask( unsigned int channel )
1085 {
1107 {
1086 unsigned char local_rw_fbins_mask[BYTES_PER_MASK];
1108 unsigned char local_rw_fbins_mask[BYTES_PER_MASK];
1087 unsigned char *maskPtr;
1109 unsigned char *maskPtr;
1088 double deltaF;
1110 double deltaF;
1089 unsigned k;
1111 unsigned k;
1090
1112
1091 k = 0;
1113 k = 0;
1092
1114
1093 maskPtr = NULL;
1115 maskPtr = NULL;
1094 deltaF = DELTAF_F2;
1116 deltaF = DELTAF_F2;
1095
1117
1096 switch (channel)
1118 switch (channel)
1097 {
1119 {
1098 case CHANNELF0:
1120 case CHANNELF0:
1099 maskPtr = parameter_dump_packet.sy_lfr_rw_mask_f0_word1;
1121 maskPtr = parameter_dump_packet.sy_lfr_rw_mask_f0_word1;
1100 deltaF = DELTAF_F0;
1122 deltaF = DELTAF_F0;
1101 break;
1123 break;
1102 case CHANNELF1:
1124 case CHANNELF1:
1103 maskPtr = parameter_dump_packet.sy_lfr_rw_mask_f1_word1;
1125 maskPtr = parameter_dump_packet.sy_lfr_rw_mask_f1_word1;
1104 deltaF = DELTAF_F1;
1126 deltaF = DELTAF_F1;
1105 break;
1127 break;
1106 case CHANNELF2:
1128 case CHANNELF2:
1107 maskPtr = parameter_dump_packet.sy_lfr_rw_mask_f2_word1;
1129 maskPtr = parameter_dump_packet.sy_lfr_rw_mask_f2_word1;
1108 deltaF = DELTAF_F2;
1130 deltaF = DELTAF_F2;
1109 break;
1131 break;
1110 default:
1132 default:
1111 break;
1133 break;
1112 }
1134 }
1113
1135
1114 for (k = 0; k < BYTES_PER_MASK; k++)
1136 for (k = 0; k < BYTES_PER_MASK; k++)
1115 {
1137 {
1116 local_rw_fbins_mask[k] = INT8_ALL_F;
1138 local_rw_fbins_mask[k] = INT8_ALL_F;
1117 }
1139 }
1118
1140
1119 // RW1 F1
1141 // RW1 F1
1120 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw1_f1, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW1_F1) >> SHIFT_7_BITS ); // [1000 0000]
1142 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw1_f1, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW1_F1) >> SHIFT_7_BITS, 1. ); // [1000 0000]
1121
1143
1122 // RW1 F2
1144 // RW1 F2
1123 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw1_f2, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW1_F2) >> SHIFT_6_BITS ); // [0100 0000]
1145 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw1_f2, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW1_F2) >> SHIFT_6_BITS, 1. ); // [0100 0000]
1124
1146
1125 // RW2 F1
1147 // RW2 F1
1126 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw2_f1, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW2_F1) >> SHIFT_5_BITS ); // [0010 0000]
1148 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw2_f1, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW2_F1) >> SHIFT_5_BITS, 1. ); // [0010 0000]
1127
1149
1128 // RW2 F2
1150 // RW2 F2
1129 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw2_f2, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW2_F2) >> SHIFT_4_BITS ); // [0001 0000]
1151 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw2_f2, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW2_F2) >> SHIFT_4_BITS, 1. ); // [0001 0000]
1130
1152
1131 // RW3 F1
1153 // RW3 F1
1132 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw3_f1, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW3_F1) >> SHIFT_3_BITS ); // [0000 1000]
1154 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw3_f1, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW3_F1) >> SHIFT_3_BITS, 1. ); // [0000 1000]
1133
1155
1134 // RW3 F2
1156 // RW3 F2
1135 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw3_f2, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW3_F2) >> SHIFT_2_BITS ); // [0000 0100]
1157 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw3_f2, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW3_F2) >> SHIFT_2_BITS, 1. ); // [0000 0100]
1136
1158
1137 // RW4 F1
1159 // RW4 F1
1138 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw4_f1, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW4_F1) >> 1 ); // [0000 0010]
1160 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw4_f1, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW4_F1) >> 1 , 1. ); // [0000 0010]
1139
1161
1140 // RW4 F2
1162 // RW4 F2
1141 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw4_f2, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW4_F2) ); // [0000 0001]
1163 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw4_f2, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW4_F2) , 1.); // [0000 0001]
1142
1164
1143 // update the value of the fbins related to reaction wheels frequency filtering
1165 // update the value of the fbins related to reaction wheels frequency filtering
1144 if (maskPtr != NULL)
1166 if (maskPtr != NULL)
1145 {
1167 {
1146 for (k = 0; k < BYTES_PER_MASK; k++)
1168 for (k = 0; k < BYTES_PER_MASK; k++)
1147 {
1169 {
1148 maskPtr[k] = local_rw_fbins_mask[k];
1170 maskPtr[k] = local_rw_fbins_mask[k];
1149 }
1171 }
1150 }
1172 }
1151 }
1173 }
1152
1174
1153 void build_sy_lfr_rw_masks( void )
1175 void build_sy_lfr_rw_masks( void )
1154 {
1176 {
1155 build_sy_lfr_rw_mask( CHANNELF0 );
1177 build_sy_lfr_rw_mask( CHANNELF0 );
1156 build_sy_lfr_rw_mask( CHANNELF1 );
1178 build_sy_lfr_rw_mask( CHANNELF1 );
1157 build_sy_lfr_rw_mask( CHANNELF2 );
1179 build_sy_lfr_rw_mask( CHANNELF2 );
1158 }
1180 }
1159
1181
1160 void merge_fbins_masks( void )
1182 void merge_fbins_masks( void )
1161 {
1183 {
1162 unsigned char k;
1184 unsigned char k;
1163
1185
1164 unsigned char *fbins_f0;
1186 unsigned char *fbins_f0;
1165 unsigned char *fbins_f1;
1187 unsigned char *fbins_f1;
1166 unsigned char *fbins_f2;
1188 unsigned char *fbins_f2;
1167 unsigned char *rw_mask_f0;
1189 unsigned char *rw_mask_f0;
1168 unsigned char *rw_mask_f1;
1190 unsigned char *rw_mask_f1;
1169 unsigned char *rw_mask_f2;
1191 unsigned char *rw_mask_f2;
1170
1192
1171 fbins_f0 = parameter_dump_packet.sy_lfr_fbins_f0_word1;
1193 fbins_f0 = parameter_dump_packet.sy_lfr_fbins_f0_word1;
1172 fbins_f1 = parameter_dump_packet.sy_lfr_fbins_f1_word1;
1194 fbins_f1 = parameter_dump_packet.sy_lfr_fbins_f1_word1;
1173 fbins_f2 = parameter_dump_packet.sy_lfr_fbins_f2_word1;
1195 fbins_f2 = parameter_dump_packet.sy_lfr_fbins_f2_word1;
1174 rw_mask_f0 = parameter_dump_packet.sy_lfr_rw_mask_f0_word1;
1196 rw_mask_f0 = parameter_dump_packet.sy_lfr_rw_mask_f0_word1;
1175 rw_mask_f1 = parameter_dump_packet.sy_lfr_rw_mask_f1_word1;
1197 rw_mask_f1 = parameter_dump_packet.sy_lfr_rw_mask_f1_word1;
1176 rw_mask_f2 = parameter_dump_packet.sy_lfr_rw_mask_f2_word1;
1198 rw_mask_f2 = parameter_dump_packet.sy_lfr_rw_mask_f2_word1;
1177
1199
1178 for( k=0; k < BYTES_PER_MASK; k++ )
1200 for( k=0; k < BYTES_PER_MASK; k++ )
1179 {
1201 {
1180 fbins_masks.merged_fbins_mask_f0[k] = fbins_f0[k] & rw_mask_f0[k];
1202 fbins_masks.merged_fbins_mask_f0[k] = fbins_f0[k] & rw_mask_f0[k];
1181 fbins_masks.merged_fbins_mask_f1[k] = fbins_f1[k] & rw_mask_f1[k];
1203 fbins_masks.merged_fbins_mask_f1[k] = fbins_f1[k] & rw_mask_f1[k];
1182 fbins_masks.merged_fbins_mask_f2[k] = fbins_f2[k] & rw_mask_f2[k];
1204 fbins_masks.merged_fbins_mask_f2[k] = fbins_f2[k] & rw_mask_f2[k];
1183 }
1205 }
1184 }
1206 }
1185
1207
1186 //***********
1208 //***********
1187 // FBINS MASK
1209 // FBINS MASK
1188
1210
1189 int set_sy_lfr_fbins( ccsdsTelecommandPacket_t *TC )
1211 int set_sy_lfr_fbins( ccsdsTelecommandPacket_t *TC )
1190 {
1212 {
1191 int status;
1213 int status;
1192 unsigned int k;
1214 unsigned int k;
1193 unsigned char *fbins_mask_dump;
1215 unsigned char *fbins_mask_dump;
1194 unsigned char *fbins_mask_TC;
1216 unsigned char *fbins_mask_TC;
1195
1217
1196 status = LFR_SUCCESSFUL;
1218 status = LFR_SUCCESSFUL;
1197
1219
1198 fbins_mask_dump = parameter_dump_packet.sy_lfr_fbins_f0_word1;
1220 fbins_mask_dump = parameter_dump_packet.sy_lfr_fbins_f0_word1;
1199 fbins_mask_TC = TC->dataAndCRC;
1221 fbins_mask_TC = TC->dataAndCRC;
1200
1222
1201 for (k=0; k < BYTES_PER_MASKS_SET; k++)
1223 for (k=0; k < BYTES_PER_MASKS_SET; k++)
1202 {
1224 {
1203 fbins_mask_dump[k] = fbins_mask_TC[k];
1225 fbins_mask_dump[k] = fbins_mask_TC[k];
1204 }
1226 }
1205
1227
1206 return status;
1228 return status;
1207 }
1229 }
1208
1230
1209 //***************************
1231 //***************************
1210 // TC_LFR_LOAD_PAS_FILTER_PAR
1232 // TC_LFR_LOAD_PAS_FILTER_PAR
1211
1233
1212 int check_sy_lfr_filter_parameters( ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
1234 int check_sy_lfr_filter_parameters( ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
1213 {
1235 {
1214 int flag;
1236 int flag;
1215 rtems_status_code status;
1237 rtems_status_code status;
1216
1238
1217 unsigned char sy_lfr_pas_filter_enabled;
1239 unsigned char sy_lfr_pas_filter_enabled;
1218 unsigned char sy_lfr_pas_filter_modulus;
1240 unsigned char sy_lfr_pas_filter_modulus;
1219 float sy_lfr_pas_filter_tbad;
1241 float sy_lfr_pas_filter_tbad;
1220 unsigned char sy_lfr_pas_filter_offset;
1242 unsigned char sy_lfr_pas_filter_offset;
1221 float sy_lfr_pas_filter_shift;
1243 float sy_lfr_pas_filter_shift;
1222 float sy_lfr_sc_rw_delta_f;
1244 float sy_lfr_sc_rw_delta_f;
1223 char *parPtr;
1245 char *parPtr;
1224
1246
1225 flag = LFR_SUCCESSFUL;
1247 flag = LFR_SUCCESSFUL;
1226 sy_lfr_pas_filter_tbad = INIT_FLOAT;
1248 sy_lfr_pas_filter_tbad = INIT_FLOAT;
1227 sy_lfr_pas_filter_shift = INIT_FLOAT;
1249 sy_lfr_pas_filter_shift = INIT_FLOAT;
1228 sy_lfr_sc_rw_delta_f = INIT_FLOAT;
1250 sy_lfr_sc_rw_delta_f = INIT_FLOAT;
1229 parPtr = NULL;
1251 parPtr = NULL;
1230
1252
1231 //***************
1253 //***************
1232 // get parameters
1254 // get parameters
1233 sy_lfr_pas_filter_enabled = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_ENABLED ] & BIT_PAS_FILTER_ENABLED; // [0000 0001]
1255 sy_lfr_pas_filter_enabled = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_ENABLED ] & BIT_PAS_FILTER_ENABLED; // [0000 0001]
1234 sy_lfr_pas_filter_modulus = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_MODULUS ];
1256 sy_lfr_pas_filter_modulus = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_MODULUS ];
1235 copyFloatByChar(
1257 copyFloatByChar(
1236 (unsigned char*) &sy_lfr_pas_filter_tbad,
1258 (unsigned char*) &sy_lfr_pas_filter_tbad,
1237 (unsigned char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD ]
1259 (unsigned char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD ]
1238 );
1260 );
1239 sy_lfr_pas_filter_offset = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_OFFSET ];
1261 sy_lfr_pas_filter_offset = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_OFFSET ];
1240 copyFloatByChar(
1262 copyFloatByChar(
1241 (unsigned char*) &sy_lfr_pas_filter_shift,
1263 (unsigned char*) &sy_lfr_pas_filter_shift,
1242 (unsigned char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT ]
1264 (unsigned char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT ]
1243 );
1265 );
1244 copyFloatByChar(
1266 copyFloatByChar(
1245 (unsigned char*) &sy_lfr_sc_rw_delta_f,
1267 (unsigned char*) &sy_lfr_sc_rw_delta_f,
1246 (unsigned char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F ]
1268 (unsigned char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F ]
1247 );
1269 );
1248
1270
1249 //******************
1271 //******************
1250 // CHECK CONSISTENCY
1272 // CHECK CONSISTENCY
1251
1273
1252 //**************************
1274 //**************************
1253 // sy_lfr_pas_filter_enabled
1275 // sy_lfr_pas_filter_enabled
1254 // nothing to check, value is 0 or 1
1276 // nothing to check, value is 0 or 1
1255
1277
1256 //**************************
1278 //**************************
1257 // sy_lfr_pas_filter_modulus
1279 // sy_lfr_pas_filter_modulus
1258 if ( (sy_lfr_pas_filter_modulus < MIN_PAS_FILTER_MODULUS) || (sy_lfr_pas_filter_modulus > MAX_PAS_FILTER_MODULUS) )
1280 if ( (sy_lfr_pas_filter_modulus < MIN_PAS_FILTER_MODULUS) || (sy_lfr_pas_filter_modulus > MAX_PAS_FILTER_MODULUS) )
1259 {
1281 {
1260 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_MODULUS + DATAFIELD_OFFSET, sy_lfr_pas_filter_modulus );
1282 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_MODULUS + DATAFIELD_OFFSET, sy_lfr_pas_filter_modulus );
1261 flag = WRONG_APP_DATA;
1283 flag = WRONG_APP_DATA;
1262 }
1284 }
1263
1285
1264 //***********************
1286 //***********************
1265 // sy_lfr_pas_filter_tbad
1287 // sy_lfr_pas_filter_tbad
1266 if ( (sy_lfr_pas_filter_tbad < MIN_PAS_FILTER_TBAD) || (sy_lfr_pas_filter_tbad > MAX_PAS_FILTER_TBAD) )
1288 if ( (sy_lfr_pas_filter_tbad < MIN_PAS_FILTER_TBAD) || (sy_lfr_pas_filter_tbad > MAX_PAS_FILTER_TBAD) )
1267 {
1289 {
1268 parPtr = (char*) &sy_lfr_pas_filter_tbad;
1290 parPtr = (char*) &sy_lfr_pas_filter_tbad;
1269 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + DATAFIELD_OFFSET, parPtr[FLOAT_LSBYTE] );
1291 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + DATAFIELD_OFFSET, parPtr[FLOAT_LSBYTE] );
1270 flag = WRONG_APP_DATA;
1292 flag = WRONG_APP_DATA;
1271 }
1293 }
1272
1294
1273 //*************************
1295 //*************************
1274 // sy_lfr_pas_filter_offset
1296 // sy_lfr_pas_filter_offset
1275 if (flag == LFR_SUCCESSFUL)
1297 if (flag == LFR_SUCCESSFUL)
1276 {
1298 {
1277 if ( (sy_lfr_pas_filter_offset < MIN_PAS_FILTER_OFFSET) || (sy_lfr_pas_filter_offset > MAX_PAS_FILTER_OFFSET) )
1299 if ( (sy_lfr_pas_filter_offset < MIN_PAS_FILTER_OFFSET) || (sy_lfr_pas_filter_offset > MAX_PAS_FILTER_OFFSET) )
1278 {
1300 {
1279 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_OFFSET + DATAFIELD_OFFSET, sy_lfr_pas_filter_offset );
1301 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_OFFSET + DATAFIELD_OFFSET, sy_lfr_pas_filter_offset );
1280 flag = WRONG_APP_DATA;
1302 flag = WRONG_APP_DATA;
1281 }
1303 }
1282 }
1304 }
1283
1305
1284 //************************
1306 //************************
1285 // sy_lfr_pas_filter_shift
1307 // sy_lfr_pas_filter_shift
1286 if (flag == LFR_SUCCESSFUL)
1308 if (flag == LFR_SUCCESSFUL)
1287 {
1309 {
1288 if ( (sy_lfr_pas_filter_shift < MIN_PAS_FILTER_SHIFT) || (sy_lfr_pas_filter_shift > MAX_PAS_FILTER_SHIFT) )
1310 if ( (sy_lfr_pas_filter_shift < MIN_PAS_FILTER_SHIFT) || (sy_lfr_pas_filter_shift > MAX_PAS_FILTER_SHIFT) )
1289 {
1311 {
1290 parPtr = (char*) &sy_lfr_pas_filter_shift;
1312 parPtr = (char*) &sy_lfr_pas_filter_shift;
1291 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + DATAFIELD_OFFSET, parPtr[FLOAT_LSBYTE] );
1313 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + DATAFIELD_OFFSET, parPtr[FLOAT_LSBYTE] );
1292 flag = WRONG_APP_DATA;
1314 flag = WRONG_APP_DATA;
1293 }
1315 }
1294 }
1316 }
1295
1317
1296 //*************************************
1318 //*************************************
1297 // check global coherency of the values
1319 // check global coherency of the values
1298 if (flag == LFR_SUCCESSFUL)
1320 if (flag == LFR_SUCCESSFUL)
1299 {
1321 {
1300 if ( (sy_lfr_pas_filter_tbad + sy_lfr_pas_filter_offset + sy_lfr_pas_filter_shift) > sy_lfr_pas_filter_modulus )
1322 if ( (sy_lfr_pas_filter_tbad + sy_lfr_pas_filter_offset + sy_lfr_pas_filter_shift) > sy_lfr_pas_filter_modulus )
1301 {
1323 {
1302 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_MODULUS + DATAFIELD_OFFSET, sy_lfr_pas_filter_modulus );
1324 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_MODULUS + DATAFIELD_OFFSET, sy_lfr_pas_filter_modulus );
1303 flag = WRONG_APP_DATA;
1325 flag = WRONG_APP_DATA;
1304 }
1326 }
1305 }
1327 }
1306
1328
1307 //*********************
1329 //*********************
1308 // sy_lfr_sc_rw_delta_f
1330 // sy_lfr_sc_rw_delta_f
1309 // nothing to check, no default value in the ICD
1331 // nothing to check, no default value in the ICD
1310
1332
1311 return flag;
1333 return flag;
1312 }
1334 }
1313
1335
1314 //**************
1336 //**************
1315 // KCOEFFICIENTS
1337 // KCOEFFICIENTS
1316 int set_sy_lfr_kcoeff( ccsdsTelecommandPacket_t *TC,rtems_id queue_id )
1338 int set_sy_lfr_kcoeff( ccsdsTelecommandPacket_t *TC,rtems_id queue_id )
1317 {
1339 {
1318 unsigned int kcoeff;
1340 unsigned int kcoeff;
1319 unsigned short sy_lfr_kcoeff_frequency;
1341 unsigned short sy_lfr_kcoeff_frequency;
1320 unsigned short bin;
1342 unsigned short bin;
1321 float *kcoeffPtr_norm;
1343 float *kcoeffPtr_norm;
1322 float *kcoeffPtr_sbm;
1344 float *kcoeffPtr_sbm;
1323 int status;
1345 int status;
1324 unsigned char *kcoeffLoadPtr;
1346 unsigned char *kcoeffLoadPtr;
1325 unsigned char *kcoeffNormPtr;
1347 unsigned char *kcoeffNormPtr;
1326 unsigned char *kcoeffSbmPtr_a;
1348 unsigned char *kcoeffSbmPtr_a;
1327 unsigned char *kcoeffSbmPtr_b;
1349 unsigned char *kcoeffSbmPtr_b;
1328
1350
1329 sy_lfr_kcoeff_frequency = 0;
1351 sy_lfr_kcoeff_frequency = 0;
1330 bin = 0;
1352 bin = 0;
1331 kcoeffPtr_norm = NULL;
1353 kcoeffPtr_norm = NULL;
1332 kcoeffPtr_sbm = NULL;
1354 kcoeffPtr_sbm = NULL;
1333 status = LFR_SUCCESSFUL;
1355 status = LFR_SUCCESSFUL;
1334
1356
1335 // copy the value of the frequency byte by byte DO NOT USE A SHORT* POINTER
1357 // copy the value of the frequency byte by byte DO NOT USE A SHORT* POINTER
1336 copyInt16ByChar( (unsigned char*) &sy_lfr_kcoeff_frequency, &TC->dataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_FREQUENCY] );
1358 copyInt16ByChar( (unsigned char*) &sy_lfr_kcoeff_frequency, &TC->dataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_FREQUENCY] );
1337
1359
1338 if ( sy_lfr_kcoeff_frequency >= NB_BINS_COMPRESSED_SM )
1360 if ( sy_lfr_kcoeff_frequency >= NB_BINS_COMPRESSED_SM )
1339 {
1361 {
1340 PRINTF1("ERR *** in set_sy_lfr_kcoeff_frequency *** sy_lfr_kcoeff_frequency = %d\n", sy_lfr_kcoeff_frequency)
1362 PRINTF1("ERR *** in set_sy_lfr_kcoeff_frequency *** sy_lfr_kcoeff_frequency = %d\n", sy_lfr_kcoeff_frequency)
1341 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_KCOEFF_FREQUENCY + DATAFIELD_OFFSET + 1,
1363 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_KCOEFF_FREQUENCY + DATAFIELD_OFFSET + 1,
1342 TC->dataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_FREQUENCY + 1] ); // +1 to get the LSB instead of the MSB
1364 TC->dataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_FREQUENCY + 1] ); // +1 to get the LSB instead of the MSB
1343 status = LFR_DEFAULT;
1365 status = LFR_DEFAULT;
1344 }
1366 }
1345 else
1367 else
1346 {
1368 {
1347 if ( ( sy_lfr_kcoeff_frequency >= 0 )
1369 if ( ( sy_lfr_kcoeff_frequency >= 0 )
1348 && ( sy_lfr_kcoeff_frequency < NB_BINS_COMPRESSED_SM_F0 ) )
1370 && ( sy_lfr_kcoeff_frequency < NB_BINS_COMPRESSED_SM_F0 ) )
1349 {
1371 {
1350 kcoeffPtr_norm = k_coeff_intercalib_f0_norm;
1372 kcoeffPtr_norm = k_coeff_intercalib_f0_norm;
1351 kcoeffPtr_sbm = k_coeff_intercalib_f0_sbm;
1373 kcoeffPtr_sbm = k_coeff_intercalib_f0_sbm;
1352 bin = sy_lfr_kcoeff_frequency;
1374 bin = sy_lfr_kcoeff_frequency;
1353 }
1375 }
1354 else if ( ( sy_lfr_kcoeff_frequency >= NB_BINS_COMPRESSED_SM_F0 )
1376 else if ( ( sy_lfr_kcoeff_frequency >= NB_BINS_COMPRESSED_SM_F0 )
1355 && ( sy_lfr_kcoeff_frequency < (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1) ) )
1377 && ( sy_lfr_kcoeff_frequency < (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1) ) )
1356 {
1378 {
1357 kcoeffPtr_norm = k_coeff_intercalib_f1_norm;
1379 kcoeffPtr_norm = k_coeff_intercalib_f1_norm;
1358 kcoeffPtr_sbm = k_coeff_intercalib_f1_sbm;
1380 kcoeffPtr_sbm = k_coeff_intercalib_f1_sbm;
1359 bin = sy_lfr_kcoeff_frequency - NB_BINS_COMPRESSED_SM_F0;
1381 bin = sy_lfr_kcoeff_frequency - NB_BINS_COMPRESSED_SM_F0;
1360 }
1382 }
1361 else if ( ( sy_lfr_kcoeff_frequency >= (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1) )
1383 else if ( ( sy_lfr_kcoeff_frequency >= (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1) )
1362 && ( sy_lfr_kcoeff_frequency < (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1 + NB_BINS_COMPRESSED_SM_F2) ) )
1384 && ( sy_lfr_kcoeff_frequency < (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1 + NB_BINS_COMPRESSED_SM_F2) ) )
1363 {
1385 {
1364 kcoeffPtr_norm = k_coeff_intercalib_f2;
1386 kcoeffPtr_norm = k_coeff_intercalib_f2;
1365 kcoeffPtr_sbm = NULL;
1387 kcoeffPtr_sbm = NULL;
1366 bin = sy_lfr_kcoeff_frequency - (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1);
1388 bin = sy_lfr_kcoeff_frequency - (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1);
1367 }
1389 }
1368 }
1390 }
1369
1391
1370 if (kcoeffPtr_norm != NULL ) // update K coefficient for NORMAL data products
1392 if (kcoeffPtr_norm != NULL ) // update K coefficient for NORMAL data products
1371 {
1393 {
1372 for (kcoeff=0; kcoeff<NB_K_COEFF_PER_BIN; kcoeff++)
1394 for (kcoeff=0; kcoeff<NB_K_COEFF_PER_BIN; kcoeff++)
1373 {
1395 {
1374 // destination
1396 // destination
1375 kcoeffNormPtr = (unsigned char*) &kcoeffPtr_norm[ (bin * NB_K_COEFF_PER_BIN) + kcoeff ];
1397 kcoeffNormPtr = (unsigned char*) &kcoeffPtr_norm[ (bin * NB_K_COEFF_PER_BIN) + kcoeff ];
1376 // source
1398 // source
1377 kcoeffLoadPtr = (unsigned char*) &TC->dataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_1 + (NB_BYTES_PER_FLOAT * kcoeff)];
1399 kcoeffLoadPtr = (unsigned char*) &TC->dataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_1 + (NB_BYTES_PER_FLOAT * kcoeff)];
1378 // copy source to destination
1400 // copy source to destination
1379 copyFloatByChar( kcoeffNormPtr, kcoeffLoadPtr );
1401 copyFloatByChar( kcoeffNormPtr, kcoeffLoadPtr );
1380 }
1402 }
1381 }
1403 }
1382
1404
1383 if (kcoeffPtr_sbm != NULL ) // update K coefficient for SBM data products
1405 if (kcoeffPtr_sbm != NULL ) // update K coefficient for SBM data products
1384 {
1406 {
1385 for (kcoeff=0; kcoeff<NB_K_COEFF_PER_BIN; kcoeff++)
1407 for (kcoeff=0; kcoeff<NB_K_COEFF_PER_BIN; kcoeff++)
1386 {
1408 {
1387 // destination
1409 // destination
1388 kcoeffSbmPtr_a= (unsigned char*) &kcoeffPtr_sbm[ ( (bin * NB_K_COEFF_PER_BIN) + kcoeff) * SBM_COEFF_PER_NORM_COEFF ];
1410 kcoeffSbmPtr_a= (unsigned char*) &kcoeffPtr_sbm[ ( (bin * NB_K_COEFF_PER_BIN) + kcoeff) * SBM_COEFF_PER_NORM_COEFF ];
1389 kcoeffSbmPtr_b= (unsigned char*) &kcoeffPtr_sbm[ (((bin * NB_K_COEFF_PER_BIN) + kcoeff) * SBM_KCOEFF_PER_NORM_KCOEFF) + 1 ];
1411 kcoeffSbmPtr_b= (unsigned char*) &kcoeffPtr_sbm[ (((bin * NB_K_COEFF_PER_BIN) + kcoeff) * SBM_KCOEFF_PER_NORM_KCOEFF) + 1 ];
1390 // source
1412 // source
1391 kcoeffLoadPtr = (unsigned char*) &TC->dataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_1 + (NB_BYTES_PER_FLOAT * kcoeff)];
1413 kcoeffLoadPtr = (unsigned char*) &TC->dataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_1 + (NB_BYTES_PER_FLOAT * kcoeff)];
1392 // copy source to destination
1414 // copy source to destination
1393 copyFloatByChar( kcoeffSbmPtr_a, kcoeffLoadPtr );
1415 copyFloatByChar( kcoeffSbmPtr_a, kcoeffLoadPtr );
1394 copyFloatByChar( kcoeffSbmPtr_b, kcoeffLoadPtr );
1416 copyFloatByChar( kcoeffSbmPtr_b, kcoeffLoadPtr );
1395 }
1417 }
1396 }
1418 }
1397
1419
1398 //print_k_coeff();
1420 //print_k_coeff();
1399
1421
1400 return status;
1422 return status;
1401 }
1423 }
1402
1424
1403 void copyFloatByChar( unsigned char *destination, unsigned char *source )
1425 void copyFloatByChar( unsigned char *destination, unsigned char *source )
1404 {
1426 {
1405 destination[BYTE_0] = source[BYTE_0];
1427 destination[BYTE_0] = source[BYTE_0];
1406 destination[BYTE_1] = source[BYTE_1];
1428 destination[BYTE_1] = source[BYTE_1];
1407 destination[BYTE_2] = source[BYTE_2];
1429 destination[BYTE_2] = source[BYTE_2];
1408 destination[BYTE_3] = source[BYTE_3];
1430 destination[BYTE_3] = source[BYTE_3];
1409 }
1431 }
1410
1432
1411 void copyInt32ByChar( unsigned char *destination, unsigned char *source )
1433 void copyInt32ByChar( unsigned char *destination, unsigned char *source )
1412 {
1434 {
1413 destination[BYTE_0] = source[BYTE_0];
1435 destination[BYTE_0] = source[BYTE_0];
1414 destination[BYTE_1] = source[BYTE_1];
1436 destination[BYTE_1] = source[BYTE_1];
1415 destination[BYTE_2] = source[BYTE_2];
1437 destination[BYTE_2] = source[BYTE_2];
1416 destination[BYTE_3] = source[BYTE_3];
1438 destination[BYTE_3] = source[BYTE_3];
1417 }
1439 }
1418
1440
1419 void copyInt16ByChar( unsigned char *destination, unsigned char *source )
1441 void copyInt16ByChar( unsigned char *destination, unsigned char *source )
1420 {
1442 {
1421 destination[BYTE_0] = source[BYTE_0];
1443 destination[BYTE_0] = source[BYTE_0];
1422 destination[BYTE_1] = source[BYTE_1];
1444 destination[BYTE_1] = source[BYTE_1];
1423 }
1445 }
1424
1446
1425 void floatToChar( float value, unsigned char* ptr)
1447 void floatToChar( float value, unsigned char* ptr)
1426 {
1448 {
1427 unsigned char* valuePtr;
1449 unsigned char* valuePtr;
1428
1450
1429 valuePtr = (unsigned char*) &value;
1451 valuePtr = (unsigned char*) &value;
1430
1452
1431 ptr[BYTE_0] = valuePtr[BYTE_0];
1453 ptr[BYTE_0] = valuePtr[BYTE_0];
1432 ptr[BYTE_1] = valuePtr[BYTE_1];
1454 ptr[BYTE_1] = valuePtr[BYTE_1];
1433 ptr[BYTE_2] = valuePtr[BYTE_2];
1455 ptr[BYTE_2] = valuePtr[BYTE_2];
1434 ptr[BYTE_3] = valuePtr[BYTE_3];
1456 ptr[BYTE_3] = valuePtr[BYTE_3];
1435 }
1457 }
1436
1458
1437 //**********
1459 //**********
1438 // init dump
1460 // init dump
1439
1461
1440 void init_parameter_dump( void )
1462 void init_parameter_dump( void )
1441 {
1463 {
1442 /** This function initialize the parameter_dump_packet global variable with default values.
1464 /** This function initialize the parameter_dump_packet global variable with default values.
1443 *
1465 *
1444 */
1466 */
1445
1467
1446 unsigned int k;
1468 unsigned int k;
1447
1469
1448 parameter_dump_packet.targetLogicalAddress = CCSDS_DESTINATION_ID;
1470 parameter_dump_packet.targetLogicalAddress = CCSDS_DESTINATION_ID;
1449 parameter_dump_packet.protocolIdentifier = CCSDS_PROTOCOLE_ID;
1471 parameter_dump_packet.protocolIdentifier = CCSDS_PROTOCOLE_ID;
1450 parameter_dump_packet.reserved = CCSDS_RESERVED;
1472 parameter_dump_packet.reserved = CCSDS_RESERVED;
1451 parameter_dump_packet.userApplication = CCSDS_USER_APP;
1473 parameter_dump_packet.userApplication = CCSDS_USER_APP;
1452 parameter_dump_packet.packetID[0] = (unsigned char) (APID_TM_PARAMETER_DUMP >> SHIFT_1_BYTE);
1474 parameter_dump_packet.packetID[0] = (unsigned char) (APID_TM_PARAMETER_DUMP >> SHIFT_1_BYTE);
1453 parameter_dump_packet.packetID[1] = (unsigned char) APID_TM_PARAMETER_DUMP;
1475 parameter_dump_packet.packetID[1] = (unsigned char) APID_TM_PARAMETER_DUMP;
1454 parameter_dump_packet.packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
1476 parameter_dump_packet.packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
1455 parameter_dump_packet.packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT;
1477 parameter_dump_packet.packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT;
1456 parameter_dump_packet.packetLength[0] = (unsigned char) (PACKET_LENGTH_PARAMETER_DUMP >> SHIFT_1_BYTE);
1478 parameter_dump_packet.packetLength[0] = (unsigned char) (PACKET_LENGTH_PARAMETER_DUMP >> SHIFT_1_BYTE);
1457 parameter_dump_packet.packetLength[1] = (unsigned char) PACKET_LENGTH_PARAMETER_DUMP;
1479 parameter_dump_packet.packetLength[1] = (unsigned char) PACKET_LENGTH_PARAMETER_DUMP;
1458 // DATA FIELD HEADER
1480 // DATA FIELD HEADER
1459 parameter_dump_packet.spare1_pusVersion_spare2 = SPARE1_PUSVERSION_SPARE2;
1481 parameter_dump_packet.spare1_pusVersion_spare2 = SPARE1_PUSVERSION_SPARE2;
1460 parameter_dump_packet.serviceType = TM_TYPE_PARAMETER_DUMP;
1482 parameter_dump_packet.serviceType = TM_TYPE_PARAMETER_DUMP;
1461 parameter_dump_packet.serviceSubType = TM_SUBTYPE_PARAMETER_DUMP;
1483 parameter_dump_packet.serviceSubType = TM_SUBTYPE_PARAMETER_DUMP;
1462 parameter_dump_packet.destinationID = TM_DESTINATION_ID_GROUND;
1484 parameter_dump_packet.destinationID = TM_DESTINATION_ID_GROUND;
1463 parameter_dump_packet.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
1485 parameter_dump_packet.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
1464 parameter_dump_packet.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
1486 parameter_dump_packet.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
1465 parameter_dump_packet.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
1487 parameter_dump_packet.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
1466 parameter_dump_packet.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
1488 parameter_dump_packet.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
1467 parameter_dump_packet.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
1489 parameter_dump_packet.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
1468 parameter_dump_packet.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
1490 parameter_dump_packet.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
1469 parameter_dump_packet.sid = SID_PARAMETER_DUMP;
1491 parameter_dump_packet.sid = SID_PARAMETER_DUMP;
1470
1492
1471 //******************
1493 //******************
1472 // COMMON PARAMETERS
1494 // COMMON PARAMETERS
1473 parameter_dump_packet.sy_lfr_common_parameters_spare = DEFAULT_SY_LFR_COMMON0;
1495 parameter_dump_packet.sy_lfr_common_parameters_spare = DEFAULT_SY_LFR_COMMON0;
1474 parameter_dump_packet.sy_lfr_common_parameters = DEFAULT_SY_LFR_COMMON1;
1496 parameter_dump_packet.sy_lfr_common_parameters = DEFAULT_SY_LFR_COMMON1;
1475
1497
1476 //******************
1498 //******************
1477 // NORMAL PARAMETERS
1499 // NORMAL PARAMETERS
1478 parameter_dump_packet.sy_lfr_n_swf_l[0] = (unsigned char) (DFLT_SY_LFR_N_SWF_L >> SHIFT_1_BYTE);
1500 parameter_dump_packet.sy_lfr_n_swf_l[0] = (unsigned char) (DFLT_SY_LFR_N_SWF_L >> SHIFT_1_BYTE);
1479 parameter_dump_packet.sy_lfr_n_swf_l[1] = (unsigned char) (DFLT_SY_LFR_N_SWF_L );
1501 parameter_dump_packet.sy_lfr_n_swf_l[1] = (unsigned char) (DFLT_SY_LFR_N_SWF_L );
1480 parameter_dump_packet.sy_lfr_n_swf_p[0] = (unsigned char) (DFLT_SY_LFR_N_SWF_P >> SHIFT_1_BYTE);
1502 parameter_dump_packet.sy_lfr_n_swf_p[0] = (unsigned char) (DFLT_SY_LFR_N_SWF_P >> SHIFT_1_BYTE);
1481 parameter_dump_packet.sy_lfr_n_swf_p[1] = (unsigned char) (DFLT_SY_LFR_N_SWF_P );
1503 parameter_dump_packet.sy_lfr_n_swf_p[1] = (unsigned char) (DFLT_SY_LFR_N_SWF_P );
1482 parameter_dump_packet.sy_lfr_n_asm_p[0] = (unsigned char) (DFLT_SY_LFR_N_ASM_P >> SHIFT_1_BYTE);
1504 parameter_dump_packet.sy_lfr_n_asm_p[0] = (unsigned char) (DFLT_SY_LFR_N_ASM_P >> SHIFT_1_BYTE);
1483 parameter_dump_packet.sy_lfr_n_asm_p[1] = (unsigned char) (DFLT_SY_LFR_N_ASM_P );
1505 parameter_dump_packet.sy_lfr_n_asm_p[1] = (unsigned char) (DFLT_SY_LFR_N_ASM_P );
1484 parameter_dump_packet.sy_lfr_n_bp_p0 = (unsigned char) DFLT_SY_LFR_N_BP_P0;
1506 parameter_dump_packet.sy_lfr_n_bp_p0 = (unsigned char) DFLT_SY_LFR_N_BP_P0;
1485 parameter_dump_packet.sy_lfr_n_bp_p1 = (unsigned char) DFLT_SY_LFR_N_BP_P1;
1507 parameter_dump_packet.sy_lfr_n_bp_p1 = (unsigned char) DFLT_SY_LFR_N_BP_P1;
1486 parameter_dump_packet.sy_lfr_n_cwf_long_f3 = (unsigned char) DFLT_SY_LFR_N_CWF_LONG_F3;
1508 parameter_dump_packet.sy_lfr_n_cwf_long_f3 = (unsigned char) DFLT_SY_LFR_N_CWF_LONG_F3;
1487
1509
1488 //*****************
1510 //*****************
1489 // BURST PARAMETERS
1511 // BURST PARAMETERS
1490 parameter_dump_packet.sy_lfr_b_bp_p0 = (unsigned char) DEFAULT_SY_LFR_B_BP_P0;
1512 parameter_dump_packet.sy_lfr_b_bp_p0 = (unsigned char) DEFAULT_SY_LFR_B_BP_P0;
1491 parameter_dump_packet.sy_lfr_b_bp_p1 = (unsigned char) DEFAULT_SY_LFR_B_BP_P1;
1513 parameter_dump_packet.sy_lfr_b_bp_p1 = (unsigned char) DEFAULT_SY_LFR_B_BP_P1;
1492
1514
1493 //****************
1515 //****************
1494 // SBM1 PARAMETERS
1516 // SBM1 PARAMETERS
1495 parameter_dump_packet.sy_lfr_s1_bp_p0 = (unsigned char) DEFAULT_SY_LFR_S1_BP_P0; // min value is 0.25 s for the period
1517 parameter_dump_packet.sy_lfr_s1_bp_p0 = (unsigned char) DEFAULT_SY_LFR_S1_BP_P0; // min value is 0.25 s for the period
1496 parameter_dump_packet.sy_lfr_s1_bp_p1 = (unsigned char) DEFAULT_SY_LFR_S1_BP_P1;
1518 parameter_dump_packet.sy_lfr_s1_bp_p1 = (unsigned char) DEFAULT_SY_LFR_S1_BP_P1;
1497
1519
1498 //****************
1520 //****************
1499 // SBM2 PARAMETERS
1521 // SBM2 PARAMETERS
1500 parameter_dump_packet.sy_lfr_s2_bp_p0 = (unsigned char) DEFAULT_SY_LFR_S2_BP_P0;
1522 parameter_dump_packet.sy_lfr_s2_bp_p0 = (unsigned char) DEFAULT_SY_LFR_S2_BP_P0;
1501 parameter_dump_packet.sy_lfr_s2_bp_p1 = (unsigned char) DEFAULT_SY_LFR_S2_BP_P1;
1523 parameter_dump_packet.sy_lfr_s2_bp_p1 = (unsigned char) DEFAULT_SY_LFR_S2_BP_P1;
1502
1524
1503 //************
1525 //************
1504 // FBINS MASKS
1526 // FBINS MASKS
1505 for (k=0; k < BYTES_PER_MASKS_SET; k++)
1527 for (k=0; k < BYTES_PER_MASKS_SET; k++)
1506 {
1528 {
1507 parameter_dump_packet.sy_lfr_fbins_f0_word1[k] = INT8_ALL_F;
1529 parameter_dump_packet.sy_lfr_fbins_f0_word1[k] = INT8_ALL_F;
1508 }
1530 }
1509
1531
1510 // PAS FILTER PARAMETERS
1532 // PAS FILTER PARAMETERS
1511 parameter_dump_packet.pa_rpw_spare8_2 = INIT_CHAR;
1533 parameter_dump_packet.pa_rpw_spare8_2 = INIT_CHAR;
1512 parameter_dump_packet.spare_sy_lfr_pas_filter_enabled = INIT_CHAR;
1534 parameter_dump_packet.spare_sy_lfr_pas_filter_enabled = INIT_CHAR;
1513 parameter_dump_packet.sy_lfr_pas_filter_modulus = DEFAULT_SY_LFR_PAS_FILTER_MODULUS;
1535 parameter_dump_packet.sy_lfr_pas_filter_modulus = DEFAULT_SY_LFR_PAS_FILTER_MODULUS;
1514 floatToChar( DEFAULT_SY_LFR_PAS_FILTER_TBAD, parameter_dump_packet.sy_lfr_pas_filter_tbad );
1536 floatToChar( DEFAULT_SY_LFR_PAS_FILTER_TBAD, parameter_dump_packet.sy_lfr_pas_filter_tbad );
1515 parameter_dump_packet.sy_lfr_pas_filter_offset = DEFAULT_SY_LFR_PAS_FILTER_OFFSET;
1537 parameter_dump_packet.sy_lfr_pas_filter_offset = DEFAULT_SY_LFR_PAS_FILTER_OFFSET;
1516 floatToChar( DEFAULT_SY_LFR_PAS_FILTER_SHIFT, parameter_dump_packet.sy_lfr_pas_filter_shift );
1538 floatToChar( DEFAULT_SY_LFR_PAS_FILTER_SHIFT, parameter_dump_packet.sy_lfr_pas_filter_shift );
1517 floatToChar( DEFAULT_SY_LFR_SC_RW_DELTA_F, parameter_dump_packet.sy_lfr_sc_rw_delta_f );
1539 floatToChar( DEFAULT_SY_LFR_SC_RW_DELTA_F, parameter_dump_packet.sy_lfr_sc_rw_delta_f );
1518
1540
1519 // LFR_RW_MASK
1541 // LFR_RW_MASK
1520 for (k=0; k < BYTES_PER_MASKS_SET; k++)
1542 for (k=0; k < BYTES_PER_MASKS_SET; k++)
1521 {
1543 {
1522 parameter_dump_packet.sy_lfr_rw_mask_f0_word1[k] = INT8_ALL_F;
1544 parameter_dump_packet.sy_lfr_rw_mask_f0_word1[k] = INT8_ALL_F;
1523 }
1545 }
1524
1546
1525 // once the reaction wheels masks have been initialized, they have to be merged with the fbins masks
1547 // once the reaction wheels masks have been initialized, they have to be merged with the fbins masks
1526 merge_fbins_masks();
1548 merge_fbins_masks();
1527 }
1549 }
1528
1550
1529 void init_kcoefficients_dump( void )
1551 void init_kcoefficients_dump( void )
1530 {
1552 {
1531 init_kcoefficients_dump_packet( &kcoefficients_dump_1, PKTNR_1, KCOEFF_BLK_NR_PKT1 );
1553 init_kcoefficients_dump_packet( &kcoefficients_dump_1, PKTNR_1, KCOEFF_BLK_NR_PKT1 );
1532 init_kcoefficients_dump_packet( &kcoefficients_dump_2, PKTNR_2, KCOEFF_BLK_NR_PKT2 );
1554 init_kcoefficients_dump_packet( &kcoefficients_dump_2, PKTNR_2, KCOEFF_BLK_NR_PKT2 );
1533
1555
1534 kcoefficient_node_1.previous = NULL;
1556 kcoefficient_node_1.previous = NULL;
1535 kcoefficient_node_1.next = NULL;
1557 kcoefficient_node_1.next = NULL;
1536 kcoefficient_node_1.sid = TM_CODE_K_DUMP;
1558 kcoefficient_node_1.sid = TM_CODE_K_DUMP;
1537 kcoefficient_node_1.coarseTime = INIT_CHAR;
1559 kcoefficient_node_1.coarseTime = INIT_CHAR;
1538 kcoefficient_node_1.fineTime = INIT_CHAR;
1560 kcoefficient_node_1.fineTime = INIT_CHAR;
1539 kcoefficient_node_1.buffer_address = (int) &kcoefficients_dump_1;
1561 kcoefficient_node_1.buffer_address = (int) &kcoefficients_dump_1;
1540 kcoefficient_node_1.status = INIT_CHAR;
1562 kcoefficient_node_1.status = INIT_CHAR;
1541
1563
1542 kcoefficient_node_2.previous = NULL;
1564 kcoefficient_node_2.previous = NULL;
1543 kcoefficient_node_2.next = NULL;
1565 kcoefficient_node_2.next = NULL;
1544 kcoefficient_node_2.sid = TM_CODE_K_DUMP;
1566 kcoefficient_node_2.sid = TM_CODE_K_DUMP;
1545 kcoefficient_node_2.coarseTime = INIT_CHAR;
1567 kcoefficient_node_2.coarseTime = INIT_CHAR;
1546 kcoefficient_node_2.fineTime = INIT_CHAR;
1568 kcoefficient_node_2.fineTime = INIT_CHAR;
1547 kcoefficient_node_2.buffer_address = (int) &kcoefficients_dump_2;
1569 kcoefficient_node_2.buffer_address = (int) &kcoefficients_dump_2;
1548 kcoefficient_node_2.status = INIT_CHAR;
1570 kcoefficient_node_2.status = INIT_CHAR;
1549 }
1571 }
1550
1572
1551 void init_kcoefficients_dump_packet( Packet_TM_LFR_KCOEFFICIENTS_DUMP_t *kcoefficients_dump, unsigned char pkt_nr, unsigned char blk_nr )
1573 void init_kcoefficients_dump_packet( Packet_TM_LFR_KCOEFFICIENTS_DUMP_t *kcoefficients_dump, unsigned char pkt_nr, unsigned char blk_nr )
1552 {
1574 {
1553 unsigned int k;
1575 unsigned int k;
1554 unsigned int packetLength;
1576 unsigned int packetLength;
1555
1577
1556 packetLength =
1578 packetLength =
1557 ((blk_nr * KCOEFF_BLK_SIZE) + BYTE_POS_KCOEFFICIENTS_PARAMETES) - CCSDS_TC_TM_PACKET_OFFSET; // 4 bytes for the CCSDS header
1579 ((blk_nr * KCOEFF_BLK_SIZE) + BYTE_POS_KCOEFFICIENTS_PARAMETES) - CCSDS_TC_TM_PACKET_OFFSET; // 4 bytes for the CCSDS header
1558
1580
1559 kcoefficients_dump->targetLogicalAddress = CCSDS_DESTINATION_ID;
1581 kcoefficients_dump->targetLogicalAddress = CCSDS_DESTINATION_ID;
1560 kcoefficients_dump->protocolIdentifier = CCSDS_PROTOCOLE_ID;
1582 kcoefficients_dump->protocolIdentifier = CCSDS_PROTOCOLE_ID;
1561 kcoefficients_dump->reserved = CCSDS_RESERVED;
1583 kcoefficients_dump->reserved = CCSDS_RESERVED;
1562 kcoefficients_dump->userApplication = CCSDS_USER_APP;
1584 kcoefficients_dump->userApplication = CCSDS_USER_APP;
1563 kcoefficients_dump->packetID[0] = (unsigned char) (APID_TM_PARAMETER_DUMP >> SHIFT_1_BYTE);
1585 kcoefficients_dump->packetID[0] = (unsigned char) (APID_TM_PARAMETER_DUMP >> SHIFT_1_BYTE);
1564 kcoefficients_dump->packetID[1] = (unsigned char) APID_TM_PARAMETER_DUMP;
1586 kcoefficients_dump->packetID[1] = (unsigned char) APID_TM_PARAMETER_DUMP;
1565 kcoefficients_dump->packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
1587 kcoefficients_dump->packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
1566 kcoefficients_dump->packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT;
1588 kcoefficients_dump->packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT;
1567 kcoefficients_dump->packetLength[0] = (unsigned char) (packetLength >> SHIFT_1_BYTE);
1589 kcoefficients_dump->packetLength[0] = (unsigned char) (packetLength >> SHIFT_1_BYTE);
1568 kcoefficients_dump->packetLength[1] = (unsigned char) packetLength;
1590 kcoefficients_dump->packetLength[1] = (unsigned char) packetLength;
1569 // DATA FIELD HEADER
1591 // DATA FIELD HEADER
1570 kcoefficients_dump->spare1_pusVersion_spare2 = SPARE1_PUSVERSION_SPARE2;
1592 kcoefficients_dump->spare1_pusVersion_spare2 = SPARE1_PUSVERSION_SPARE2;
1571 kcoefficients_dump->serviceType = TM_TYPE_K_DUMP;
1593 kcoefficients_dump->serviceType = TM_TYPE_K_DUMP;
1572 kcoefficients_dump->serviceSubType = TM_SUBTYPE_K_DUMP;
1594 kcoefficients_dump->serviceSubType = TM_SUBTYPE_K_DUMP;
1573 kcoefficients_dump->destinationID= TM_DESTINATION_ID_GROUND;
1595 kcoefficients_dump->destinationID= TM_DESTINATION_ID_GROUND;
1574 kcoefficients_dump->time[BYTE_0] = INIT_CHAR;
1596 kcoefficients_dump->time[BYTE_0] = INIT_CHAR;
1575 kcoefficients_dump->time[BYTE_1] = INIT_CHAR;
1597 kcoefficients_dump->time[BYTE_1] = INIT_CHAR;
1576 kcoefficients_dump->time[BYTE_2] = INIT_CHAR;
1598 kcoefficients_dump->time[BYTE_2] = INIT_CHAR;
1577 kcoefficients_dump->time[BYTE_3] = INIT_CHAR;
1599 kcoefficients_dump->time[BYTE_3] = INIT_CHAR;
1578 kcoefficients_dump->time[BYTE_4] = INIT_CHAR;
1600 kcoefficients_dump->time[BYTE_4] = INIT_CHAR;
1579 kcoefficients_dump->time[BYTE_5] = INIT_CHAR;
1601 kcoefficients_dump->time[BYTE_5] = INIT_CHAR;
1580 kcoefficients_dump->sid = SID_K_DUMP;
1602 kcoefficients_dump->sid = SID_K_DUMP;
1581
1603
1582 kcoefficients_dump->pkt_cnt = KCOEFF_PKTCNT;
1604 kcoefficients_dump->pkt_cnt = KCOEFF_PKTCNT;
1583 kcoefficients_dump->pkt_nr = PKTNR_1;
1605 kcoefficients_dump->pkt_nr = PKTNR_1;
1584 kcoefficients_dump->blk_nr = blk_nr;
1606 kcoefficients_dump->blk_nr = blk_nr;
1585
1607
1586 //******************
1608 //******************
1587 // SOURCE DATA repeated N times with N in [0 .. PA_LFR_KCOEFF_BLK_NR]
1609 // SOURCE DATA repeated N times with N in [0 .. PA_LFR_KCOEFF_BLK_NR]
1588 // one blk is 2 + 4 * 32 = 130 bytes, 30 blks max in one packet (30 * 130 = 3900)
1610 // one blk is 2 + 4 * 32 = 130 bytes, 30 blks max in one packet (30 * 130 = 3900)
1589 for (k=0; k<(KCOEFF_BLK_NR_PKT1 * KCOEFF_BLK_SIZE); k++)
1611 for (k=0; k<(KCOEFF_BLK_NR_PKT1 * KCOEFF_BLK_SIZE); k++)
1590 {
1612 {
1591 kcoefficients_dump->kcoeff_blks[k] = INIT_CHAR;
1613 kcoefficients_dump->kcoeff_blks[k] = INIT_CHAR;
1592 }
1614 }
1593 }
1615 }
1594
1616
1595 void increment_seq_counter_destination_id_dump( unsigned char *packet_sequence_control, unsigned char destination_id )
1617 void increment_seq_counter_destination_id_dump( unsigned char *packet_sequence_control, unsigned char destination_id )
1596 {
1618 {
1597 /** This function increment the packet sequence control parameter of a TC, depending on its destination ID.
1619 /** This function increment the packet sequence control parameter of a TC, depending on its destination ID.
1598 *
1620 *
1599 * @param packet_sequence_control points to the packet sequence control which will be incremented
1621 * @param packet_sequence_control points to the packet sequence control which will be incremented
1600 * @param destination_id is the destination ID of the TM, there is one counter by destination ID
1622 * @param destination_id is the destination ID of the TM, there is one counter by destination ID
1601 *
1623 *
1602 * If the destination ID is not known, a dedicated counter is incremented.
1624 * If the destination ID is not known, a dedicated counter is incremented.
1603 *
1625 *
1604 */
1626 */
1605
1627
1606 unsigned short sequence_cnt;
1628 unsigned short sequence_cnt;
1607 unsigned short segmentation_grouping_flag;
1629 unsigned short segmentation_grouping_flag;
1608 unsigned short new_packet_sequence_control;
1630 unsigned short new_packet_sequence_control;
1609 unsigned char i;
1631 unsigned char i;
1610
1632
1611 switch (destination_id)
1633 switch (destination_id)
1612 {
1634 {
1613 case SID_TC_GROUND:
1635 case SID_TC_GROUND:
1614 i = GROUND;
1636 i = GROUND;
1615 break;
1637 break;
1616 case SID_TC_MISSION_TIMELINE:
1638 case SID_TC_MISSION_TIMELINE:
1617 i = MISSION_TIMELINE;
1639 i = MISSION_TIMELINE;
1618 break;
1640 break;
1619 case SID_TC_TC_SEQUENCES:
1641 case SID_TC_TC_SEQUENCES:
1620 i = TC_SEQUENCES;
1642 i = TC_SEQUENCES;
1621 break;
1643 break;
1622 case SID_TC_RECOVERY_ACTION_CMD:
1644 case SID_TC_RECOVERY_ACTION_CMD:
1623 i = RECOVERY_ACTION_CMD;
1645 i = RECOVERY_ACTION_CMD;
1624 break;
1646 break;
1625 case SID_TC_BACKUP_MISSION_TIMELINE:
1647 case SID_TC_BACKUP_MISSION_TIMELINE:
1626 i = BACKUP_MISSION_TIMELINE;
1648 i = BACKUP_MISSION_TIMELINE;
1627 break;
1649 break;
1628 case SID_TC_DIRECT_CMD:
1650 case SID_TC_DIRECT_CMD:
1629 i = DIRECT_CMD;
1651 i = DIRECT_CMD;
1630 break;
1652 break;
1631 case SID_TC_SPARE_GRD_SRC1:
1653 case SID_TC_SPARE_GRD_SRC1:
1632 i = SPARE_GRD_SRC1;
1654 i = SPARE_GRD_SRC1;
1633 break;
1655 break;
1634 case SID_TC_SPARE_GRD_SRC2:
1656 case SID_TC_SPARE_GRD_SRC2:
1635 i = SPARE_GRD_SRC2;
1657 i = SPARE_GRD_SRC2;
1636 break;
1658 break;
1637 case SID_TC_OBCP:
1659 case SID_TC_OBCP:
1638 i = OBCP;
1660 i = OBCP;
1639 break;
1661 break;
1640 case SID_TC_SYSTEM_CONTROL:
1662 case SID_TC_SYSTEM_CONTROL:
1641 i = SYSTEM_CONTROL;
1663 i = SYSTEM_CONTROL;
1642 break;
1664 break;
1643 case SID_TC_AOCS:
1665 case SID_TC_AOCS:
1644 i = AOCS;
1666 i = AOCS;
1645 break;
1667 break;
1646 case SID_TC_RPW_INTERNAL:
1668 case SID_TC_RPW_INTERNAL:
1647 i = RPW_INTERNAL;
1669 i = RPW_INTERNAL;
1648 break;
1670 break;
1649 default:
1671 default:
1650 i = GROUND;
1672 i = GROUND;
1651 break;
1673 break;
1652 }
1674 }
1653
1675
1654 segmentation_grouping_flag = TM_PACKET_SEQ_CTRL_STANDALONE << SHIFT_1_BYTE;
1676 segmentation_grouping_flag = TM_PACKET_SEQ_CTRL_STANDALONE << SHIFT_1_BYTE;
1655 sequence_cnt = sequenceCounters_TM_DUMP[ i ] & SEQ_CNT_MASK;
1677 sequence_cnt = sequenceCounters_TM_DUMP[ i ] & SEQ_CNT_MASK;
1656
1678
1657 new_packet_sequence_control = segmentation_grouping_flag | sequence_cnt ;
1679 new_packet_sequence_control = segmentation_grouping_flag | sequence_cnt ;
1658
1680
1659 packet_sequence_control[0] = (unsigned char) (new_packet_sequence_control >> SHIFT_1_BYTE);
1681 packet_sequence_control[0] = (unsigned char) (new_packet_sequence_control >> SHIFT_1_BYTE);
1660 packet_sequence_control[1] = (unsigned char) (new_packet_sequence_control );
1682 packet_sequence_control[1] = (unsigned char) (new_packet_sequence_control );
1661
1683
1662 // increment the sequence counter
1684 // increment the sequence counter
1663 if ( sequenceCounters_TM_DUMP[ i ] < SEQ_CNT_MAX )
1685 if ( sequenceCounters_TM_DUMP[ i ] < SEQ_CNT_MAX )
1664 {
1686 {
1665 sequenceCounters_TM_DUMP[ i ] = sequenceCounters_TM_DUMP[ i ] + 1;
1687 sequenceCounters_TM_DUMP[ i ] = sequenceCounters_TM_DUMP[ i ] + 1;
1666 }
1688 }
1667 else
1689 else
1668 {
1690 {
1669 sequenceCounters_TM_DUMP[ i ] = 0;
1691 sequenceCounters_TM_DUMP[ i ] = 0;
1670 }
1692 }
1671 }
1693 }
General Comments 0
You need to be logged in to leave comments. Login now