@@ -1,6 +1,6 | |||
|
1 | 1 | <?xml version="1.0" encoding="UTF-8"?> |
|
2 | 2 | <!DOCTYPE QtCreatorProject> |
|
3 |
<!-- Written by QtCreator 3.0.1, 2014-04- |
|
|
3 | <!-- Written by QtCreator 3.0.1, 2014-04-11T12:08:35. --> | |
|
4 | 4 | <qtcreator> |
|
5 | 5 | <data> |
|
6 | 6 | <variable>ProjectExplorer.Project.ActiveTarget</variable> |
@@ -209,8 +209,8 enum apid_destid{ | |||
|
209 | 209 | #define PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0 (126 - CCSDS_TC_TM_PACKET_OFFSET) // 11 * 9 + 27 - 7 |
|
210 | 210 | #define PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0 (356 - CCSDS_TC_TM_PACKET_OFFSET) // 11 * 30 + 25 - 7 |
|
211 | 211 | #define PACKET_LENGTH_TM_LFR_SCIENCE_BURST_BP2_F1 (806 - CCSDS_TC_TM_PACKET_OFFSET) // 26 * 30 + 26 - 7 |
|
212 |
#define PACKET_LENGTH_TM_LFR_SCIENCE_SBM |
|
|
213 |
#define PACKET_LENGTH_TM_LFR_SCIENCE_SBM |
|
|
212 | #define PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0 (224 - CCSDS_TC_TM_PACKET_OFFSET) // 22 * 9 + 26 - 7 | |
|
213 | #define PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0 (686 - CCSDS_TC_TM_PACKET_OFFSET) // 22 * 30 + 26 - 7 | |
|
214 | 214 | |
|
215 | 215 | #define PACKET_LENGTH_DELTA 11 // 7 + 4 |
|
216 | 216 |
@@ -34,6 +34,7 rtems_task dumb_task( rtems_task_argumen | |||
|
34 | 34 | void init_housekeeping_parameters( void ); |
|
35 | 35 | void increment_seq_counter( unsigned char *packet_sequence_control); |
|
36 | 36 | void getTime( unsigned char *time); |
|
37 | unsigned long long int getTimeAsUnsignedLongLongInt( ); | |
|
37 | 38 | void send_dumb_hk( void ); |
|
38 | 39 | |
|
39 | 40 | #endif // FSW_MISC_H_INCLUDED |
@@ -18,6 +18,29 typedef struct ring_node | |||
|
18 | 18 | unsigned int status; |
|
19 | 19 | } ring_node; |
|
20 | 20 | |
|
21 | typedef struct { | |
|
22 | unsigned int f0; | |
|
23 | unsigned int norm_bp1_f0; | |
|
24 | unsigned int norm_bp2_f0; | |
|
25 | unsigned int norm_asm_f0; | |
|
26 | unsigned int sbm_bp1_f0; | |
|
27 | unsigned int sbm_bp2_f0; | |
|
28 | } nb_sm_t; | |
|
29 | ||
|
30 | typedef struct { | |
|
31 | unsigned int norm_bp1_f0; | |
|
32 | unsigned int norm_bp2_f0; | |
|
33 | unsigned int norm_asm_f0; | |
|
34 | unsigned int burst_sbm_bp1_f0; | |
|
35 | unsigned int burst_sbm_bp2_f0; | |
|
36 | unsigned int burst_bp1_f0; | |
|
37 | unsigned int burst_bp2_f0; | |
|
38 | unsigned int sbm1_bp1_f0; | |
|
39 | unsigned int sbm1_bp2_f0; | |
|
40 | unsigned int sbm2_bp1_f0; | |
|
41 | unsigned int sbm2_bp2_f0; | |
|
42 | } nb_sm_before_bp_t; | |
|
43 | ||
|
21 | 44 | //************************ |
|
22 | 45 | // flight software version |
|
23 | 46 | // this parameters is handled by the Qt project options |
@@ -55,17 +78,17 typedef struct ring_node | |||
|
55 | 78 | #define THR_MODE_NORMAL 1 |
|
56 | 79 | #define THR_MODE_BURST 2 |
|
57 | 80 | |
|
58 | #define RTEMS_EVENT_MODE_STANDBY RTEMS_EVENT_0 | |
|
59 | #define RTEMS_EVENT_MODE_NORMAL RTEMS_EVENT_1 | |
|
60 | #define RTEMS_EVENT_MODE_BURST RTEMS_EVENT_2 | |
|
61 | #define RTEMS_EVENT_MODE_SBM1 RTEMS_EVENT_3 | |
|
62 | #define RTEMS_EVENT_MODE_SBM2 RTEMS_EVENT_4 | |
|
63 | #define RTEMS_EVENT_MODE_SBM2_WFRM RTEMS_EVENT_5 | |
|
64 | #define RTEMS_EVENT_NORM_BP1_F0 RTEMS_EVENT_6 | |
|
65 | #define RTEMS_EVENT_NORM_BP2_F0 RTEMS_EVENT_7 | |
|
66 | #define RTEMS_EVENT_NORM_ASM_F0 RTEMS_EVENT_8 | |
|
67 |
#define RTEMS_EVENT_SBM |
|
|
68 |
#define RTEMS_EVENT_SBM |
|
|
81 | #define RTEMS_EVENT_MODE_STANDBY RTEMS_EVENT_0 | |
|
82 | #define RTEMS_EVENT_MODE_NORMAL RTEMS_EVENT_1 | |
|
83 | #define RTEMS_EVENT_MODE_BURST RTEMS_EVENT_2 | |
|
84 | #define RTEMS_EVENT_MODE_SBM1 RTEMS_EVENT_3 | |
|
85 | #define RTEMS_EVENT_MODE_SBM2 RTEMS_EVENT_4 | |
|
86 | #define RTEMS_EVENT_MODE_SBM2_WFRM RTEMS_EVENT_5 | |
|
87 | #define RTEMS_EVENT_NORM_BP1_F0 RTEMS_EVENT_6 | |
|
88 | #define RTEMS_EVENT_NORM_BP2_F0 RTEMS_EVENT_7 | |
|
89 | #define RTEMS_EVENT_NORM_ASM_F0 RTEMS_EVENT_8 | |
|
90 | #define RTEMS_EVENT_BURST_SBM_BP1_F0 RTEMS_EVENT_9 | |
|
91 | #define RTEMS_EVENT_BURST_SBM_BP2_F0 RTEMS_EVENT_10 | |
|
69 | 92 | |
|
70 | 93 | //**************************** |
|
71 | 94 | // LFR DEFAULT MODE PARAMETERS |
@@ -126,7 +149,7 typedef struct ring_node | |||
|
126 | 149 | |
|
127 | 150 | //***** |
|
128 | 151 | // TIME |
|
129 |
#define CLKDIV_SM_SIMULATOR (10 |
|
|
152 | #define CLKDIV_SM_SIMULATOR (10416 - 1) // 10 ms => nominal is 1/96 = 0.010416667, 10417 - 1 = 10416 | |
|
130 | 153 | #define TIMER_SM_SIMULATOR 1 |
|
131 | 154 | #define HK_PERIOD 100 // 100 * 10ms => 1s |
|
132 | 155 | #define SY_LFR_TIME_SYN_TIMEOUT_in_ms 2000 |
@@ -12,10 +12,16 | |||
|
12 | 12 | #define DATAFIELD_POS_SY_LFR_N_CWF_LONG_F3 8 |
|
13 | 13 | |
|
14 | 14 | // TC_LFR_LOAD_BURST_PAR |
|
15 | #define DATAFIELD_POS_SY_LFR_B_BP_P0 0 | |
|
16 | #define DATAFIELD_POS_SY_LFR_B_BP_P1 1 | |
|
15 | 17 | |
|
16 | 18 | // TC_LFR_LOAD_SBM1_PAR |
|
19 | #define DATAFIELD_POS_SY_LFR_S1_BP_P0 0 | |
|
20 | #define DATAFIELD_POS_SY_LFR_S1_BP_P1 1 | |
|
17 | 21 | |
|
18 | 22 | // TC_LFR_LOAD_SBM2_PAR |
|
23 | #define DATAFIELD_POS_SY_LFR_S2_BP_P0 0 | |
|
24 | #define DATAFIELD_POS_SY_LFR_S2_BP_P1 1 | |
|
19 | 25 | |
|
20 | 26 | // TC_LFR_UPDATE_INFO |
|
21 | 27 | #define BYTE_POS_UPDATE_INFO_PARAMETERS_SET5 34 |
@@ -9,11 +9,10 | |||
|
9 | 9 | #define TOTAL_SIZE_NORM_BP1_F2 108 // 12 * 9 = 108 |
|
10 | 10 | #define TOTAL_SIZE_SBM1_BP1_F0 198 // 22 * 9 = 198 |
|
11 | 11 | // |
|
12 |
#define NB_RING_NODES_ |
|
|
13 |
#define NB_RING_NODES_ |
|
|
14 |
#define NB_RING_NODES_ |
|
|
15 |
#define NB_RING_NODES_ |
|
|
16 | #define NB_RING_NODES_SBM1_BP2 5 // AT LEAST 3 | |
|
12 | #define NB_RING_NODES_SM_F0 12 // AT LEAST 3 | |
|
13 | #define NB_RING_NODES_SM_F1 3 // AT LEAST 3 | |
|
14 | #define NB_RING_NODES_SM_F2 3 // AT LEAST 3 | |
|
15 | #define NB_RING_NODES_ASM_BURST_SBM_F0 10 // AT LEAST 3 | |
|
17 | 16 | // |
|
18 | 17 | #define NB_BINS_PER_ASM_F0 88 |
|
19 | 18 | #define NB_BINS_PER_PKT_ASM_F0 44 |
@@ -36,22 +35,32 | |||
|
36 | 35 | #define NB_BINS_COMPRESSED_SM_F0 11 |
|
37 | 36 | #define NB_BINS_COMPRESSED_SM_F1 13 |
|
38 | 37 | #define NB_BINS_COMPRESSED_SM_F2 12 |
|
39 |
#define NB_BINS_COMPRESSED_SM_SBM |
|
|
38 | #define NB_BINS_COMPRESSED_SM_SBM_F0 22 | |
|
39 | ||
|
40 | 40 | // |
|
41 | #define NB_BINS_TO_AVERAGE_ASM_F0 8 | |
|
42 | #define NB_BINS_TO_AVERAGE_ASM_F1 8 | |
|
43 | #define NB_BINS_TO_AVERAGE_ASM_F2 8 | |
|
44 |
#define NB_BINS_TO_AVERAGE_ASM_SBM |
|
|
41 | #define NB_BINS_TO_AVERAGE_ASM_F0 8 | |
|
42 | #define NB_BINS_TO_AVERAGE_ASM_F1 8 | |
|
43 | #define NB_BINS_TO_AVERAGE_ASM_F2 8 | |
|
44 | #define NB_BINS_TO_AVERAGE_ASM_SBM_F0 4 | |
|
45 | 45 | // |
|
46 | 46 | #define TOTAL_SIZE_COMPRESSED_ASM_F0 275 // 11 * 25 WORDS |
|
47 | 47 | #define TOTAL_SIZE_COMPRESSED_ASM_F1 325 // 13 * 25 WORDS |
|
48 | 48 | #define TOTAL_SIZE_COMPRESSED_ASM_F2 300 // 12 * 25 WORDS |
|
49 | 49 | #define TOTAL_SIZE_COMPRESSED_ASM_SBM1 550 // 22 * 25 WORDS |
|
50 | // NORM | |
|
50 | 51 | #define NB_SM_BEFORE_NORM_BP1_F0 384 // 96 * 4 |
|
51 | 52 | #define NB_SM_BEFORE_NORM_BP2_F0 1920 // 96 * 20 |
|
52 | 53 | #define NB_SM_BEFORE_NORM_ASM_F0 384 // 384 matrices at f0 = 4.00 second |
|
53 | #define NB_SM_BEFORE_SBM1_BP1_F0 24 // 24 matrices at f0 = 0.25 second | |
|
54 |
#define NB_SM_BEFORE_ |
|
|
54 | // BURST | |
|
55 | #define NB_SM_BEFORE_BURST_BP1_F0 96 // 96 matrices at f0 = 1.00 second | |
|
56 | #define NB_SM_BEFORE_BURST_BP2_F0 480 // 480 matrices at f0 = 5.00 second | |
|
57 | // SBM1 | |
|
58 | #define NB_SM_BEFORE_SBM1_BP1_F0 24 // 24 matrices at f0 = 0.25 second | |
|
59 | #define NB_SM_BEFORE_SBM1_BP2_F0 96 // 96 matrices at f0 = 1.00 second | |
|
60 | // SBM2 | |
|
61 | #define NB_SM_BEFORE_SBM2_BP1_F0 96 // 96 matrices at f0 = 1.00 second | |
|
62 | #define NB_SM_BEFORE_SBM2_BP2_F0 480 // 480 matrices at f0 = 5.00 second | |
|
63 | // GENERAL | |
|
55 | 64 | #define NB_SM_BEFORE_AVF0 8 |
|
56 | 65 | |
|
57 | 66 | #endif // FSW_PARAMS_PROCESSING_H |
@@ -14,34 +14,35 | |||
|
14 | 14 | typedef struct ring_node_sm |
|
15 | 15 | { |
|
16 | 16 | struct ring_node_sm *previous; |
|
17 | struct ring_node_sm *next; | |
|
17 | 18 | int buffer_address; |
|
18 | struct ring_node_sm *next; | |
|
19 | 19 | unsigned int status; |
|
20 | 20 | unsigned int coarseTime; |
|
21 | 21 | unsigned int fineTime; |
|
22 | 22 | } ring_node_sm; |
|
23 | 23 | |
|
24 |
typedef struct ring_node_ |
|
|
24 | typedef struct ring_node_asm | |
|
25 | 25 | { |
|
26 |
struct ring_node_ |
|
|
27 |
struct ring_node_ |
|
|
26 | struct ring_node_asm *previous; | |
|
27 | struct ring_node_asm *next; | |
|
28 | float asm_burst_sbm_f0[ TIME_OFFSET + TOTAL_SIZE_SM ]; | |
|
28 | 29 | unsigned int status; |
|
29 | unsigned int coarseTime; | |
|
30 | unsigned int fineTime; | |
|
31 | Header_TM_LFR_SCIENCE_BP_t header; | |
|
32 | unsigned char data[ 30 * 22 ]; // MAX size is 22 * 30 TM_LFR_SCIENCE_BURST_BP2_F1 | |
|
33 | } ring_node_bp; | |
|
30 | } ring_node_asm; | |
|
34 | 31 | |
|
35 |
typedef struct |
|
|
32 | typedef struct bp_packet | |
|
36 | 33 | { |
|
37 | struct ring_node_bp_with_spare *previous; | |
|
38 | struct ring_node_bp_with_spare *next; | |
|
39 | unsigned int status; | |
|
40 | unsigned int coarseTime; | |
|
41 | unsigned int fineTime; | |
|
34 | Header_TM_LFR_SCIENCE_BP_t header; | |
|
35 | unsigned char data[ 30 * 22 ]; // MAX size is 22 * 30 [TM_LFR_SCIENCE_BURST_BP2_F1] | |
|
36 | } bp_packet; | |
|
37 | ||
|
38 | typedef struct bp_packet_with_spare | |
|
39 | { | |
|
42 | 40 | Header_TM_LFR_SCIENCE_BP_with_spare_t header; |
|
43 | unsigned char data[ 9 * 22 ]; | |
|
44 |
} |
|
|
41 | unsigned char data[ 9 * 13 ]; // only for TM_LFR_SCIENCE_NORMAL_BP1_F0 and F1 | |
|
42 | } bp_packet_with_spare; | |
|
43 | ||
|
44 | extern nb_sm_t nb_sm; | |
|
45 | extern nb_sm_before_bp_t nb_sm_before_bp; | |
|
45 | 46 | |
|
46 | 47 | extern volatile int sm_f0[ ]; |
|
47 | 48 | extern volatile int sm_f1[ ]; |
@@ -57,23 +58,23 extern spectral_matrix_regs_t *spectral_ | |||
|
57 | 58 | extern rtems_name misc_name[5]; |
|
58 | 59 | extern rtems_id Task_id[20]; /* array of task ids */ |
|
59 | 60 | |
|
60 | void init_sm_rings( void ); | |
|
61 | void reset_current_sm_ring_nodes( void ); | |
|
62 | void reset_current_bp_ring_nodes( void ); | |
|
63 | ||
|
64 | 61 | // ISR |
|
65 |
void reset_nb_sm_f0( |
|
|
62 | void reset_nb_sm_f0( unsigned char lfrMode ); | |
|
66 | 63 | rtems_isr spectral_matrices_isr( rtems_vector_number vector ); |
|
67 | 64 | rtems_isr spectral_matrices_isr_simu( rtems_vector_number vector ); |
|
68 | 65 | |
|
69 | 66 | // RTEMS TASKS |
|
70 |
rtems_task |
|
|
71 | rtems_task smiq_task(rtems_task_argument argument); // added to test the spectral matrix simulator | |
|
72 |
rtems_task matr_task(rtems_task_argument |
|
|
67 | rtems_task smiq_task( rtems_task_argument argument ); // added to test the spectral matrix simulator | |
|
68 | rtems_task avf0_task( rtems_task_argument lfrRequestedMode ); | |
|
69 | rtems_task matr_task( rtems_task_argument lfrRequestedMode ); | |
|
73 | 70 | |
|
74 |
//****************** |
|
|
75 |
// Spectral |
|
|
76 | ||
|
71 | //****************** | |
|
72 | // Spectral Matrices | |
|
73 | void SM_init_rings( void ); | |
|
74 | void ASM_init_ring( void ); | |
|
75 | void SM_reset_current_ring_nodes( void ); | |
|
76 | void ASM_reset_current_ring_node( void ); | |
|
77 | void ASM_init_header( Header_TM_LFR_SCIENCE_ASM_t *header); | |
|
77 | 78 | void SM_average(float *averaged_spec_mat_f0, float *averaged_spec_mat_f1, |
|
78 | 79 | ring_node_sm *ring_node_tab[], |
|
79 | 80 | unsigned int firstTimeF0, unsigned int firstTimeF1 ); |
@@ -86,23 +87,23 void ASM_convert(volatile float *input_m | |||
|
86 | 87 | void ASM_send(Header_TM_LFR_SCIENCE_ASM_t *header, char *spectral_matrix, |
|
87 | 88 | unsigned int sid, spw_ioctl_pkt_send *spw_ioctl_send, rtems_id queue_id); |
|
88 | 89 | |
|
90 | //***************** | |
|
91 | // Basic Parameters | |
|
92 | ||
|
93 | void BP_reset_current_ring_nodes( void ); | |
|
94 | void BP_init_header(Header_TM_LFR_SCIENCE_BP_t *header, | |
|
95 | unsigned int apid, unsigned char sid, | |
|
96 | unsigned int packetLength , unsigned char blkNr); | |
|
97 | void BP_init_header_with_spare(Header_TM_LFR_SCIENCE_BP_with_spare_t *header, | |
|
98 | unsigned int apid, unsigned char sid, | |
|
99 | unsigned int packetLength, unsigned char blkNr ); | |
|
89 | 100 | void BP_send(char *data, |
|
90 | 101 | rtems_id queue_id , |
|
91 | 102 | unsigned int nbBytesToSend ); |
|
92 | 103 | |
|
93 | void init_header_asm( Header_TM_LFR_SCIENCE_ASM_t *header); | |
|
94 | void init_bp_ring_sbm1_bp1( void ); | |
|
95 | void init_bp_ring_sbm1_bp2( void ); | |
|
96 | void init_headers_bp_ring_sbm1_bp1(); | |
|
97 | void init_header_bp(Header_TM_LFR_SCIENCE_BP_t *header, | |
|
98 | unsigned int apid, unsigned char sid, | |
|
99 | unsigned int packetLength , unsigned char blkNr); | |
|
100 | void init_header_bp_with_spare(Header_TM_LFR_SCIENCE_BP_with_spare_t *header, | |
|
101 | unsigned int apid, unsigned char sid, | |
|
102 | unsigned int packetLength, unsigned char blkNr ); | |
|
103 | ||
|
104 | //****************** | |
|
105 | // general functions | |
|
104 | 106 | void reset_spectral_matrix_regs( void ); |
|
105 | ||
|
106 | void set_time( unsigned char *time, unsigned int coarseTime, unsigned int fineTime ); | |
|
107 | void set_time(unsigned char *time, unsigned char *timeInBuffer ); | |
|
107 | 108 | |
|
108 | 109 | #endif // FSW_PROCESSING_H_INCLUDED |
@@ -37,7 +37,7 int check_mode_transition( unsigned char | |||
|
37 | 37 | int check_transition_date( unsigned int transitionCoarseTime ); |
|
38 | 38 | int stop_current_mode( void ); |
|
39 | 39 | int enter_mode( unsigned char mode , unsigned int transitionCoarseTime ); |
|
40 | int restart_science_tasks(); | |
|
40 | int restart_science_tasks(unsigned char lfrRequestedMode ); | |
|
41 | 41 | int suspend_science_tasks(); |
|
42 | 42 | void launch_waveform_picker(unsigned char mode , unsigned int transitionCoarseTime); |
|
43 | 43 | void launch_spectral_matrix( unsigned char mode ); |
@@ -9,6 +9,9 | |||
|
9 | 9 | #include "tm_lfr_tc_exe.h" |
|
10 | 10 | #include "fsw_misc.h" |
|
11 | 11 | |
|
12 | extern nb_sm_t nb_sm; | |
|
13 | extern nb_sm_before_bp_t nb_sm_before_bp; | |
|
14 | ||
|
12 | 15 | int action_load_common_par( ccsdsTelecommandPacket_t *TC ); |
|
13 | 16 | int action_load_normal_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time); |
|
14 | 17 | int action_load_burst_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time); |
@@ -16,6 +19,7 int action_load_sbm1_par(ccsdsTelecomman | |||
|
16 | 19 | int action_load_sbm2_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time); |
|
17 | 20 | int action_dump_par(rtems_id queue_id ); |
|
18 | 21 | |
|
22 | // NORMAL | |
|
19 | 23 | int set_sy_lfr_n_swf_l(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time); |
|
20 | 24 | int set_sy_lfr_n_swf_p( ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time ); |
|
21 | 25 | int set_sy_lfr_n_asm_p( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); |
@@ -23,6 +27,18 int set_sy_lfr_n_bp_p0( ccsdsTelecommand | |||
|
23 | 27 | int set_sy_lfr_n_bp_p1( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); |
|
24 | 28 | int set_sy_lfr_n_cwf_long_f3(ccsdsTelecommandPacket_t *TC, rtems_id queue_id); |
|
25 | 29 | |
|
30 | // BURST | |
|
31 | int set_sy_lfr_b_bp_p0( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); | |
|
32 | int set_sy_lfr_b_bp_p1( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); | |
|
33 | ||
|
34 | // SBM1 | |
|
35 | int set_sy_lfr_s1_bp_p0( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); | |
|
36 | int set_sy_lfr_s1_bp_p1( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); | |
|
37 | ||
|
38 | // SBM2 | |
|
39 | int set_sy_lfr_s2_bp_p0( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); | |
|
40 | int set_sy_lfr_s2_bp_p1( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); | |
|
41 | ||
|
26 | 42 | // TC_LFR_UPDATE_INFO |
|
27 | 43 | unsigned int check_update_info_hk_lfr_mode( unsigned char mode ); |
|
28 | 44 | unsigned int check_update_info_hk_tds_mode( unsigned char mode ); |
@@ -45,11 +45,16 volatile int wf_cont_f3_a [ (NB_SAMPL | |||
|
45 | 45 | volatile int wf_cont_f3_b [ (NB_SAMPLES_PER_SNAPSHOT) * NB_WORDS_SWF_BLK + TIME_OFFSET ] __attribute__((aligned(0x100))); |
|
46 | 46 | char wf_cont_f3_light[ (NB_SAMPLES_PER_SNAPSHOT) * NB_BYTES_CWF3_LIGHT_BLK + TIME_OFFSET_IN_BYTES ] __attribute__((aligned(0x100))); |
|
47 | 47 | |
|
48 | //*********************************** | |
|
48 | 49 | // SPECTRAL MATRICES GLOBAL VARIABLES |
|
50 | ||
|
51 | nb_sm_t nb_sm; | |
|
52 | nb_sm_before_bp_t nb_sm_before_bp; | |
|
53 | ||
|
49 | 54 | // alignment constraints for the spectral matrices buffers => the first data after the time (8 bytes) shall be aligned on 0x00 |
|
50 |
volatile int sm_f0[ NB_RING_NODES_ |
|
|
51 |
volatile int sm_f1[ NB_RING_NODES_ |
|
|
52 |
volatile int sm_f2[ NB_RING_NODES_ |
|
|
55 | volatile int sm_f0[ NB_RING_NODES_SM_F0 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); | |
|
56 | volatile int sm_f1[ NB_RING_NODES_SM_F1 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); | |
|
57 | volatile int sm_f2[ NB_RING_NODES_SM_F2 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); | |
|
53 | 58 | |
|
54 | 59 | // APB CONFIGURATION REGISTERS |
|
55 | 60 | time_management_regs_t *time_management_regs = (time_management_regs_t*) REGS_ADDR_TIME_MANAGEMENT; |
@@ -97,9 +97,8 rtems_task Init( rtems_task_argument ign | |||
|
97 | 97 | init_housekeeping_parameters(); |
|
98 | 98 | |
|
99 | 99 | init_waveform_rings(); // initialize the waveform rings |
|
100 |
init |
|
|
101 | init_bp_ring_sbm1_bp1(); // initialize basic parameter ring for SBM1 BP1 set | |
|
102 | init_bp_ring_sbm1_bp2(); // initialize basic parameter ring for SBM1 BP2 set | |
|
100 | SM_init_rings(); // initialize spectral matrices rings | |
|
101 | ASM_init_ring(); // initialize the average spectral matrix ring (just for burst, sbm1 and sbm2 asm @ f0 storage) | |
|
103 | 102 | |
|
104 | 103 | reset_wfp_burst_enable(); |
|
105 | 104 | reset_wfp_status(); |
@@ -363,6 +363,19 void getTime( unsigned char *time) | |||
|
363 | 363 | time[5] = (unsigned char) (time_management_regs->fine_time); |
|
364 | 364 | } |
|
365 | 365 | |
|
366 | unsigned long long int getTimeAsUnsignedLongLongInt( ) | |
|
367 | { | |
|
368 | /** This function write the current local time in the time buffer passed in argument. | |
|
369 | * | |
|
370 | */ | |
|
371 | unsigned long long int time; | |
|
372 | ||
|
373 | time = ( (unsigned long long int) (time_management_regs->coarse_time & 0x7fffffff) << 16 ) | |
|
374 | + time_management_regs->fine_time; | |
|
375 | ||
|
376 | return time; | |
|
377 | } | |
|
378 | ||
|
366 | 379 | void send_dumb_hk( void ) |
|
367 | 380 | { |
|
368 | 381 | Packet_TM_LFR_HK_t dummy_hk_packet; |
This diff has been collapsed as it changes many lines, (963 lines changed) Show them Hide them | |||
@@ -13,56 +13,426 | |||
|
13 | 13 | |
|
14 | 14 | //************************ |
|
15 | 15 | // spectral matrices rings |
|
16 |
ring_node_sm sm_ring_f0[ NB_RING_NODES_ |
|
|
17 |
ring_node_sm sm_ring_f1[ NB_RING_NODES_ |
|
|
18 |
ring_node_sm sm_ring_f2[ NB_RING_NODES_ |
|
|
16 | ring_node_sm sm_ring_f0[ NB_RING_NODES_SM_F0 ]; | |
|
17 | ring_node_sm sm_ring_f1[ NB_RING_NODES_SM_F1 ]; | |
|
18 | ring_node_sm sm_ring_f2[ NB_RING_NODES_SM_F2 ]; | |
|
19 | 19 | ring_node_sm *current_ring_node_sm_f0; |
|
20 | 20 | ring_node_sm *ring_node_for_averaging_sm_f0; |
|
21 | 21 | ring_node_sm *current_ring_node_sm_f1; |
|
22 | 22 | ring_node_sm *current_ring_node_sm_f2; |
|
23 | 23 | |
|
24 | //********************** | |
|
25 | // basic parameter rings | |
|
26 | ring_node_bp *current_node_sbm1_bp1_f0; | |
|
27 | ring_node_bp *current_node_sbm1_bp2_f0; | |
|
28 | ring_node_bp bp_ring_sbm1_bp1[ NB_RING_NODES_SBM1_BP1 ]; | |
|
29 | ring_node_bp bp_ring_sbm1_bp2[ NB_RING_NODES_SBM1_BP2 ]; | |
|
24 | ring_node_asm asm_ring_burst_sbm_f0[ NB_RING_NODES_ASM_BURST_SBM_F0 ]; | |
|
25 | ring_node_asm *current_ring_node_asm_burst_sbm_f0; | |
|
26 | ring_node_asm *ring_node_for_processing_asm_burst_sbm_f0; | |
|
30 | 27 | |
|
31 | 28 | //***** |
|
32 | 29 | // NORM |
|
33 | 30 | // F0 |
|
34 | 31 | float asm_norm_f0 [ TIME_OFFSET + TOTAL_SIZE_SM ]; |
|
35 | 32 | float asm_f0_reorganized [ TIME_OFFSET + TOTAL_SIZE_SM ]; |
|
36 |
char asm_f0_char |
|
|
33 | char asm_f0_char [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ]; | |
|
37 | 34 | float compressed_sm_norm_f0[ TIME_OFFSET + TOTAL_SIZE_COMPRESSED_ASM_F0 ]; |
|
38 | 35 | |
|
39 | 36 | //***** |
|
40 | 37 | // SBM1 |
|
41 |
float asm_sbm |
|
|
42 |
float compressed_sm_sbm |
|
|
38 | float asm_sbm_f0 [ TIME_OFFSET + TOTAL_SIZE_SM ]; | |
|
39 | float compressed_sm_sbm[ TIME_OFFSET + TOTAL_SIZE_COMPRESSED_ASM_SBM1 ]; | |
|
43 | 40 | |
|
44 | 41 | unsigned char LFR_BP1_F0[ TIME_OFFSET_IN_BYTES + TOTAL_SIZE_NORM_BP1_F0 * 2 ]; |
|
45 | 42 | unsigned char LFR_BP1_F1[ TIME_OFFSET_IN_BYTES + TOTAL_SIZE_NORM_BP1_F1 ]; |
|
46 | 43 | unsigned char LFR_BP1_F2[ TIME_OFFSET_IN_BYTES + TOTAL_SIZE_NORM_BP1_F2 ]; |
|
47 | 44 | |
|
48 | unsigned int nb_sm_f0; | |
|
45 | //*********************************************************** | |
|
46 | // Interrupt Service Routine for spectral matrices processing | |
|
47 | void reset_nb_sm_f0( unsigned char lfrMode ) | |
|
48 | { | |
|
49 | nb_sm.f0 = 0; | |
|
50 | nb_sm.norm_bp1_f0 = 0; | |
|
51 | nb_sm.norm_bp2_f0 = 0; | |
|
52 | nb_sm.norm_asm_f0 = 0; | |
|
53 | nb_sm.sbm_bp1_f0 = 0; | |
|
54 | nb_sm.sbm_bp2_f0 = 0; | |
|
55 | ||
|
56 | nb_sm_before_bp.norm_bp1_f0 = parameter_dump_packet.sy_lfr_n_bp_p0 * 96; | |
|
57 | nb_sm_before_bp.norm_bp2_f0 = parameter_dump_packet.sy_lfr_n_bp_p1 * 96; | |
|
58 | nb_sm_before_bp.norm_asm_f0 = (parameter_dump_packet.sy_lfr_n_asm_p[0] * 256 + parameter_dump_packet.sy_lfr_n_asm_p[1]) * 96; | |
|
59 | nb_sm_before_bp.sbm1_bp1_f0 = parameter_dump_packet.sy_lfr_s1_bp_p0 * 24; | |
|
60 | nb_sm_before_bp.sbm1_bp2_f0 = parameter_dump_packet.sy_lfr_s1_bp_p1 * 96; | |
|
61 | nb_sm_before_bp.sbm2_bp1_f0 = parameter_dump_packet.sy_lfr_s2_bp_p0 * 96; | |
|
62 | nb_sm_before_bp.sbm2_bp2_f0 = parameter_dump_packet.sy_lfr_s2_bp_p1 * 96; | |
|
63 | nb_sm_before_bp.burst_bp1_f0 = parameter_dump_packet.sy_lfr_b_bp_p0 * 96; | |
|
64 | nb_sm_before_bp.burst_bp2_f0 = parameter_dump_packet.sy_lfr_b_bp_p1 * 96; | |
|
65 | ||
|
66 | if (lfrMode == LFR_MODE_SBM1) | |
|
67 | { | |
|
68 | nb_sm_before_bp.burst_sbm_bp1_f0 = nb_sm_before_bp.sbm1_bp1_f0; | |
|
69 | nb_sm_before_bp.burst_sbm_bp2_f0 = nb_sm_before_bp.sbm1_bp2_f0; | |
|
70 | } | |
|
71 | else if (lfrMode == LFR_MODE_SBM2) | |
|
72 | { | |
|
73 | nb_sm_before_bp.burst_sbm_bp1_f0 = nb_sm_before_bp.sbm2_bp1_f0; | |
|
74 | nb_sm_before_bp.burst_sbm_bp2_f0 = nb_sm_before_bp.sbm2_bp2_f0; | |
|
75 | } | |
|
76 | else if (lfrMode == LFR_MODE_BURST) | |
|
77 | { | |
|
78 | nb_sm_before_bp.burst_sbm_bp1_f0 = nb_sm_before_bp.burst_bp1_f0; | |
|
79 | nb_sm_before_bp.burst_sbm_bp2_f0 = nb_sm_before_bp.burst_bp2_f0; | |
|
80 | } | |
|
81 | else | |
|
82 | { | |
|
83 | nb_sm_before_bp.burst_sbm_bp1_f0 = nb_sm_before_bp.burst_bp1_f0; | |
|
84 | nb_sm_before_bp.burst_sbm_bp2_f0 = nb_sm_before_bp.burst_bp2_f0; | |
|
85 | } | |
|
86 | } | |
|
87 | ||
|
88 | rtems_isr spectral_matrices_isr( rtems_vector_number vector ) | |
|
89 | { | |
|
90 | // rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 ); | |
|
91 | ||
|
92 | // if ( (spectral_matrix_regs->status & 0x1) == 0x01) | |
|
93 | // { | |
|
94 | // current_ring_node_sm_f0 = current_ring_node_sm_f0->next; | |
|
95 | // spectral_matrix_regs->matrixF0_Address0 = current_ring_node_sm_f0->buffer_address; | |
|
96 | // spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffffe; // 1110 | |
|
97 | // nb_sm_f0 = nb_sm_f0 + 1; | |
|
98 | // } | |
|
99 | // else if ( (spectral_matrix_regs->status & 0x2) == 0x02) | |
|
100 | // { | |
|
101 | // current_ring_node_sm_f0 = current_ring_node_sm_f0->next; | |
|
102 | // spectral_matrix_regs->matrixFO_Address1 = current_ring_node_sm_f0->buffer_address; | |
|
103 | // spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffffd; // 1101 | |
|
104 | // nb_sm_f0 = nb_sm_f0 + 1; | |
|
105 | // } | |
|
106 | ||
|
107 | // if ( (spectral_matrix_regs->status & 0x30) != 0x00) | |
|
108 | // { | |
|
109 | // rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 ); | |
|
110 | // spectral_matrix_regs->status = spectral_matrix_regs->status & 0xffffffcf; // 1100 1111 | |
|
111 | // } | |
|
112 | ||
|
113 | // spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffff3; // 0011 | |
|
114 | ||
|
115 | // if (nb_sm_f0 == (NB_SM_BEFORE_AVF0-1) ) | |
|
116 | // { | |
|
117 | // ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0; | |
|
118 | // if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) | |
|
119 | // { | |
|
120 | // rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 ); | |
|
121 | // } | |
|
122 | // nb_sm_f0 = 0; | |
|
123 | // } | |
|
124 | // else | |
|
125 | // { | |
|
126 | // nb_sm.nb_sm_f0 = nb_sm.nb_sm_f0 + 1; | |
|
127 | // } | |
|
128 | } | |
|
129 | ||
|
130 | rtems_isr spectral_matrices_isr_simu( rtems_vector_number vector ) | |
|
131 | { | |
|
132 | if (nb_sm.f0 == (NB_SM_BEFORE_AVF0-1) ) | |
|
133 | { | |
|
134 | ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0; | |
|
135 | if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) | |
|
136 | { | |
|
137 | rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 ); | |
|
138 | } | |
|
139 | nb_sm.f0 = 0; | |
|
140 | } | |
|
141 | else | |
|
142 | { | |
|
143 | nb_sm.f0 = nb_sm.f0 + 1; | |
|
144 | } | |
|
145 | } | |
|
146 | ||
|
147 | //************ | |
|
148 | // RTEMS TASKS | |
|
149 | ||
|
150 | rtems_task smiq_task( rtems_task_argument argument ) // process the Spectral Matrices IRQ | |
|
151 | { | |
|
152 | rtems_event_set event_out; | |
|
153 | ||
|
154 | BOOT_PRINTF("in SMIQ *** \n") | |
|
155 | ||
|
156 | while(1){ | |
|
157 | rtems_event_receive(RTEMS_EVENT_0, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT0 | |
|
158 | } | |
|
159 | } | |
|
160 | ||
|
161 | rtems_task avf0_task( rtems_task_argument lfrRequestedMode ) | |
|
162 | { | |
|
163 | int i; | |
|
164 | ||
|
165 | rtems_event_set event_out; | |
|
166 | rtems_event_set event_for_matr; | |
|
167 | rtems_status_code status; | |
|
168 | ring_node_sm *ring_node_tab[8]; | |
|
169 | unsigned long long int localTime; | |
|
170 | ||
|
171 | reset_nb_sm_f0( lfrRequestedMode ); // reset the sm counters that drive the BP and ASM computations / transmissions | |
|
172 | ||
|
173 | BOOT_PRINTF1("in AVFO *** lfrRequestedMode = %d\n", lfrRequestedMode) | |
|
174 | ||
|
175 | while(1){ | |
|
176 | rtems_event_receive(RTEMS_EVENT_0, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT0 | |
|
177 | ring_node_tab[NB_SM_BEFORE_AVF0-1] = ring_node_for_averaging_sm_f0; | |
|
178 | for ( i = 2; i < (NB_SM_BEFORE_AVF0+1); i++ ) | |
|
179 | { | |
|
180 | ring_node_for_averaging_sm_f0 = ring_node_for_averaging_sm_f0->previous; | |
|
181 | ring_node_tab[NB_SM_BEFORE_AVF0-i] = ring_node_for_averaging_sm_f0; | |
|
182 | } | |
|
183 | ||
|
184 | localTime = getTimeAsUnsignedLongLongInt( ); | |
|
185 | ||
|
186 | // compute the average and store it in the averaged_sm_f1 buffer | |
|
187 | SM_average( asm_norm_f0, current_ring_node_asm_burst_sbm_f0->asm_burst_sbm_f0, | |
|
188 | ring_node_tab, | |
|
189 | nb_sm.norm_bp1_f0, nb_sm.sbm_bp1_f0 ); | |
|
190 | ||
|
191 | localTime = getTimeAsUnsignedLongLongInt( ) - localTime; | |
|
192 | ||
|
193 | // update nb_average | |
|
194 | nb_sm.norm_bp1_f0 = nb_sm.norm_bp1_f0 + NB_SM_BEFORE_AVF0; | |
|
195 | nb_sm.norm_bp2_f0 = nb_sm.norm_bp2_f0 + NB_SM_BEFORE_AVF0; | |
|
196 | nb_sm.norm_asm_f0 = nb_sm.norm_asm_f0 + NB_SM_BEFORE_AVF0; | |
|
197 | nb_sm.sbm_bp1_f0 = nb_sm.sbm_bp1_f0 + NB_SM_BEFORE_AVF0; | |
|
198 | nb_sm.sbm_bp2_f0 = nb_sm.sbm_bp2_f0 + NB_SM_BEFORE_AVF0; | |
|
199 | ||
|
200 | //*********************************************************** | |
|
201 | // build a composite event that will be sent to the MATR task | |
|
202 | event_for_matr = 0x00; | |
|
203 | ||
|
204 | if (nb_sm.sbm_bp1_f0 == nb_sm_before_bp.burst_sbm_bp1_f0) | |
|
205 | { | |
|
206 | nb_sm.sbm_bp1_f0 = 0; | |
|
207 | // the ring node is ready for BP calculations | |
|
208 | ring_node_for_processing_asm_burst_sbm_f0 = current_ring_node_asm_burst_sbm_f0; | |
|
209 | // set another ring for the ASM storage | |
|
210 | current_ring_node_asm_burst_sbm_f0 = current_ring_node_asm_burst_sbm_f0->next; | |
|
211 | if ( (lfrCurrentMode == LFR_MODE_BURST) | |
|
212 | || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) ) | |
|
213 | { | |
|
214 | event_for_matr = event_for_matr | RTEMS_EVENT_BURST_SBM_BP1_F0; | |
|
215 | } | |
|
216 | } | |
|
217 | ||
|
218 | if (nb_sm.sbm_bp2_f0 == nb_sm_before_bp.burst_sbm_bp2_f0) | |
|
219 | { | |
|
220 | nb_sm.sbm_bp2_f0 = 0; | |
|
221 | if ( (lfrCurrentMode == LFR_MODE_BURST) | |
|
222 | || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) ) | |
|
223 | { | |
|
224 | event_for_matr = event_for_matr | RTEMS_EVENT_BURST_SBM_BP2_F0; | |
|
225 | } | |
|
226 | } | |
|
49 | 227 | |
|
50 | void init_sm_rings( void ) | |
|
228 | if (nb_sm.norm_bp1_f0 == nb_sm_before_bp.norm_bp1_f0) | |
|
229 | { | |
|
230 | nb_sm.norm_bp1_f0 = 0; | |
|
231 | if (lfrCurrentMode == LFR_MODE_NORMAL) | |
|
232 | { | |
|
233 | event_for_matr = event_for_matr | RTEMS_EVENT_NORM_BP1_F0; | |
|
234 | } | |
|
235 | } | |
|
236 | ||
|
237 | if (nb_sm.norm_bp2_f0 == nb_sm_before_bp.norm_bp2_f0) | |
|
238 | { | |
|
239 | nb_sm.norm_bp2_f0 = 0; | |
|
240 | if ( (lfrCurrentMode == LFR_MODE_NORMAL) | |
|
241 | || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) ) | |
|
242 | { | |
|
243 | event_for_matr = event_for_matr | RTEMS_EVENT_NORM_BP2_F0; | |
|
244 | } | |
|
245 | } | |
|
246 | ||
|
247 | if (nb_sm.norm_asm_f0 == nb_sm_before_bp.norm_asm_f0) | |
|
248 | { | |
|
249 | nb_sm.norm_asm_f0 = 0; | |
|
250 | if ( (lfrCurrentMode == LFR_MODE_NORMAL) | |
|
251 | || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) ) | |
|
252 | { | |
|
253 | // PRINTF1("%lld\n", localTime) | |
|
254 | event_for_matr = event_for_matr | RTEMS_EVENT_NORM_ASM_F0; | |
|
255 | } | |
|
256 | } | |
|
257 | ||
|
258 | //********************************* | |
|
259 | // send the composite event to MATR | |
|
260 | status = rtems_event_send( Task_id[TASKID_MATR], event_for_matr ); | |
|
261 | if (status != RTEMS_SUCCESSFUL) { | |
|
262 | printf("in AVF0 *** Error sending RTEMS_EVENT_0, code %d\n", status); | |
|
263 | } | |
|
264 | } | |
|
265 | } | |
|
266 | ||
|
267 | rtems_task matr_task( rtems_task_argument lfrRequestedMode ) | |
|
268 | { | |
|
269 | spw_ioctl_pkt_send spw_ioctl_send_ASM; | |
|
270 | rtems_event_set event_out; | |
|
271 | rtems_status_code status; | |
|
272 | rtems_id queue_id; | |
|
273 | Header_TM_LFR_SCIENCE_ASM_t headerASM; | |
|
274 | bp_packet_with_spare current_node_norm_bp1_f0; | |
|
275 | bp_packet current_node_norm_bp2_f0; | |
|
276 | bp_packet current_node_sbm_bp1_f0; | |
|
277 | bp_packet current_node_sbm_bp2_f0; | |
|
278 | unsigned long long int localTime; | |
|
279 | ||
|
280 | ASM_init_header( &headerASM ); | |
|
281 | ||
|
282 | //************* | |
|
283 | // NORM headers | |
|
284 | BP_init_header_with_spare( ¤t_node_norm_bp1_f0.header, | |
|
285 | APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP1_F0, | |
|
286 | PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0, NB_BINS_COMPRESSED_SM_F0 ); | |
|
287 | BP_init_header( ¤t_node_norm_bp2_f0.header, | |
|
288 | APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP2_F0, | |
|
289 | PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0, NB_BINS_COMPRESSED_SM_F0); | |
|
290 | ||
|
291 | //**************************** | |
|
292 | // BURST SBM1 and SBM2 headers | |
|
293 | if ( (lfrRequestedMode == LFR_MODE_BURST) | |
|
294 | || (lfrRequestedMode == LFR_MODE_NORMAL) || (lfrRequestedMode == LFR_MODE_STANDBY) ) | |
|
295 | { | |
|
296 | BP_init_header( ¤t_node_sbm_bp1_f0.header, | |
|
297 | APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP1_F0, | |
|
298 | PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0); | |
|
299 | BP_init_header( ¤t_node_sbm_bp2_f0.header, | |
|
300 | APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP2_F0, | |
|
301 | PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0); | |
|
302 | } | |
|
303 | else if ( lfrRequestedMode == LFR_MODE_SBM1 ) | |
|
304 | { | |
|
305 | BP_init_header( ¤t_node_sbm_bp1_f0.header, | |
|
306 | APID_TM_SCIENCE_SBM1_SBM2, SID_SBM1_BP1_F0, | |
|
307 | PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0); | |
|
308 | BP_init_header( ¤t_node_sbm_bp2_f0.header, | |
|
309 | APID_TM_SCIENCE_SBM1_SBM2, SID_SBM1_BP2_F0, | |
|
310 | PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0); | |
|
311 | } | |
|
312 | else if ( lfrRequestedMode == LFR_MODE_SBM2 ) | |
|
313 | { | |
|
314 | BP_init_header( ¤t_node_sbm_bp1_f0.header, | |
|
315 | APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP1_F0, | |
|
316 | PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0); | |
|
317 | BP_init_header( ¤t_node_sbm_bp2_f0.header, | |
|
318 | APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP2_F0, | |
|
319 | PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0); | |
|
320 | } | |
|
321 | else | |
|
322 | { | |
|
323 | PRINTF1("ERR *** in MATR *** unexpected lfrRequestedMode passed as argument = %d\n", (unsigned int) lfrRequestedMode) | |
|
324 | } | |
|
325 | ||
|
326 | status = get_message_queue_id_send( &queue_id ); | |
|
327 | if (status != RTEMS_SUCCESSFUL) | |
|
328 | { | |
|
329 | PRINTF1("in MATR *** ERR get_message_queue_id_send %d\n", status) | |
|
330 | } | |
|
331 | ||
|
332 | BOOT_PRINTF1("in MATR *** lfrRequestedMode = %d\n", lfrRequestedMode) | |
|
333 | ||
|
334 | while(1){ | |
|
335 | rtems_event_receive( RTEMS_EVENT_NORM_BP1_F0 | RTEMS_EVENT_NORM_BP2_F0 | RTEMS_EVENT_NORM_ASM_F0 | |
|
336 | | RTEMS_EVENT_BURST_SBM_BP1_F0 | RTEMS_EVENT_BURST_SBM_BP2_F0, | |
|
337 | RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out); | |
|
338 | localTime = getTimeAsUnsignedLongLongInt( ); | |
|
339 | //**************** | |
|
340 | //**************** | |
|
341 | // BURST SBM1 SBM2 | |
|
342 | //**************** | |
|
343 | //**************** | |
|
344 | if ( event_out & RTEMS_EVENT_BURST_SBM_BP1_F0 ) | |
|
345 | { | |
|
346 | // 1) compress the matrix for Basic Parameters calculation | |
|
347 | ASM_compress_reorganize_and_divide( current_ring_node_asm_burst_sbm_f0->asm_burst_sbm_f0, compressed_sm_sbm, | |
|
348 | nb_sm_before_bp.burst_sbm_bp1_f0, | |
|
349 | NB_BINS_COMPRESSED_SM_SBM_F0, NB_BINS_TO_AVERAGE_ASM_SBM_F0, | |
|
350 | ASM_F0_INDICE_START); | |
|
351 | // 2) compute the BP1 set | |
|
352 | ||
|
353 | // 3) send the BP1 set | |
|
354 | set_time( current_node_sbm_bp1_f0.header.time, (unsigned char *) &compressed_sm_sbm ); | |
|
355 | set_time( current_node_sbm_bp1_f0.header.acquisitionTime, (unsigned char *) &compressed_sm_sbm ); | |
|
356 | BP_send( (char *) ¤t_node_sbm_bp1_f0.header, queue_id, | |
|
357 | PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0 + PACKET_LENGTH_DELTA); | |
|
358 | // 4) compute the BP2 set if needed | |
|
359 | if ( event_out & RTEMS_EVENT_BURST_SBM_BP2_F0 ) | |
|
360 | { | |
|
361 | // 1) compute the BP2 set | |
|
362 | ||
|
363 | // 2) send the BP2 set | |
|
364 | set_time( current_node_sbm_bp2_f0.header.time, (unsigned char *) &compressed_sm_sbm ); | |
|
365 | set_time( current_node_sbm_bp2_f0.header.acquisitionTime, (unsigned char *) &compressed_sm_sbm ); | |
|
366 | BP_send( (char *) ¤t_node_sbm_bp2_f0.header, queue_id, | |
|
367 | PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0 + PACKET_LENGTH_DELTA); | |
|
368 | } | |
|
369 | } | |
|
370 | ||
|
371 | //***** | |
|
372 | //***** | |
|
373 | // NORM | |
|
374 | //***** | |
|
375 | //***** | |
|
376 | if (event_out & RTEMS_EVENT_NORM_BP1_F0) | |
|
377 | { | |
|
378 | // 1) compress the matrix for Basic Parameters calculation | |
|
379 | ASM_compress_reorganize_and_divide( asm_norm_f0, compressed_sm_norm_f0, | |
|
380 | nb_sm_before_bp.norm_bp1_f0, | |
|
381 | NB_BINS_COMPRESSED_SM_F0, NB_BINS_TO_AVERAGE_ASM_F0, | |
|
382 | ASM_F0_INDICE_START ); | |
|
383 | // 2) compute the BP1 set | |
|
384 | ||
|
385 | // 3) send the BP1 set | |
|
386 | set_time( current_node_norm_bp1_f0.header.time, (unsigned char *) &compressed_sm_norm_f0 ); | |
|
387 | set_time( current_node_norm_bp1_f0.header.acquisitionTime, (unsigned char *) &compressed_sm_norm_f0 ); | |
|
388 | BP_send( (char *) ¤t_node_norm_bp1_f0.header, queue_id, | |
|
389 | PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0 + PACKET_LENGTH_DELTA); | |
|
390 | if (event_out & RTEMS_EVENT_NORM_BP2_F0) | |
|
391 | { | |
|
392 | // 1) compute the BP2 set | |
|
393 | ||
|
394 | // 2) send the BP2 set | |
|
395 | set_time( current_node_norm_bp2_f0.header.time, (unsigned char *) &compressed_sm_norm_f0 ); | |
|
396 | set_time( current_node_norm_bp2_f0.header.acquisitionTime, (unsigned char *) &compressed_sm_norm_f0 ); | |
|
397 | BP_send( (char *) ¤t_node_norm_bp2_f0.header, queue_id, | |
|
398 | PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0 + PACKET_LENGTH_DELTA); | |
|
399 | } | |
|
400 | } | |
|
401 | ||
|
402 | if (event_out & RTEMS_EVENT_NORM_ASM_F0) | |
|
403 | { | |
|
404 | // 1) reorganize the ASM and divide | |
|
405 | ASM_reorganize_and_divide( asm_norm_f0, asm_f0_reorganized, NB_SM_BEFORE_NORM_BP1_F0 ); | |
|
406 | // 2) convert the float array in a char array | |
|
407 | ASM_convert( asm_f0_reorganized, asm_f0_char); | |
|
408 | // 3) send the spectral matrix packets | |
|
409 | ASM_send( &headerASM, asm_f0_char, SID_NORM_ASM_F0, &spw_ioctl_send_ASM, queue_id); | |
|
410 | // localTime = getTimeAsUnsignedLongLongInt( ) - localTime; | |
|
411 | // PRINTF1("in MATR *** %lld\n", localTime) | |
|
412 | } | |
|
413 | ||
|
414 | } | |
|
415 | } | |
|
416 | ||
|
417 | //****************** | |
|
418 | // Spectral Matrices | |
|
419 | ||
|
420 | void SM_init_rings( void ) | |
|
51 | 421 | { |
|
52 | 422 | unsigned char i; |
|
53 | 423 | |
|
54 | 424 | // F0 RING |
|
55 | 425 | sm_ring_f0[0].next = (ring_node_sm*) &sm_ring_f0[1]; |
|
56 |
sm_ring_f0[0].previous = (ring_node_sm*) &sm_ring_f0[NB_RING_NODES_ |
|
|
426 | sm_ring_f0[0].previous = (ring_node_sm*) &sm_ring_f0[NB_RING_NODES_SM_F0-1]; | |
|
57 | 427 | sm_ring_f0[0].buffer_address = |
|
58 | 428 | (int) &sm_f0[ 0 ]; |
|
59 | 429 | |
|
60 |
sm_ring_f0[NB_RING_NODES_ |
|
|
61 |
sm_ring_f0[NB_RING_NODES_ |
|
|
62 |
sm_ring_f0[NB_RING_NODES_ |
|
|
63 |
(int) &sm_f0[ (NB_RING_NODES_ |
|
|
430 | sm_ring_f0[NB_RING_NODES_SM_F0-1].next = (ring_node_sm*) &sm_ring_f0[0]; | |
|
431 | sm_ring_f0[NB_RING_NODES_SM_F0-1].previous = (ring_node_sm*) &sm_ring_f0[NB_RING_NODES_SM_F0-2]; | |
|
432 | sm_ring_f0[NB_RING_NODES_SM_F0-1].buffer_address = | |
|
433 | (int) &sm_f0[ (NB_RING_NODES_SM_F0-1) * TOTAL_SIZE_SM ]; | |
|
64 | 434 | |
|
65 |
for(i=1; i<NB_RING_NODES_ |
|
|
435 | for(i=1; i<NB_RING_NODES_SM_F0-1; i++) | |
|
66 | 436 | { |
|
67 | 437 | sm_ring_f0[i].next = (ring_node_sm*) &sm_ring_f0[i+1]; |
|
68 | 438 | sm_ring_f0[i].previous = (ring_node_sm*) &sm_ring_f0[i-1]; |
@@ -72,16 +442,16 void init_sm_rings( void ) | |||
|
72 | 442 | |
|
73 | 443 | // F1 RING |
|
74 | 444 | sm_ring_f1[0].next = (ring_node_sm*) &sm_ring_f1[1]; |
|
75 |
sm_ring_f1[0].previous = (ring_node_sm*) &sm_ring_f1[NB_RING_NODES_ |
|
|
445 | sm_ring_f1[0].previous = (ring_node_sm*) &sm_ring_f1[NB_RING_NODES_SM_F1-1]; | |
|
76 | 446 | sm_ring_f1[0].buffer_address = |
|
77 | 447 | (int) &sm_f1[ 0 ]; |
|
78 | 448 | |
|
79 |
sm_ring_f1[NB_RING_NODES_ |
|
|
80 |
sm_ring_f1[NB_RING_NODES_ |
|
|
81 |
sm_ring_f1[NB_RING_NODES_ |
|
|
82 |
(int) &sm_f1[ (NB_RING_NODES_ |
|
|
449 | sm_ring_f1[NB_RING_NODES_SM_F1-1].next = (ring_node_sm*) &sm_ring_f1[0]; | |
|
450 | sm_ring_f1[NB_RING_NODES_SM_F1-1].previous = (ring_node_sm*) &sm_ring_f1[NB_RING_NODES_SM_F1-2]; | |
|
451 | sm_ring_f1[NB_RING_NODES_SM_F1-1].buffer_address = | |
|
452 | (int) &sm_f1[ (NB_RING_NODES_SM_F1-1) * TOTAL_SIZE_SM ]; | |
|
83 | 453 | |
|
84 |
for(i=1; i<NB_RING_NODES_ |
|
|
454 | for(i=1; i<NB_RING_NODES_SM_F1-1; i++) | |
|
85 | 455 | { |
|
86 | 456 | sm_ring_f1[i].next = (ring_node_sm*) &sm_ring_f1[i+1]; |
|
87 | 457 | sm_ring_f1[i].previous = (ring_node_sm*) &sm_ring_f1[i-1]; |
@@ -91,16 +461,16 void init_sm_rings( void ) | |||
|
91 | 461 | |
|
92 | 462 | // F2 RING |
|
93 | 463 | sm_ring_f2[0].next = (ring_node_sm*) &sm_ring_f2[1]; |
|
94 |
sm_ring_f2[0].previous = (ring_node_sm*) &sm_ring_f2[NB_RING_NODES_ |
|
|
464 | sm_ring_f2[0].previous = (ring_node_sm*) &sm_ring_f2[NB_RING_NODES_SM_F2-1]; | |
|
95 | 465 | sm_ring_f2[0].buffer_address = |
|
96 | 466 | (int) &sm_f2[ 0 ]; |
|
97 | 467 | |
|
98 |
sm_ring_f2[NB_RING_NODES_ |
|
|
99 |
sm_ring_f2[NB_RING_NODES_ |
|
|
100 |
sm_ring_f2[NB_RING_NODES_ |
|
|
101 |
(int) &sm_f2[ (NB_RING_NODES_ |
|
|
468 | sm_ring_f2[NB_RING_NODES_SM_F2-1].next = (ring_node_sm*) &sm_ring_f2[0]; | |
|
469 | sm_ring_f2[NB_RING_NODES_SM_F2-1].previous = (ring_node_sm*) &sm_ring_f2[NB_RING_NODES_SM_F2-2]; | |
|
470 | sm_ring_f2[NB_RING_NODES_SM_F2-1].buffer_address = | |
|
471 | (int) &sm_f2[ (NB_RING_NODES_SM_F2-1) * TOTAL_SIZE_SM ]; | |
|
102 | 472 | |
|
103 |
for(i=1; i<NB_RING_NODES_ |
|
|
473 | for(i=1; i<NB_RING_NODES_SM_F2-1; i++) | |
|
104 | 474 | { |
|
105 | 475 | sm_ring_f2[i].next = (ring_node_sm*) &sm_ring_f2[i+1]; |
|
106 | 476 | sm_ring_f2[i].previous = (ring_node_sm*) &sm_ring_f2[i-1]; |
@@ -116,7 +486,26 void init_sm_rings( void ) | |||
|
116 | 486 | DEBUG_PRINTF1("spectral_matrix_regs->matrixF0_Address0 @%x\n", spectral_matrix_regs->matrixF0_Address0) |
|
117 | 487 | } |
|
118 | 488 | |
|
119 | void reset_current_sm_ring_nodes( void ) | |
|
489 | void ASM_init_ring( void ) | |
|
490 | { | |
|
491 | unsigned char i; | |
|
492 | ||
|
493 | asm_ring_burst_sbm_f0[0].next = (ring_node_asm*) &asm_ring_burst_sbm_f0[1]; | |
|
494 | asm_ring_burst_sbm_f0[0].previous = (ring_node_asm*) &asm_ring_burst_sbm_f0[NB_RING_NODES_ASM_BURST_SBM_F0-1]; | |
|
495 | ||
|
496 | asm_ring_burst_sbm_f0[NB_RING_NODES_ASM_BURST_SBM_F0-1].next | |
|
497 | = (ring_node_asm*) &asm_ring_burst_sbm_f0[0]; | |
|
498 | asm_ring_burst_sbm_f0[NB_RING_NODES_ASM_BURST_SBM_F0-1].previous | |
|
499 | = (ring_node_asm*) &asm_ring_burst_sbm_f0[NB_RING_NODES_ASM_BURST_SBM_F0-2]; | |
|
500 | ||
|
501 | for(i=1; i<NB_RING_NODES_ASM_BURST_SBM_F0-1; i++) | |
|
502 | { | |
|
503 | asm_ring_burst_sbm_f0[i].next = (ring_node_asm*) &asm_ring_burst_sbm_f0[i+1]; | |
|
504 | asm_ring_burst_sbm_f0[i].previous = (ring_node_asm*) &asm_ring_burst_sbm_f0[i-1]; | |
|
505 | } | |
|
506 | } | |
|
507 | ||
|
508 | void SM_reset_current_ring_nodes( void ) | |
|
120 | 509 | { |
|
121 | 510 | current_ring_node_sm_f0 = sm_ring_f0; |
|
122 | 511 | current_ring_node_sm_f1 = sm_ring_f1; |
@@ -125,319 +514,51 void reset_current_sm_ring_nodes( void ) | |||
|
125 | 514 | ring_node_for_averaging_sm_f0 = sm_ring_f0; |
|
126 | 515 | } |
|
127 | 516 | |
|
128 |
void reset_current_ |
|
|
129 | { | |
|
130 | current_node_sbm1_bp1_f0 = bp_ring_sbm1_bp1; | |
|
131 | current_node_sbm1_bp2_f0 = bp_ring_sbm1_bp2; | |
|
132 | } | |
|
133 | ||
|
134 | //*********************************************************** | |
|
135 | // Interrupt Service Routine for spectral matrices processing | |
|
136 | void reset_nb_sm_f0( void ) | |
|
137 | { | |
|
138 | nb_sm_f0 = 0; | |
|
139 | } | |
|
140 | ||
|
141 | rtems_isr spectral_matrices_isr( rtems_vector_number vector ) | |
|
517 | void ASM_reset_current_ring_node( void ) | |
|
142 | 518 | { |
|
143 | rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 ); | |
|
144 | ||
|
145 | if ( (spectral_matrix_regs->status & 0x1) == 0x01) | |
|
146 | { | |
|
147 | current_ring_node_sm_f0 = current_ring_node_sm_f0->next; | |
|
148 | spectral_matrix_regs->matrixF0_Address0 = current_ring_node_sm_f0->buffer_address; | |
|
149 | spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffffe; // 1110 | |
|
150 | nb_sm_f0 = nb_sm_f0 + 1; | |
|
151 | } | |
|
152 | else if ( (spectral_matrix_regs->status & 0x2) == 0x02) | |
|
153 | { | |
|
154 | current_ring_node_sm_f0 = current_ring_node_sm_f0->next; | |
|
155 | spectral_matrix_regs->matrixFO_Address1 = current_ring_node_sm_f0->buffer_address; | |
|
156 | spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffffd; // 1101 | |
|
157 | nb_sm_f0 = nb_sm_f0 + 1; | |
|
158 | } | |
|
159 | ||
|
160 | if ( (spectral_matrix_regs->status & 0x30) != 0x00) | |
|
161 | { | |
|
162 | rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 ); | |
|
163 | spectral_matrix_regs->status = spectral_matrix_regs->status & 0xffffffcf; // 1100 1111 | |
|
164 | } | |
|
165 | ||
|
166 | spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffff3; // 0011 | |
|
167 | ||
|
168 | if (nb_sm_f0 == (NB_SM_BEFORE_AVF0-1) ) | |
|
169 | { | |
|
170 | ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0; | |
|
171 | if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) | |
|
172 | { | |
|
173 | rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 ); | |
|
174 | } | |
|
175 | nb_sm_f0 = 0; | |
|
176 | } | |
|
177 | else | |
|
178 | { | |
|
179 | nb_sm_f0 = nb_sm_f0 + 1; | |
|
180 | } | |
|
181 | } | |
|
182 | ||
|
183 | rtems_isr spectral_matrices_isr_simu( rtems_vector_number vector ) | |
|
184 | { | |
|
185 | if (nb_sm_f0 == (NB_SM_BEFORE_AVF0-1) ) | |
|
186 | { | |
|
187 | ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0; | |
|
188 | if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) | |
|
189 | { | |
|
190 | rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 ); | |
|
191 | } | |
|
192 | nb_sm_f0 = 0; | |
|
193 | } | |
|
194 | else | |
|
195 | { | |
|
196 | nb_sm_f0 = nb_sm_f0 + 1; | |
|
197 | } | |
|
198 | } | |
|
199 | ||
|
200 | //************ | |
|
201 | // RTEMS TASKS | |
|
202 | ||
|
203 | rtems_task smiq_task(rtems_task_argument argument) // process the Spectral Matrices IRQ | |
|
204 | { | |
|
205 | rtems_event_set event_out; | |
|
206 | ||
|
207 | BOOT_PRINTF("in SMIQ *** \n") | |
|
208 | ||
|
209 | while(1){ | |
|
210 | rtems_event_receive(RTEMS_EVENT_0, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT0 | |
|
211 | } | |
|
519 | current_ring_node_asm_burst_sbm_f0 = asm_ring_burst_sbm_f0; | |
|
520 | ring_node_for_processing_asm_burst_sbm_f0 = asm_ring_burst_sbm_f0; | |
|
212 | 521 | } |
|
213 | 522 | |
|
214 | rtems_task avf0_task(rtems_task_argument argument) | |
|
215 | { | |
|
216 | int i; | |
|
217 | static unsigned int nb_sm_norm_bp1_f0; | |
|
218 | static unsigned int nb_sm_norm_bp2_f0; | |
|
219 | static unsigned int nb_sm_norm_asm_f0; | |
|
220 | static unsigned int nb_sm_sbm1_bp1_f0; | |
|
221 | static unsigned int nb_sm_sbm1_bp2_f0; | |
|
222 | rtems_event_set event_out; | |
|
223 | rtems_event_set event_for_matr; | |
|
224 | rtems_status_code status; | |
|
225 | ring_node_sm *ring_node_tab[8]; | |
|
226 | ||
|
227 | nb_sm_norm_bp1_f0 = 0; | |
|
228 | nb_sm_norm_bp2_f0 = 0; | |
|
229 | nb_sm_norm_asm_f0 = 0; | |
|
230 | nb_sm_sbm1_bp1_f0 = 0; | |
|
231 | nb_sm_sbm1_bp2_f0 = 0; | |
|
232 | ||
|
233 | BOOT_PRINTF("in AVFO *** \n") | |
|
234 | ||
|
235 | while(1){ | |
|
236 | rtems_event_receive(RTEMS_EVENT_0, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT0 | |
|
237 | ring_node_tab[NB_SM_BEFORE_AVF0-1] = ring_node_for_averaging_sm_f0; | |
|
238 | for ( i = 2; i < (NB_SM_BEFORE_AVF0+1); i++ ) | |
|
239 | { | |
|
240 | ring_node_for_averaging_sm_f0 = ring_node_for_averaging_sm_f0->previous; | |
|
241 | ring_node_tab[NB_SM_BEFORE_AVF0-i] = ring_node_for_averaging_sm_f0; | |
|
242 | } | |
|
243 | ||
|
244 | // copy time information in the asm_f0 buffer | |
|
245 | asm_norm_f0[0] = ring_node_tab[7]->coarseTime; | |
|
246 | asm_norm_f0[1] = ring_node_tab[7]->fineTime; | |
|
247 | asm_sbm1_f0[0] = ring_node_tab[7]->coarseTime; | |
|
248 | asm_sbm1_f0[1] = ring_node_tab[7]->fineTime; | |
|
249 | ||
|
250 | // compute the average and store it in the averaged_sm_f1 buffer | |
|
251 | SM_average( asm_norm_f0, asm_sbm1_f0, | |
|
252 | ring_node_tab, | |
|
253 | nb_sm_norm_bp1_f0, nb_sm_sbm1_bp1_f0 ); | |
|
254 | ||
|
255 | // update nb_average | |
|
256 | nb_sm_norm_bp1_f0 = nb_sm_norm_bp1_f0 + NB_SM_BEFORE_AVF0; | |
|
257 | nb_sm_norm_bp2_f0 = nb_sm_norm_bp2_f0 + NB_SM_BEFORE_AVF0; | |
|
258 | nb_sm_norm_asm_f0 = nb_sm_norm_asm_f0 + NB_SM_BEFORE_AVF0; | |
|
259 | nb_sm_sbm1_bp1_f0 = nb_sm_sbm1_bp1_f0 + NB_SM_BEFORE_AVF0; | |
|
260 | nb_sm_sbm1_bp2_f0 = nb_sm_sbm1_bp2_f0 + NB_SM_BEFORE_AVF0; | |
|
261 | ||
|
262 | //*********************************************************** | |
|
263 | // build a composite event that will be sent to the MATR task | |
|
264 | event_for_matr = 0x00; | |
|
265 | ||
|
266 | if (nb_sm_sbm1_bp1_f0 == NB_SM_BEFORE_SBM1_BP1_F0) | |
|
267 | { | |
|
268 | nb_sm_sbm1_bp1_f0 = 0; | |
|
269 | if (lfrCurrentMode == LFR_MODE_SBM1) | |
|
270 | { | |
|
271 | event_for_matr = event_for_matr | RTEMS_EVENT_SBM1_BP1_F0; | |
|
272 | } | |
|
273 | } | |
|
274 | ||
|
275 | if (nb_sm_sbm1_bp2_f0 == NB_SM_BEFORE_SBM1_BP2_F0) | |
|
276 | { | |
|
277 | nb_sm_sbm1_bp2_f0 = 0; | |
|
278 | if (lfrCurrentMode == LFR_MODE_SBM1) | |
|
279 | { | |
|
280 | event_for_matr = event_for_matr | RTEMS_EVENT_SBM1_BP2_F0; | |
|
281 | } | |
|
282 | } | |
|
283 | ||
|
284 | if (nb_sm_norm_bp1_f0 == NB_SM_BEFORE_NORM_BP1_F0) { | |
|
285 | nb_sm_norm_bp1_f0 = 0; | |
|
286 | if (lfrCurrentMode == LFR_MODE_NORMAL) | |
|
287 | { | |
|
288 | event_for_matr = event_for_matr | RTEMS_EVENT_NORM_BP1_F0; | |
|
289 | } | |
|
290 | } | |
|
291 | ||
|
292 | if (nb_sm_norm_bp2_f0 == NB_SM_BEFORE_NORM_BP2_F0) { | |
|
293 | nb_sm_norm_bp2_f0 = 0; | |
|
294 | if (lfrCurrentMode == LFR_MODE_NORMAL) | |
|
295 | { | |
|
296 | event_for_matr = event_for_matr | RTEMS_EVENT_NORM_BP2_F0; | |
|
297 | } | |
|
298 | } | |
|
299 | ||
|
300 | if (nb_sm_norm_asm_f0 == NB_SM_BEFORE_NORM_ASM_F0) { | |
|
301 | nb_sm_norm_asm_f0 = 0; | |
|
302 | if (lfrCurrentMode == LFR_MODE_NORMAL) | |
|
303 | { | |
|
304 | event_for_matr = event_for_matr | RTEMS_EVENT_NORM_ASM_F0; | |
|
305 | } | |
|
306 | } | |
|
307 | ||
|
308 | //********************************* | |
|
309 | // send the composite event to MATR | |
|
310 | status = rtems_event_send( Task_id[TASKID_MATR], event_for_matr ); | |
|
311 | if (status != RTEMS_SUCCESSFUL) { | |
|
312 | printf("in AVF0 *** Error sending RTEMS_EVENT_0, code %d\n", status); | |
|
313 | } | |
|
314 | } | |
|
315 | } | |
|
316 | ||
|
317 | rtems_task matr_task(rtems_task_argument argument) | |
|
523 | void ASM_init_header( Header_TM_LFR_SCIENCE_ASM_t *header) | |
|
318 | 524 | { |
|
319 | spw_ioctl_pkt_send spw_ioctl_send_ASM; | |
|
320 | rtems_event_set event_out; | |
|
321 | rtems_status_code status; | |
|
322 | rtems_id queue_id; | |
|
323 | Header_TM_LFR_SCIENCE_ASM_t headerASM; | |
|
324 | ring_node_bp_with_spare current_node_norm_bp1_f0; | |
|
325 | ring_node_bp current_node_norm_bp2_f0; | |
|
326 | ||
|
327 | init_header_asm( &headerASM ); | |
|
328 | init_header_bp_with_spare( ¤t_node_norm_bp1_f0.header, | |
|
329 | APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP1_F0, | |
|
330 | PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0, NB_BINS_COMPRESSED_SM_F0 ); | |
|
331 | init_header_bp( ¤t_node_norm_bp2_f0.header, | |
|
332 | APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP2_F0, | |
|
333 | PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0, NB_BINS_COMPRESSED_SM_F0); | |
|
334 | ||
|
335 | status = get_message_queue_id_send( &queue_id ); | |
|
336 | if (status != RTEMS_SUCCESSFUL) | |
|
337 | { | |
|
338 | PRINTF1("in MATR *** ERR get_message_queue_id_send %d\n", status) | |
|
339 | } | |
|
340 | ||
|
341 | BOOT_PRINTF("in MATR *** \n") | |
|
342 | ||
|
343 | while(1){ | |
|
344 | rtems_event_receive( RTEMS_EVENT_NORM_BP1_F0 | RTEMS_EVENT_NORM_BP2_F0 | RTEMS_EVENT_NORM_ASM_F0 | |
|
345 | | RTEMS_EVENT_SBM1_BP1_F0 | RTEMS_EVENT_SBM1_BP2_F0, | |
|
346 | RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out); | |
|
347 | //***** | |
|
348 | //***** | |
|
349 | // SBM1 | |
|
350 | //***** | |
|
351 | //***** | |
|
352 | if (event_out & RTEMS_EVENT_SBM1_BP1_F0) | |
|
353 | { | |
|
354 | // 1) compress the matrix for Basic Parameters calculation | |
|
355 | ASM_compress_reorganize_and_divide( asm_sbm1_f0, compressed_sm_sbm1, | |
|
356 | NB_SM_BEFORE_SBM1_BP1_F0, | |
|
357 | NB_BINS_COMPRESSED_SM_SBM1_F0, NB_BINS_TO_AVERAGE_ASM_SBM1_F0, | |
|
358 | ASM_F0_INDICE_START); | |
|
359 | // 2) compute the BP1 set | |
|
360 | ||
|
361 | // 3) send the BP1 set | |
|
362 | set_time( current_node_sbm1_bp1_f0->header.time, | |
|
363 | current_node_sbm1_bp1_f0->coarseTime, current_node_sbm1_bp1_f0->fineTime); | |
|
364 | set_time( current_node_sbm1_bp1_f0->header.acquisitionTime, | |
|
365 | current_node_sbm1_bp1_f0->coarseTime, current_node_sbm1_bp1_f0->fineTime); | |
|
366 | BP_send( (char *) ¤t_node_sbm1_bp1_f0->header, queue_id, | |
|
367 | PACKET_LENGTH_TM_LFR_SCIENCE_SBM1_BP1_F0 + PACKET_LENGTH_DELTA); | |
|
368 | // 4) update current_node_sbm1_bp1_f0 | |
|
369 | current_node_sbm1_bp1_f0 = current_node_sbm1_bp1_f0->next; | |
|
370 | if (event_out & RTEMS_EVENT_SBM1_BP2_F0) | |
|
371 | { | |
|
372 | // 1) compute the BP2 set | |
|
373 | ||
|
374 | // 2) send the BP2 set | |
|
375 | set_time( current_node_sbm1_bp2_f0->header.time, | |
|
376 | current_node_sbm1_bp2_f0->coarseTime, current_node_sbm1_bp2_f0->fineTime); | |
|
377 | set_time( current_node_sbm1_bp2_f0->header.acquisitionTime, | |
|
378 | current_node_sbm1_bp2_f0->coarseTime, current_node_sbm1_bp2_f0->fineTime); | |
|
379 | BP_send( (char *) ¤t_node_sbm1_bp2_f0->header, queue_id, | |
|
380 | PACKET_LENGTH_TM_LFR_SCIENCE_SBM1_BP1_F0 + PACKET_LENGTH_DELTA); | |
|
381 | } | |
|
382 | } | |
|
383 | ||
|
384 | //***** | |
|
385 | //***** | |
|
386 | // NORM | |
|
387 | //***** | |
|
388 | //***** | |
|
389 | if (event_out & RTEMS_EVENT_NORM_BP1_F0) | |
|
390 | { | |
|
391 | // 1) compress the matrix for Basic Parameters calculation | |
|
392 | ASM_compress_reorganize_and_divide( asm_norm_f0, compressed_sm_norm_f0, | |
|
393 | NB_SM_BEFORE_NORM_BP1_F0, | |
|
394 | NB_BINS_COMPRESSED_SM_F0, NB_BINS_TO_AVERAGE_ASM_F0, | |
|
395 | ASM_F0_INDICE_START ); | |
|
396 | // 2) compute the BP1 set | |
|
397 | ||
|
398 | // 3) send the BP1 set | |
|
399 | set_time( current_node_norm_bp1_f0.header.time, | |
|
400 | current_node_norm_bp1_f0.coarseTime, current_node_norm_bp1_f0.fineTime); | |
|
401 | set_time( current_node_norm_bp1_f0.header.acquisitionTime, | |
|
402 | current_node_norm_bp1_f0.coarseTime, current_node_norm_bp1_f0.fineTime); | |
|
403 | BP_send( (char *) ¤t_node_norm_bp1_f0.header, queue_id, | |
|
404 | PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0 + PACKET_LENGTH_DELTA); | |
|
405 | if (event_out & RTEMS_EVENT_NORM_BP2_F0) | |
|
406 | { | |
|
407 | // 1) compute the BP2 set | |
|
408 | ||
|
409 | // 2) send the BP2 set | |
|
410 | set_time( current_node_norm_bp2_f0.header.time, | |
|
411 | current_node_norm_bp2_f0.coarseTime, current_node_norm_bp2_f0.fineTime); | |
|
412 | set_time( current_node_norm_bp2_f0.header.acquisitionTime, | |
|
413 | current_node_norm_bp2_f0.coarseTime, current_node_norm_bp2_f0.fineTime); | |
|
414 | BP_send( (char *) ¤t_node_norm_bp2_f0.header, queue_id, | |
|
415 | PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0 + PACKET_LENGTH_DELTA); | |
|
416 | } | |
|
417 | } | |
|
418 | ||
|
419 | if (event_out & RTEMS_EVENT_NORM_ASM_F0) | |
|
420 | { | |
|
421 | // 1) reorganize the ASM and divide | |
|
422 | ASM_reorganize_and_divide( asm_norm_f0, asm_f0_reorganized, NB_SM_BEFORE_NORM_BP1_F0 ); | |
|
423 | // 2) convert the float array in a char array | |
|
424 | ASM_convert( asm_f0_reorganized, asm_f0_char); | |
|
425 | // 3) send the spectral matrix packets | |
|
426 | ASM_send( &headerASM, asm_f0_char, SID_NORM_ASM_F0, &spw_ioctl_send_ASM, queue_id); | |
|
427 | } | |
|
428 | ||
|
429 | } | |
|
525 | header->targetLogicalAddress = CCSDS_DESTINATION_ID; | |
|
526 | header->protocolIdentifier = CCSDS_PROTOCOLE_ID; | |
|
527 | header->reserved = 0x00; | |
|
528 | header->userApplication = CCSDS_USER_APP; | |
|
529 | header->packetID[0] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST >> 8); | |
|
530 | header->packetID[1] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST); | |
|
531 | header->packetSequenceControl[0] = 0xc0; | |
|
532 | header->packetSequenceControl[1] = 0x00; | |
|
533 | header->packetLength[0] = 0x00; | |
|
534 | header->packetLength[1] = 0x00; | |
|
535 | // DATA FIELD HEADER | |
|
536 | header->spare1_pusVersion_spare2 = 0x10; | |
|
537 | header->serviceType = TM_TYPE_LFR_SCIENCE; // service type | |
|
538 | header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype | |
|
539 | header->destinationID = TM_DESTINATION_ID_GROUND; | |
|
540 | // AUXILIARY DATA HEADER | |
|
541 | header->sid = 0x00; | |
|
542 | header->biaStatusInfo = 0x00; | |
|
543 | header->pa_lfr_pkt_cnt_asm = 0x00; | |
|
544 | header->pa_lfr_pkt_nr_asm = 0x00; | |
|
545 | header->time[0] = 0x00; | |
|
546 | header->time[0] = 0x00; | |
|
547 | header->time[0] = 0x00; | |
|
548 | header->time[0] = 0x00; | |
|
549 | header->time[0] = 0x00; | |
|
550 | header->time[0] = 0x00; | |
|
551 | header->pa_lfr_asm_blk_nr[0] = 0x00; // BLK_NR MSB | |
|
552 | header->pa_lfr_asm_blk_nr[1] = 0x00; // BLK_NR LSB | |
|
430 | 553 | } |
|
431 | 554 | |
|
432 | //***************************** | |
|
433 | // Spectral matrices processing | |
|
434 | ||
|
435 | 555 | void SM_average( float *averaged_spec_mat_f0, float *averaged_spec_mat_f1, |
|
436 | 556 | ring_node_sm *ring_node_tab[], |
|
437 | 557 | unsigned int nbAverageNormF0, unsigned int nbAverageSBM1F0 ) |
|
438 | 558 | { |
|
439 | 559 | float sum; |
|
440 | 560 | unsigned int i; |
|
561 | unsigned char *ptr; | |
|
441 | 562 | |
|
442 | 563 | for(i=0; i<TOTAL_SIZE_SM; i++) |
|
443 | 564 | { |
@@ -470,6 +591,27 void SM_average( float *averaged_spec_ma | |||
|
470 | 591 | PRINTF2("ERR *** in SM_average *** unexpected parameters %d %d\n", nbAverageNormF0, nbAverageSBM1F0) |
|
471 | 592 | } |
|
472 | 593 | } |
|
594 | if ( (nbAverageNormF0 == 0) && (nbAverageSBM1F0 == 0) ) | |
|
595 | { | |
|
596 | ptr = (unsigned char *) averaged_spec_mat_f0; | |
|
597 | ptr[0] = (unsigned char) (time_management_regs->coarse_time >> 24); | |
|
598 | ptr[1] = (unsigned char) (time_management_regs->coarse_time >> 16); | |
|
599 | ptr[2] = (unsigned char) (time_management_regs->coarse_time >> 8 ); | |
|
600 | ptr[3] = (unsigned char) (time_management_regs->coarse_time ); | |
|
601 | ptr[4] = (unsigned char) (time_management_regs->fine_time >> 24); | |
|
602 | ptr[5] = (unsigned char) (time_management_regs->fine_time >> 16); | |
|
603 | ptr[6] = (unsigned char) (time_management_regs->fine_time >> 8 ); | |
|
604 | ptr[7] = (unsigned char) (time_management_regs->fine_time ); | |
|
605 | ptr = (unsigned char *) averaged_spec_mat_f1; | |
|
606 | ptr[0] = (unsigned char) (time_management_regs->coarse_time >> 24); | |
|
607 | ptr[1] = (unsigned char) (time_management_regs->coarse_time >> 16); | |
|
608 | ptr[2] = (unsigned char) (time_management_regs->coarse_time >> 8 ); | |
|
609 | ptr[3] = (unsigned char) (time_management_regs->coarse_time ); | |
|
610 | ptr[4] = (unsigned char) (time_management_regs->fine_time >> 24); | |
|
611 | ptr[5] = (unsigned char) (time_management_regs->fine_time >> 16); | |
|
612 | ptr[6] = (unsigned char) (time_management_regs->fine_time >> 8 ); | |
|
613 | ptr[7] = (unsigned char) (time_management_regs->fine_time ); | |
|
614 | } | |
|
473 | 615 | } |
|
474 | 616 | |
|
475 | 617 | void ASM_reorganize_and_divide( float *averaged_spec_mat, float *averaged_spec_mat_reorganized, float divider ) |
@@ -500,6 +642,11 void ASM_compress_reorganize_and_divide( | |||
|
500 | 642 | int offsetCompressed; |
|
501 | 643 | int k; |
|
502 | 644 | |
|
645 | // copy the time information | |
|
646 | compressed_spec_mat[ 0 ] = averaged_spec_mat[ 0 ]; | |
|
647 | compressed_spec_mat[ 1 ] = averaged_spec_mat[ 1 ]; | |
|
648 | ||
|
649 | // build data | |
|
503 | 650 | for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++) |
|
504 | 651 | { |
|
505 | 652 | for( frequencyBin = 0; frequencyBin < nbBinsCompressedMatrix; frequencyBin++ ) |
@@ -616,111 +763,10 void ASM_send(Header_TM_LFR_SCIENCE_ASM_ | |||
|
616 | 763 | } |
|
617 | 764 | } |
|
618 | 765 | |
|
619 | void BP_send(char *data, rtems_id queue_id, unsigned int nbBytesToSend ) | |
|
620 | { | |
|
621 | rtems_status_code status; | |
|
622 | ||
|
623 | // SEND PACKET | |
|
624 | status = rtems_message_queue_send( queue_id, data, nbBytesToSend); | |
|
625 | if (status != RTEMS_SUCCESSFUL) | |
|
626 | { | |
|
627 | printf("ERR *** in BP_send *** ERR %d\n", (int) status); | |
|
628 | } | |
|
629 | } | |
|
630 | ||
|
631 | void init_header_asm( Header_TM_LFR_SCIENCE_ASM_t *header) | |
|
632 | { | |
|
633 | header->targetLogicalAddress = CCSDS_DESTINATION_ID; | |
|
634 | header->protocolIdentifier = CCSDS_PROTOCOLE_ID; | |
|
635 | header->reserved = 0x00; | |
|
636 | header->userApplication = CCSDS_USER_APP; | |
|
637 | header->packetID[0] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST >> 8); | |
|
638 | header->packetID[1] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST); | |
|
639 | header->packetSequenceControl[0] = 0xc0; | |
|
640 | header->packetSequenceControl[1] = 0x00; | |
|
641 | header->packetLength[0] = 0x00; | |
|
642 | header->packetLength[1] = 0x00; | |
|
643 | // DATA FIELD HEADER | |
|
644 | header->spare1_pusVersion_spare2 = 0x10; | |
|
645 | header->serviceType = TM_TYPE_LFR_SCIENCE; // service type | |
|
646 | header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype | |
|
647 | header->destinationID = TM_DESTINATION_ID_GROUND; | |
|
648 | // AUXILIARY DATA HEADER | |
|
649 | header->sid = 0x00; | |
|
650 | header->biaStatusInfo = 0x00; | |
|
651 | header->pa_lfr_pkt_cnt_asm = 0x00; | |
|
652 | header->pa_lfr_pkt_nr_asm = 0x00; | |
|
653 | header->time[0] = 0x00; | |
|
654 | header->time[0] = 0x00; | |
|
655 | header->time[0] = 0x00; | |
|
656 | header->time[0] = 0x00; | |
|
657 | header->time[0] = 0x00; | |
|
658 | header->time[0] = 0x00; | |
|
659 | header->pa_lfr_asm_blk_nr[0] = 0x00; // BLK_NR MSB | |
|
660 | header->pa_lfr_asm_blk_nr[1] = 0x00; // BLK_NR LSB | |
|
661 | } | |
|
662 | ||
|
663 | void init_bp_ring_sbm1_bp1( void ) | |
|
664 | { | |
|
665 | unsigned int i; | |
|
666 | ||
|
667 | //******** | |
|
668 | // F0 RING | |
|
669 | bp_ring_sbm1_bp1[0].next = (ring_node_bp*) &bp_ring_sbm1_bp1[1]; | |
|
670 | bp_ring_sbm1_bp1[0].previous = (ring_node_bp*) &bp_ring_sbm1_bp1[NB_RING_NODES_SBM1_BP1-1]; | |
|
766 | //***************** | |
|
767 | // Basic Parameters | |
|
671 | 768 | |
|
672 | bp_ring_sbm1_bp1[NB_RING_NODES_SBM1_BP1-1].next = (ring_node_bp*) &bp_ring_sbm1_bp1[0]; | |
|
673 | bp_ring_sbm1_bp1[NB_RING_NODES_SBM1_BP1-1].previous = (ring_node_bp*) &bp_ring_sbm1_bp1[NB_RING_NODES_SBM1_BP1-2]; | |
|
674 | ||
|
675 | for(i=1; i<NB_RING_NODES_SBM1_BP1-1; i++) | |
|
676 | { | |
|
677 | bp_ring_sbm1_bp1[i].next = (ring_node_bp*) &bp_ring_sbm1_bp1[i+1]; | |
|
678 | bp_ring_sbm1_bp1[i].previous = (ring_node_bp*) &bp_ring_sbm1_bp1[i-1]; | |
|
679 | } | |
|
680 | // | |
|
681 | //******** | |
|
682 | ||
|
683 | for (i=0; i<NB_RING_NODES_SBM1_BP1; i++) | |
|
684 | { | |
|
685 | init_header_bp( &bp_ring_sbm1_bp1[ i ].header, | |
|
686 | APID_TM_SCIENCE_SBM1_SBM2, SID_SBM1_BP1_F0, | |
|
687 | PACKET_LENGTH_TM_LFR_SCIENCE_SBM1_BP1_F0, NB_BINS_COMPRESSED_SM_SBM1_F0 | |
|
688 | ); | |
|
689 | bp_ring_sbm1_bp1[ i ].status = 0; | |
|
690 | } | |
|
691 | } | |
|
692 | ||
|
693 | void init_bp_ring_sbm1_bp2( void ) | |
|
694 | { | |
|
695 | unsigned int i; | |
|
696 | ||
|
697 | //******** | |
|
698 | // F0 RING | |
|
699 | bp_ring_sbm1_bp2[0].next = (ring_node_bp*) &bp_ring_sbm1_bp2[1]; | |
|
700 | bp_ring_sbm1_bp2[0].previous = (ring_node_bp*) &bp_ring_sbm1_bp2[NB_RING_NODES_SBM1_BP2-1]; | |
|
701 | ||
|
702 | bp_ring_sbm1_bp2[NB_RING_NODES_SBM1_BP2-1].next = (ring_node_bp*) &bp_ring_sbm1_bp2[0]; | |
|
703 | bp_ring_sbm1_bp2[NB_RING_NODES_SBM1_BP2-1].previous = (ring_node_bp*) &bp_ring_sbm1_bp2[NB_RING_NODES_SBM1_BP2-2]; | |
|
704 | ||
|
705 | for(i=1; i<NB_RING_NODES_SBM1_BP2-1; i++) | |
|
706 | { | |
|
707 | bp_ring_sbm1_bp2[i].next = (ring_node_bp*) &bp_ring_sbm1_bp2[i+1]; | |
|
708 | bp_ring_sbm1_bp2[i].previous = (ring_node_bp*) &bp_ring_sbm1_bp2[i-1]; | |
|
709 | } | |
|
710 | // | |
|
711 | //******** | |
|
712 | ||
|
713 | for (i=0; i<NB_RING_NODES_SBM1_BP2; i++) | |
|
714 | { | |
|
715 | init_header_bp( &bp_ring_sbm1_bp2[ i ].header, | |
|
716 | APID_TM_SCIENCE_SBM1_SBM2, SID_SBM1_BP2_F0, | |
|
717 | PACKET_LENGTH_TM_LFR_SCIENCE_SBM1_BP2_F0, NB_BINS_COMPRESSED_SM_SBM1_F0 | |
|
718 | ); | |
|
719 | bp_ring_sbm1_bp2[ i ].status = 0; | |
|
720 | } | |
|
721 | } | |
|
722 | ||
|
723 | void init_header_bp( Header_TM_LFR_SCIENCE_BP_t *header, | |
|
769 | void BP_init_header( Header_TM_LFR_SCIENCE_BP_t *header, | |
|
724 | 770 | unsigned int apid, unsigned char sid, |
|
725 | 771 | unsigned int packetLength, unsigned char blkNr ) |
|
726 | 772 | { |
@@ -752,7 +798,7 void init_header_bp( Header_TM_LFR_SCIEN | |||
|
752 | 798 | header->pa_lfr_bp_blk_nr[1] = blkNr; // BLK_NR LSB |
|
753 | 799 | } |
|
754 | 800 | |
|
755 |
void init_header |
|
|
801 | void BP_init_header_with_spare(Header_TM_LFR_SCIENCE_BP_with_spare_t *header, | |
|
756 | 802 | unsigned int apid, unsigned char sid, |
|
757 | 803 | unsigned int packetLength , unsigned char blkNr) |
|
758 | 804 | { |
@@ -784,6 +830,21 void init_header_bp_with_spare(Header_TM | |||
|
784 | 830 | header->pa_lfr_bp_blk_nr[1] = blkNr; // BLK_NR LSB |
|
785 | 831 | } |
|
786 | 832 | |
|
833 | void BP_send(char *data, rtems_id queue_id, unsigned int nbBytesToSend ) | |
|
834 | { | |
|
835 | rtems_status_code status; | |
|
836 | ||
|
837 | // SEND PACKET | |
|
838 | status = rtems_message_queue_send( queue_id, data, nbBytesToSend); | |
|
839 | if (status != RTEMS_SUCCESSFUL) | |
|
840 | { | |
|
841 | printf("ERR *** in BP_send *** ERR %d\n", (int) status); | |
|
842 | } | |
|
843 | } | |
|
844 | ||
|
845 | //****************** | |
|
846 | // general functions | |
|
847 | ||
|
787 | 848 | void reset_spectral_matrix_regs( void ) |
|
788 | 849 | { |
|
789 | 850 | /** This function resets the spectral matrices module registers. |
@@ -808,17 +869,21 void reset_spectral_matrix_regs( void ) | |||
|
808 | 869 | spectral_matrix_regs->matrixF2_Address = current_ring_node_sm_f2->buffer_address; |
|
809 | 870 | } |
|
810 | 871 | |
|
811 | //****************** | |
|
812 | // general functions | |
|
813 | ||
|
814 | void set_time( unsigned char *time, unsigned int coarseTime, unsigned int fineTime ) | |
|
872 | void set_time( unsigned char *time, unsigned char * timeInBuffer ) | |
|
815 | 873 | { |
|
816 | time[0] = (unsigned char) (coarseTime>>24); | |
|
817 | time[1] = (unsigned char) (coarseTime>>16); | |
|
818 | time[2] = (unsigned char) (coarseTime>>8); | |
|
819 | time[3] = (unsigned char) (coarseTime); | |
|
820 | time[4] = (unsigned char) (fineTime>>8); | |
|
821 | time[5] = (unsigned char) (fineTime); | |
|
874 | // time[0] = timeInBuffer[2]; | |
|
875 | // time[1] = timeInBuffer[3]; | |
|
876 | // time[2] = timeInBuffer[0]; | |
|
877 | // time[3] = timeInBuffer[1]; | |
|
878 | // time[4] = timeInBuffer[6]; | |
|
879 | // time[5] = timeInBuffer[7]; | |
|
880 | ||
|
881 | time[0] = timeInBuffer[0]; | |
|
882 | time[1] = timeInBuffer[1]; | |
|
883 | time[2] = timeInBuffer[2]; | |
|
884 | time[3] = timeInBuffer[3]; | |
|
885 | time[4] = timeInBuffer[6]; | |
|
886 | time[5] = timeInBuffer[7]; | |
|
822 | 887 | } |
|
823 | 888 | |
|
824 | 889 |
@@ -530,7 +530,7 int enter_mode( unsigned char mode, unsi | |||
|
530 | 530 | rtems_cpu_usage_reset(); |
|
531 | 531 | maxCount = 0; |
|
532 | 532 | #endif |
|
533 | status = restart_science_tasks(); | |
|
533 | status = restart_science_tasks( mode ); | |
|
534 | 534 | launch_waveform_picker( mode, transitionCoarseTime ); |
|
535 | 535 | launch_spectral_matrix_simu( mode ); |
|
536 | 536 | } |
@@ -559,7 +559,7 int enter_mode( unsigned char mode, unsi | |||
|
559 | 559 | return status; |
|
560 | 560 | } |
|
561 | 561 | |
|
562 | int restart_science_tasks() | |
|
562 | int restart_science_tasks(unsigned char lfrRequestedMode ) | |
|
563 | 563 | { |
|
564 | 564 | /** This function is used to restart all science tasks. |
|
565 | 565 | * |
@@ -573,12 +573,12 int restart_science_tasks() | |||
|
573 | 573 | * |
|
574 | 574 | */ |
|
575 | 575 | |
|
576 |
rtems_status_code status[ |
|
|
576 | rtems_status_code status[7]; | |
|
577 | 577 | rtems_status_code ret; |
|
578 | 578 | |
|
579 | 579 | ret = RTEMS_SUCCESSFUL; |
|
580 | 580 | |
|
581 |
status[0] = rtems_task_restart( Task_id[TASKID_AVF0], |
|
|
581 | status[0] = rtems_task_restart( Task_id[TASKID_AVF0], lfrRequestedMode ); | |
|
582 | 582 | if (status[0] != RTEMS_SUCCESSFUL) |
|
583 | 583 | { |
|
584 | 584 | PRINTF1("in restart_science_task *** 0 ERR %d\n", status[0]) |
@@ -608,8 +608,15 int restart_science_tasks() | |||
|
608 | 608 | PRINTF1("in restart_science_task *** 5 ERR %d\n", status[5]) |
|
609 | 609 | } |
|
610 | 610 | |
|
611 | status[6] = rtems_task_restart( Task_id[TASKID_MATR], lfrRequestedMode ); | |
|
612 | if (status[6] != RTEMS_SUCCESSFUL) | |
|
613 | { | |
|
614 | PRINTF1("in restart_science_task *** 6 ERR %d\n", status[6]) | |
|
615 | } | |
|
616 | ||
|
611 | 617 | if ( (status[0] != RTEMS_SUCCESSFUL) || (status[2] != RTEMS_SUCCESSFUL) || |
|
612 |
(status[3] != RTEMS_SUCCESSFUL) || (status[4] != RTEMS_SUCCESSFUL) || |
|
|
618 | (status[3] != RTEMS_SUCCESSFUL) || (status[4] != RTEMS_SUCCESSFUL) || | |
|
619 | (status[5] != RTEMS_SUCCESSFUL) || (status[6] != RTEMS_SUCCESSFUL) ) | |
|
613 | 620 | { |
|
614 | 621 | ret = RTEMS_UNSATISFIED; |
|
615 | 622 | } |
@@ -697,9 +704,8 void launch_waveform_picker( unsigned ch | |||
|
697 | 704 | |
|
698 | 705 | void launch_spectral_matrix( unsigned char mode ) |
|
699 | 706 | { |
|
700 | reset_nb_sm_f0(); | |
|
701 |
reset_current_ |
|
|
702 | reset_current_bp_ring_nodes(); | |
|
707 | SM_reset_current_ring_nodes(); | |
|
708 | ASM_reset_current_ring_node(); | |
|
703 | 709 | reset_spectral_matrix_regs(); |
|
704 | 710 | |
|
705 | 711 | struct grgpio_regs_str *grgpio_regs = (struct grgpio_regs_str *) REGS_ADDR_GRGPIO; |
@@ -739,9 +745,8 void set_run_matrix_spectral( unsigned c | |||
|
739 | 745 | |
|
740 | 746 | void launch_spectral_matrix_simu( unsigned char mode ) |
|
741 | 747 | { |
|
742 | reset_nb_sm_f0(); | |
|
743 |
reset_current_ |
|
|
744 | reset_current_bp_ring_nodes(); | |
|
748 | SM_reset_current_ring_nodes(); | |
|
749 | ASM_reset_current_ring_node(); | |
|
745 | 750 | reset_spectral_matrix_regs(); |
|
746 | 751 | |
|
747 | 752 | // Spectral Matrices simulator |
@@ -41,6 +41,9 int action_load_normal_par(ccsdsTelecomm | |||
|
41 | 41 | int result; |
|
42 | 42 | int flag; |
|
43 | 43 | rtems_status_code status; |
|
44 | unsigned char sy_lfr_n_bp_p0; | |
|
45 | unsigned char sy_lfr_n_bp_p1; | |
|
46 | float aux; | |
|
44 | 47 | |
|
45 | 48 | flag = LFR_SUCCESSFUL; |
|
46 | 49 | |
@@ -83,6 +86,20 int action_load_normal_par(ccsdsTelecomm | |||
|
83 | 86 | } |
|
84 | 87 | } |
|
85 | 88 | |
|
89 | //**************************************************************** | |
|
90 | // check the consistency between sy_lfr_n_bp_p0 and sy_lfr_n_bp_p1 | |
|
91 | if (flag == LFR_SUCCESSFUL) | |
|
92 | { | |
|
93 | sy_lfr_n_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P0 ]; | |
|
94 | sy_lfr_n_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P1 ]; | |
|
95 | aux = ( (float ) sy_lfr_n_bp_p1 / sy_lfr_n_bp_p0 ) - floor(sy_lfr_n_bp_p1 / sy_lfr_n_bp_p0); | |
|
96 | if (aux != 0) | |
|
97 | { | |
|
98 | status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_BP_P0+10, sy_lfr_n_bp_p0 ); | |
|
99 | flag = LFR_DEFAULT; | |
|
100 | } | |
|
101 | } | |
|
102 | ||
|
86 | 103 | //*************** |
|
87 | 104 | // sy_lfr_n_bp_p0 |
|
88 | 105 | if (flag == LFR_SUCCESSFUL) |
@@ -129,24 +146,56 int action_load_burst_par(ccsdsTelecomma | |||
|
129 | 146 | */ |
|
130 | 147 | |
|
131 | 148 | int result; |
|
132 | unsigned char lfrMode; | |
|
149 | int flag; | |
|
133 | 150 | rtems_status_code status; |
|
151 | unsigned char sy_lfr_b_bp_p0; | |
|
152 | unsigned char sy_lfr_b_bp_p1; | |
|
153 | float aux; | |
|
134 | 154 | |
|
135 |
|
|
|
136 | lfrMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4; | |
|
155 | flag = LFR_SUCCESSFUL; | |
|
137 | 156 | |
|
138 | if ( lfrMode == LFR_MODE_BURST ) { | |
|
157 | if ( lfrCurrentMode == LFR_MODE_BURST ) { | |
|
139 | 158 | status = send_tm_lfr_tc_exe_not_executable( TC, queue_id ); |
|
140 | 159 | result = LFR_DEFAULT; |
|
141 | 160 | } |
|
142 | else { | |
|
143 | parameter_dump_packet.sy_lfr_b_bp_p0 = TC->dataAndCRC[0]; | |
|
144 | parameter_dump_packet.sy_lfr_b_bp_p1 = TC->dataAndCRC[1]; | |
|
145 | 161 | |
|
146 | result = LFR_SUCCESSFUL; | |
|
162 | //**************************************************************** | |
|
163 | // check the consistency between sy_lfr_b_bp_p0 and sy_lfr_b_bp_p1 | |
|
164 | if (flag == LFR_SUCCESSFUL) | |
|
165 | { | |
|
166 | sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ]; | |
|
167 | sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ]; | |
|
168 | aux = ( (float ) sy_lfr_b_bp_p1 / sy_lfr_b_bp_p0 ) - floor(sy_lfr_b_bp_p1 / sy_lfr_b_bp_p0); | |
|
169 | if (aux != 0) | |
|
170 | { | |
|
171 | status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_B_BP_P0+10, sy_lfr_b_bp_p0 ); | |
|
172 | flag = LFR_DEFAULT; | |
|
173 | } | |
|
147 | 174 | } |
|
148 | 175 | |
|
149 | return result; | |
|
176 | //*************** | |
|
177 | // sy_lfr_b_bp_p0 | |
|
178 | if (flag == LFR_SUCCESSFUL) | |
|
179 | { | |
|
180 | result = set_sy_lfr_b_bp_p0( TC, queue_id ); | |
|
181 | if (result != LFR_SUCCESSFUL) | |
|
182 | { | |
|
183 | flag = LFR_DEFAULT; | |
|
184 | } | |
|
185 | } | |
|
186 | ||
|
187 | //*************** | |
|
188 | // sy_lfr_b_bp_p1 | |
|
189 | if (flag == LFR_SUCCESSFUL) | |
|
190 | { | |
|
191 | result = set_sy_lfr_b_bp_p1( TC, queue_id ); | |
|
192 | if (result != LFR_SUCCESSFUL) | |
|
193 | { | |
|
194 | flag = LFR_DEFAULT; | |
|
195 | } | |
|
196 | } | |
|
197 | ||
|
198 | return flag; | |
|
150 | 199 | } |
|
151 | 200 | |
|
152 | 201 | int action_load_sbm1_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time) |
@@ -157,25 +206,58 int action_load_sbm1_par(ccsdsTelecomman | |||
|
157 | 206 | * @param queue_id is the id of the queue which handles TM related to this execution step |
|
158 | 207 | * |
|
159 | 208 | */ |
|
160 | int result; | |
|
161 | unsigned char lfrMode; | |
|
162 | rtems_status_code status; | |
|
163 | 209 | |
|
164 | result = LFR_DEFAULT; | |
|
165 | lfrMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4; | |
|
210 | int result; | |
|
211 | int flag; | |
|
212 | rtems_status_code status; | |
|
213 | unsigned char sy_lfr_s1_bp_p0; | |
|
214 | unsigned char sy_lfr_s1_bp_p1; | |
|
215 | float aux; | |
|
166 | 216 | |
|
167 | if ( lfrMode == LFR_MODE_SBM1 ) { | |
|
217 | flag = LFR_SUCCESSFUL; | |
|
218 | ||
|
219 | if ( lfrCurrentMode == LFR_MODE_SBM1 ) { | |
|
168 | 220 | status = send_tm_lfr_tc_exe_not_executable( TC, queue_id ); |
|
169 | 221 | result = LFR_DEFAULT; |
|
170 | 222 | } |
|
171 | else { | |
|
172 | parameter_dump_packet.sy_lfr_s1_bp_p0 = TC->dataAndCRC[0]; | |
|
173 | parameter_dump_packet.sy_lfr_s1_bp_p1 = TC->dataAndCRC[1]; | |
|
174 | 223 | |
|
175 | result = LFR_SUCCESSFUL; | |
|
224 | //****************************************************************** | |
|
225 | // check the consistency between sy_lfr_s1_bp_p0 and sy_lfr_s1_bp_p1 | |
|
226 | if (flag == LFR_SUCCESSFUL) | |
|
227 | { | |
|
228 | sy_lfr_s1_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P0 ]; | |
|
229 | sy_lfr_s1_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P1 ]; | |
|
230 | aux = ( (float ) sy_lfr_s1_bp_p1 / (sy_lfr_s1_bp_p0*0.25) ) - floor(sy_lfr_s1_bp_p1 / (sy_lfr_s1_bp_p0*0.25)); | |
|
231 | if (aux != 0) | |
|
232 | { | |
|
233 | status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S1_BP_P0+10, sy_lfr_s1_bp_p0 ); | |
|
234 | flag = LFR_DEFAULT; | |
|
235 | } | |
|
176 | 236 | } |
|
177 | 237 | |
|
178 | return result; | |
|
238 | //*************** | |
|
239 | // sy_lfr_s1_bp_p0 | |
|
240 | if (flag == LFR_SUCCESSFUL) | |
|
241 | { | |
|
242 | result = set_sy_lfr_s1_bp_p0( TC, queue_id ); | |
|
243 | if (result != LFR_SUCCESSFUL) | |
|
244 | { | |
|
245 | flag = LFR_DEFAULT; | |
|
246 | } | |
|
247 | } | |
|
248 | ||
|
249 | //*************** | |
|
250 | // sy_lfr_s1_bp_p1 | |
|
251 | if (flag == LFR_SUCCESSFUL) | |
|
252 | { | |
|
253 | result = set_sy_lfr_s1_bp_p1( TC, queue_id ); | |
|
254 | if (result != LFR_SUCCESSFUL) | |
|
255 | { | |
|
256 | flag = LFR_DEFAULT; | |
|
257 | } | |
|
258 | } | |
|
259 | ||
|
260 | return flag; | |
|
179 | 261 | } |
|
180 | 262 | |
|
181 | 263 | int action_load_sbm2_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time) |
@@ -188,24 +270,56 int action_load_sbm2_par(ccsdsTelecomman | |||
|
188 | 270 | */ |
|
189 | 271 | |
|
190 | 272 | int result; |
|
191 | unsigned char lfrMode; | |
|
273 | int flag; | |
|
192 | 274 | rtems_status_code status; |
|
275 | unsigned char sy_lfr_s2_bp_p0; | |
|
276 | unsigned char sy_lfr_s2_bp_p1; | |
|
277 | float aux; | |
|
193 | 278 | |
|
194 |
|
|
|
195 | lfrMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4; | |
|
279 | flag = LFR_SUCCESSFUL; | |
|
196 | 280 | |
|
197 | if ( lfrMode == LFR_MODE_SBM2 ) { | |
|
281 | if ( lfrCurrentMode == LFR_MODE_SBM2 ) { | |
|
198 | 282 | status = send_tm_lfr_tc_exe_not_executable( TC, queue_id ); |
|
199 | 283 | result = LFR_DEFAULT; |
|
200 | 284 | } |
|
201 | else { | |
|
202 | parameter_dump_packet.sy_lfr_s2_bp_p0 = TC->dataAndCRC[0]; | |
|
203 | parameter_dump_packet.sy_lfr_s2_bp_p1 = TC->dataAndCRC[1]; | |
|
204 | 285 | |
|
205 | result = LFR_SUCCESSFUL; | |
|
286 | //****************************************************************** | |
|
287 | // check the consistency between sy_lfr_s2_bp_p0 and sy_lfr_s2_bp_p1 | |
|
288 | if (flag == LFR_SUCCESSFUL) | |
|
289 | { | |
|
290 | sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ]; | |
|
291 | sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ]; | |
|
292 | aux = ( (float ) sy_lfr_s2_bp_p1 / sy_lfr_s2_bp_p0 ) - floor(sy_lfr_s2_bp_p1 / sy_lfr_s2_bp_p0); | |
|
293 | if (aux != 0) | |
|
294 | { | |
|
295 | status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S2_BP_P0+10, sy_lfr_s2_bp_p0 ); | |
|
296 | flag = LFR_DEFAULT; | |
|
297 | } | |
|
206 | 298 | } |
|
207 | 299 | |
|
208 | return result; | |
|
300 | //*************** | |
|
301 | // sy_lfr_s2_bp_p0 | |
|
302 | if (flag == LFR_SUCCESSFUL) | |
|
303 | { | |
|
304 | result = set_sy_lfr_s2_bp_p0( TC, queue_id ); | |
|
305 | if (result != LFR_SUCCESSFUL) | |
|
306 | { | |
|
307 | flag = LFR_DEFAULT; | |
|
308 | } | |
|
309 | } | |
|
310 | ||
|
311 | //*************** | |
|
312 | // sy_lfr_s2_bp_p1 | |
|
313 | if (flag == LFR_SUCCESSFUL) | |
|
314 | { | |
|
315 | result = set_sy_lfr_s2_bp_p1( TC, queue_id ); | |
|
316 | if (result != LFR_SUCCESSFUL) | |
|
317 | { | |
|
318 | flag = LFR_DEFAULT; | |
|
319 | } | |
|
320 | } | |
|
321 | ||
|
322 | return flag; | |
|
209 | 323 | } |
|
210 | 324 | |
|
211 | 325 | int action_dump_par( rtems_id queue_id ) |
@@ -403,12 +517,118 int set_sy_lfr_n_cwf_long_f3(ccsdsTeleco | |||
|
403 | 517 | |
|
404 | 518 | //********************** |
|
405 | 519 | // BURST MODE PARAMETERS |
|
520 | int set_sy_lfr_b_bp_p0( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ) | |
|
521 | { | |
|
522 | /** This function sets the time between two basic parameter sets, in s (SY_LFR_B_BP_P0). | |
|
523 | * | |
|
524 | * @param TC points to the TeleCommand packet that is being processed | |
|
525 | * @param queue_id is the id of the queue which handles TM related to this execution step | |
|
526 | * | |
|
527 | */ | |
|
528 | ||
|
529 | int status; | |
|
530 | ||
|
531 | status = LFR_SUCCESSFUL; | |
|
532 | ||
|
533 | parameter_dump_packet.sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ]; | |
|
534 | ||
|
535 | return status; | |
|
536 | } | |
|
537 | ||
|
538 | int set_sy_lfr_b_bp_p1( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ) | |
|
539 | { | |
|
540 | /** This function sets the time between two basic parameter sets, in s (SY_LFR_B_BP_P1). | |
|
541 | * | |
|
542 | * @param TC points to the TeleCommand packet that is being processed | |
|
543 | * @param queue_id is the id of the queue which handles TM related to this execution step | |
|
544 | * | |
|
545 | */ | |
|
546 | ||
|
547 | int status; | |
|
548 | ||
|
549 | status = LFR_SUCCESSFUL; | |
|
550 | ||
|
551 | parameter_dump_packet.sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ]; | |
|
552 | ||
|
553 | return status; | |
|
554 | } | |
|
406 | 555 | |
|
407 | 556 | //********************* |
|
408 | 557 | // SBM1 MODE PARAMETERS |
|
558 | int set_sy_lfr_s1_bp_p0( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ) | |
|
559 | { | |
|
560 | /** This function sets the time between two basic parameter sets, in s (SY_LFR_S1_BP_P0). | |
|
561 | * | |
|
562 | * @param TC points to the TeleCommand packet that is being processed | |
|
563 | * @param queue_id is the id of the queue which handles TM related to this execution step | |
|
564 | * | |
|
565 | */ | |
|
566 | ||
|
567 | int status; | |
|
568 | ||
|
569 | status = LFR_SUCCESSFUL; | |
|
570 | ||
|
571 | parameter_dump_packet.sy_lfr_s1_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P0 ]; | |
|
572 | ||
|
573 | return status; | |
|
574 | } | |
|
575 | ||
|
576 | int set_sy_lfr_s1_bp_p1( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ) | |
|
577 | { | |
|
578 | /** This function sets the time between two basic parameter sets, in s (SY_LFR_S1_BP_P1). | |
|
579 | * | |
|
580 | * @param TC points to the TeleCommand packet that is being processed | |
|
581 | * @param queue_id is the id of the queue which handles TM related to this execution step | |
|
582 | * | |
|
583 | */ | |
|
584 | ||
|
585 | int status; | |
|
586 | ||
|
587 | status = LFR_SUCCESSFUL; | |
|
588 | ||
|
589 | parameter_dump_packet.sy_lfr_s1_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P1 ]; | |
|
590 | ||
|
591 | return status; | |
|
592 | } | |
|
409 | 593 | |
|
410 | 594 | //********************* |
|
411 | 595 | // SBM2 MODE PARAMETERS |
|
596 | int set_sy_lfr_s2_bp_p0( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ) | |
|
597 | { | |
|
598 | /** This function sets the time between two basic parameter sets, in s (SY_LFR_S2_BP_P0). | |
|
599 | * | |
|
600 | * @param TC points to the TeleCommand packet that is being processed | |
|
601 | * @param queue_id is the id of the queue which handles TM related to this execution step | |
|
602 | * | |
|
603 | */ | |
|
604 | ||
|
605 | int status; | |
|
606 | ||
|
607 | status = LFR_SUCCESSFUL; | |
|
608 | ||
|
609 | parameter_dump_packet.sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ]; | |
|
610 | ||
|
611 | return status; | |
|
612 | } | |
|
613 | ||
|
614 | int set_sy_lfr_s2_bp_p1( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ) | |
|
615 | { | |
|
616 | /** This function sets the time between two basic parameter sets, in s (SY_LFR_S2_BP_P1). | |
|
617 | * | |
|
618 | * @param TC points to the TeleCommand packet that is being processed | |
|
619 | * @param queue_id is the id of the queue which handles TM related to this execution step | |
|
620 | * | |
|
621 | */ | |
|
622 | ||
|
623 | int status; | |
|
624 | ||
|
625 | status = LFR_SUCCESSFUL; | |
|
626 | ||
|
627 | parameter_dump_packet.sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ]; | |
|
628 | ||
|
629 | return status; | |
|
630 | } | |
|
631 | ||
|
412 | 632 | |
|
413 | 633 | //******************* |
|
414 | 634 | // TC_LFR_UPDATE_INFO |
General Comments 0
You need to be logged in to leave comments.
Login now