@@ -1,6 +1,6 | |||||
1 | <?xml version="1.0" encoding="UTF-8"?> |
|
1 | <?xml version="1.0" encoding="UTF-8"?> | |
2 | <!DOCTYPE QtCreatorProject> |
|
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 | <qtcreator> |
|
4 | <qtcreator> | |
5 | <data> |
|
5 | <data> | |
6 | <variable>ProjectExplorer.Project.ActiveTarget</variable> |
|
6 | <variable>ProjectExplorer.Project.ActiveTarget</variable> |
@@ -209,8 +209,8 enum apid_destid{ | |||||
209 | #define PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0 (126 - CCSDS_TC_TM_PACKET_OFFSET) // 11 * 9 + 27 - 7 |
|
209 | #define PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0 (126 - CCSDS_TC_TM_PACKET_OFFSET) // 11 * 9 + 27 - 7 | |
210 | #define PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0 (356 - CCSDS_TC_TM_PACKET_OFFSET) // 11 * 30 + 25 - 7 |
|
210 | #define PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0 (356 - CCSDS_TC_TM_PACKET_OFFSET) // 11 * 30 + 25 - 7 | |
211 | #define PACKET_LENGTH_TM_LFR_SCIENCE_BURST_BP2_F1 (806 - CCSDS_TC_TM_PACKET_OFFSET) // 26 * 30 + 26 - 7 |
|
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 |
|
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 |
|
213 | #define PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0 (686 - CCSDS_TC_TM_PACKET_OFFSET) // 22 * 30 + 26 - 7 | |
214 |
|
214 | |||
215 | #define PACKET_LENGTH_DELTA 11 // 7 + 4 |
|
215 | #define PACKET_LENGTH_DELTA 11 // 7 + 4 | |
216 |
|
216 |
@@ -34,6 +34,7 rtems_task dumb_task( rtems_task_argumen | |||||
34 | void init_housekeeping_parameters( void ); |
|
34 | void init_housekeeping_parameters( void ); | |
35 | void increment_seq_counter( unsigned char *packet_sequence_control); |
|
35 | void increment_seq_counter( unsigned char *packet_sequence_control); | |
36 | void getTime( unsigned char *time); |
|
36 | void getTime( unsigned char *time); | |
|
37 | unsigned long long int getTimeAsUnsignedLongLongInt( ); | |||
37 | void send_dumb_hk( void ); |
|
38 | void send_dumb_hk( void ); | |
38 |
|
39 | |||
39 | #endif // FSW_MISC_H_INCLUDED |
|
40 | #endif // FSW_MISC_H_INCLUDED |
@@ -18,6 +18,29 typedef struct ring_node | |||||
18 | unsigned int status; |
|
18 | unsigned int status; | |
19 | } ring_node; |
|
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 | // flight software version |
|
45 | // flight software version | |
23 | // this parameters is handled by the Qt project options |
|
46 | // this parameters is handled by the Qt project options | |
@@ -55,17 +78,17 typedef struct ring_node | |||||
55 | #define THR_MODE_NORMAL 1 |
|
78 | #define THR_MODE_NORMAL 1 | |
56 | #define THR_MODE_BURST 2 |
|
79 | #define THR_MODE_BURST 2 | |
57 |
|
80 | |||
58 | #define RTEMS_EVENT_MODE_STANDBY RTEMS_EVENT_0 |
|
81 | #define RTEMS_EVENT_MODE_STANDBY RTEMS_EVENT_0 | |
59 | #define RTEMS_EVENT_MODE_NORMAL RTEMS_EVENT_1 |
|
82 | #define RTEMS_EVENT_MODE_NORMAL RTEMS_EVENT_1 | |
60 | #define RTEMS_EVENT_MODE_BURST RTEMS_EVENT_2 |
|
83 | #define RTEMS_EVENT_MODE_BURST RTEMS_EVENT_2 | |
61 | #define RTEMS_EVENT_MODE_SBM1 RTEMS_EVENT_3 |
|
84 | #define RTEMS_EVENT_MODE_SBM1 RTEMS_EVENT_3 | |
62 | #define RTEMS_EVENT_MODE_SBM2 RTEMS_EVENT_4 |
|
85 | #define RTEMS_EVENT_MODE_SBM2 RTEMS_EVENT_4 | |
63 | #define RTEMS_EVENT_MODE_SBM2_WFRM RTEMS_EVENT_5 |
|
86 | #define RTEMS_EVENT_MODE_SBM2_WFRM RTEMS_EVENT_5 | |
64 | #define RTEMS_EVENT_NORM_BP1_F0 RTEMS_EVENT_6 |
|
87 | #define RTEMS_EVENT_NORM_BP1_F0 RTEMS_EVENT_6 | |
65 | #define RTEMS_EVENT_NORM_BP2_F0 RTEMS_EVENT_7 |
|
88 | #define RTEMS_EVENT_NORM_BP2_F0 RTEMS_EVENT_7 | |
66 | #define RTEMS_EVENT_NORM_ASM_F0 RTEMS_EVENT_8 |
|
89 | #define RTEMS_EVENT_NORM_ASM_F0 RTEMS_EVENT_8 | |
67 |
#define RTEMS_EVENT_SBM |
|
90 | #define RTEMS_EVENT_BURST_SBM_BP1_F0 RTEMS_EVENT_9 | |
68 |
#define RTEMS_EVENT_SBM |
|
91 | #define RTEMS_EVENT_BURST_SBM_BP2_F0 RTEMS_EVENT_10 | |
69 |
|
92 | |||
70 | //**************************** |
|
93 | //**************************** | |
71 | // LFR DEFAULT MODE PARAMETERS |
|
94 | // LFR DEFAULT MODE PARAMETERS | |
@@ -126,7 +149,7 typedef struct ring_node | |||||
126 |
|
149 | |||
127 | //***** |
|
150 | //***** | |
128 | // TIME |
|
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 | #define TIMER_SM_SIMULATOR 1 |
|
153 | #define TIMER_SM_SIMULATOR 1 | |
131 | #define HK_PERIOD 100 // 100 * 10ms => 1s |
|
154 | #define HK_PERIOD 100 // 100 * 10ms => 1s | |
132 | #define SY_LFR_TIME_SYN_TIMEOUT_in_ms 2000 |
|
155 | #define SY_LFR_TIME_SYN_TIMEOUT_in_ms 2000 |
@@ -12,10 +12,16 | |||||
12 | #define DATAFIELD_POS_SY_LFR_N_CWF_LONG_F3 8 |
|
12 | #define DATAFIELD_POS_SY_LFR_N_CWF_LONG_F3 8 | |
13 |
|
13 | |||
14 | // TC_LFR_LOAD_BURST_PAR |
|
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 | // TC_LFR_LOAD_SBM1_PAR |
|
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 | // TC_LFR_LOAD_SBM2_PAR |
|
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 | // TC_LFR_UPDATE_INFO |
|
26 | // TC_LFR_UPDATE_INFO | |
21 | #define BYTE_POS_UPDATE_INFO_PARAMETERS_SET5 34 |
|
27 | #define BYTE_POS_UPDATE_INFO_PARAMETERS_SET5 34 |
@@ -9,11 +9,10 | |||||
9 | #define TOTAL_SIZE_NORM_BP1_F2 108 // 12 * 9 = 108 |
|
9 | #define TOTAL_SIZE_NORM_BP1_F2 108 // 12 * 9 = 108 | |
10 | #define TOTAL_SIZE_SBM1_BP1_F0 198 // 22 * 9 = 198 |
|
10 | #define TOTAL_SIZE_SBM1_BP1_F0 198 // 22 * 9 = 198 | |
11 | // |
|
11 | // | |
12 |
#define NB_RING_NODES_ |
|
12 | #define NB_RING_NODES_SM_F0 12 // AT LEAST 3 | |
13 |
#define NB_RING_NODES_ |
|
13 | #define NB_RING_NODES_SM_F1 3 // AT LEAST 3 | |
14 |
#define NB_RING_NODES_ |
|
14 | #define NB_RING_NODES_SM_F2 3 // AT LEAST 3 | |
15 |
#define NB_RING_NODES_ |
|
15 | #define NB_RING_NODES_ASM_BURST_SBM_F0 10 // AT LEAST 3 | |
16 | #define NB_RING_NODES_SBM1_BP2 5 // AT LEAST 3 |
|
|||
17 | // |
|
16 | // | |
18 | #define NB_BINS_PER_ASM_F0 88 |
|
17 | #define NB_BINS_PER_ASM_F0 88 | |
19 | #define NB_BINS_PER_PKT_ASM_F0 44 |
|
18 | #define NB_BINS_PER_PKT_ASM_F0 44 | |
@@ -36,22 +35,32 | |||||
36 | #define NB_BINS_COMPRESSED_SM_F0 11 |
|
35 | #define NB_BINS_COMPRESSED_SM_F0 11 | |
37 | #define NB_BINS_COMPRESSED_SM_F1 13 |
|
36 | #define NB_BINS_COMPRESSED_SM_F1 13 | |
38 | #define NB_BINS_COMPRESSED_SM_F2 12 |
|
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 |
|
41 | #define NB_BINS_TO_AVERAGE_ASM_F0 8 | |
42 | #define NB_BINS_TO_AVERAGE_ASM_F1 8 |
|
42 | #define NB_BINS_TO_AVERAGE_ASM_F1 8 | |
43 | #define NB_BINS_TO_AVERAGE_ASM_F2 8 |
|
43 | #define NB_BINS_TO_AVERAGE_ASM_F2 8 | |
44 |
#define NB_BINS_TO_AVERAGE_ASM_SBM |
|
44 | #define NB_BINS_TO_AVERAGE_ASM_SBM_F0 4 | |
45 | // |
|
45 | // | |
46 | #define TOTAL_SIZE_COMPRESSED_ASM_F0 275 // 11 * 25 WORDS |
|
46 | #define TOTAL_SIZE_COMPRESSED_ASM_F0 275 // 11 * 25 WORDS | |
47 | #define TOTAL_SIZE_COMPRESSED_ASM_F1 325 // 13 * 25 WORDS |
|
47 | #define TOTAL_SIZE_COMPRESSED_ASM_F1 325 // 13 * 25 WORDS | |
48 | #define TOTAL_SIZE_COMPRESSED_ASM_F2 300 // 12 * 25 WORDS |
|
48 | #define TOTAL_SIZE_COMPRESSED_ASM_F2 300 // 12 * 25 WORDS | |
49 | #define TOTAL_SIZE_COMPRESSED_ASM_SBM1 550 // 22 * 25 WORDS |
|
49 | #define TOTAL_SIZE_COMPRESSED_ASM_SBM1 550 // 22 * 25 WORDS | |
|
50 | // NORM | |||
50 | #define NB_SM_BEFORE_NORM_BP1_F0 384 // 96 * 4 |
|
51 | #define NB_SM_BEFORE_NORM_BP1_F0 384 // 96 * 4 | |
51 | #define NB_SM_BEFORE_NORM_BP2_F0 1920 // 96 * 20 |
|
52 | #define NB_SM_BEFORE_NORM_BP2_F0 1920 // 96 * 20 | |
52 | #define NB_SM_BEFORE_NORM_ASM_F0 384 // 384 matrices at f0 = 4.00 second |
|
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 | // BURST | |
54 |
#define NB_SM_BEFORE_ |
|
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 | #define NB_SM_BEFORE_AVF0 8 |
|
64 | #define NB_SM_BEFORE_AVF0 8 | |
56 |
|
65 | |||
57 | #endif // FSW_PARAMS_PROCESSING_H |
|
66 | #endif // FSW_PARAMS_PROCESSING_H |
@@ -14,34 +14,35 | |||||
14 | typedef struct ring_node_sm |
|
14 | typedef struct ring_node_sm | |
15 | { |
|
15 | { | |
16 | struct ring_node_sm *previous; |
|
16 | struct ring_node_sm *previous; | |
|
17 | struct ring_node_sm *next; | |||
17 | int buffer_address; |
|
18 | int buffer_address; | |
18 | struct ring_node_sm *next; |
|
|||
19 | unsigned int status; |
|
19 | unsigned int status; | |
20 | unsigned int coarseTime; |
|
20 | unsigned int coarseTime; | |
21 | unsigned int fineTime; |
|
21 | unsigned int fineTime; | |
22 | } ring_node_sm; |
|
22 | } ring_node_sm; | |
23 |
|
23 | |||
24 |
typedef struct ring_node_ |
|
24 | typedef struct ring_node_asm | |
25 | { |
|
25 | { | |
26 |
struct ring_node_ |
|
26 | struct ring_node_asm *previous; | |
27 |
struct ring_node_ |
|
27 | struct ring_node_asm *next; | |
|
28 | float asm_burst_sbm_f0[ TIME_OFFSET + TOTAL_SIZE_SM ]; | |||
28 | unsigned int status; |
|
29 | unsigned int status; | |
29 | unsigned int coarseTime; |
|
30 | } ring_node_asm; | |
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; |
|
|||
34 |
|
31 | |||
35 |
typedef struct |
|
32 | typedef struct bp_packet | |
36 | { |
|
33 | { | |
37 | struct ring_node_bp_with_spare *previous; |
|
34 | Header_TM_LFR_SCIENCE_BP_t header; | |
38 | struct ring_node_bp_with_spare *next; |
|
35 | unsigned char data[ 30 * 22 ]; // MAX size is 22 * 30 [TM_LFR_SCIENCE_BURST_BP2_F1] | |
39 | unsigned int status; |
|
36 | } bp_packet; | |
40 | unsigned int coarseTime; |
|
37 | ||
41 | unsigned int fineTime; |
|
38 | typedef struct bp_packet_with_spare | |
|
39 | { | |||
42 | Header_TM_LFR_SCIENCE_BP_with_spare_t header; |
|
40 | Header_TM_LFR_SCIENCE_BP_with_spare_t header; | |
43 | unsigned char data[ 9 * 22 ]; |
|
41 | unsigned char data[ 9 * 13 ]; // only for TM_LFR_SCIENCE_NORMAL_BP1_F0 and F1 | |
44 |
} |
|
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 | extern volatile int sm_f0[ ]; |
|
47 | extern volatile int sm_f0[ ]; | |
47 | extern volatile int sm_f1[ ]; |
|
48 | extern volatile int sm_f1[ ]; | |
@@ -57,23 +58,23 extern spectral_matrix_regs_t *spectral_ | |||||
57 | extern rtems_name misc_name[5]; |
|
58 | extern rtems_name misc_name[5]; | |
58 | extern rtems_id Task_id[20]; /* array of task ids */ |
|
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 | // ISR |
|
61 | // ISR | |
65 |
void reset_nb_sm_f0( |
|
62 | void reset_nb_sm_f0( unsigned char lfrMode ); | |
66 | rtems_isr spectral_matrices_isr( rtems_vector_number vector ); |
|
63 | rtems_isr spectral_matrices_isr( rtems_vector_number vector ); | |
67 | rtems_isr spectral_matrices_isr_simu( rtems_vector_number vector ); |
|
64 | rtems_isr spectral_matrices_isr_simu( rtems_vector_number vector ); | |
68 |
|
65 | |||
69 | // RTEMS TASKS |
|
66 | // RTEMS TASKS | |
70 |
rtems_task |
|
67 | rtems_task smiq_task( rtems_task_argument argument ); // added to test the spectral matrix simulator | |
71 | rtems_task smiq_task(rtems_task_argument argument); // added to test the spectral matrix simulator |
|
68 | rtems_task avf0_task( rtems_task_argument lfrRequestedMode ); | |
72 |
rtems_task matr_task(rtems_task_argument |
|
69 | rtems_task matr_task( rtems_task_argument lfrRequestedMode ); | |
73 |
|
70 | |||
74 |
//****************** |
|
71 | //****************** | |
75 |
// Spectral |
|
72 | // Spectral Matrices | |
76 |
|
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 | void SM_average(float *averaged_spec_mat_f0, float *averaged_spec_mat_f1, |
|
78 | void SM_average(float *averaged_spec_mat_f0, float *averaged_spec_mat_f1, | |
78 | ring_node_sm *ring_node_tab[], |
|
79 | ring_node_sm *ring_node_tab[], | |
79 | unsigned int firstTimeF0, unsigned int firstTimeF1 ); |
|
80 | unsigned int firstTimeF0, unsigned int firstTimeF1 ); | |
@@ -86,23 +87,23 void ASM_convert(volatile float *input_m | |||||
86 | void ASM_send(Header_TM_LFR_SCIENCE_ASM_t *header, char *spectral_matrix, |
|
87 | void ASM_send(Header_TM_LFR_SCIENCE_ASM_t *header, char *spectral_matrix, | |
87 | unsigned int sid, spw_ioctl_pkt_send *spw_ioctl_send, rtems_id queue_id); |
|
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 | void BP_send(char *data, |
|
100 | void BP_send(char *data, | |
90 | rtems_id queue_id , |
|
101 | rtems_id queue_id , | |
91 | unsigned int nbBytesToSend ); |
|
102 | unsigned int nbBytesToSend ); | |
92 |
|
103 | |||
93 | void init_header_asm( Header_TM_LFR_SCIENCE_ASM_t *header); |
|
104 | //****************** | |
94 | void init_bp_ring_sbm1_bp1( void ); |
|
105 | // general functions | |
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 | void reset_spectral_matrix_regs( void ); |
|
106 | void reset_spectral_matrix_regs( void ); | |
105 |
|
107 | void set_time(unsigned char *time, unsigned char *timeInBuffer ); | ||
106 | void set_time( unsigned char *time, unsigned int coarseTime, unsigned int fineTime ); |
|
|||
107 |
|
108 | |||
108 | #endif // FSW_PROCESSING_H_INCLUDED |
|
109 | #endif // FSW_PROCESSING_H_INCLUDED |
@@ -37,7 +37,7 int check_mode_transition( unsigned char | |||||
37 | int check_transition_date( unsigned int transitionCoarseTime ); |
|
37 | int check_transition_date( unsigned int transitionCoarseTime ); | |
38 | int stop_current_mode( void ); |
|
38 | int stop_current_mode( void ); | |
39 | int enter_mode( unsigned char mode , unsigned int transitionCoarseTime ); |
|
39 | int enter_mode( unsigned char mode , unsigned int transitionCoarseTime ); | |
40 | int restart_science_tasks(); |
|
40 | int restart_science_tasks(unsigned char lfrRequestedMode ); | |
41 | int suspend_science_tasks(); |
|
41 | int suspend_science_tasks(); | |
42 | void launch_waveform_picker(unsigned char mode , unsigned int transitionCoarseTime); |
|
42 | void launch_waveform_picker(unsigned char mode , unsigned int transitionCoarseTime); | |
43 | void launch_spectral_matrix( unsigned char mode ); |
|
43 | void launch_spectral_matrix( unsigned char mode ); |
@@ -9,6 +9,9 | |||||
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 |
|
11 | |||
|
12 | extern nb_sm_t nb_sm; | |||
|
13 | extern nb_sm_before_bp_t nb_sm_before_bp; | |||
|
14 | ||||
12 | int action_load_common_par( ccsdsTelecommandPacket_t *TC ); |
|
15 | int action_load_common_par( ccsdsTelecommandPacket_t *TC ); | |
13 | int action_load_normal_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time); |
|
16 | int action_load_normal_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time); | |
14 | int action_load_burst_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time); |
|
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 | int action_load_sbm2_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time); |
|
19 | int action_load_sbm2_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time); | |
17 | int action_dump_par(rtems_id queue_id ); |
|
20 | int action_dump_par(rtems_id queue_id ); | |
18 |
|
21 | |||
|
22 | // NORMAL | |||
19 | int set_sy_lfr_n_swf_l(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time); |
|
23 | int set_sy_lfr_n_swf_l(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time); | |
20 | int set_sy_lfr_n_swf_p( ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time ); |
|
24 | int set_sy_lfr_n_swf_p( ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time ); | |
21 | int set_sy_lfr_n_asm_p( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); |
|
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 | int set_sy_lfr_n_bp_p1( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); |
|
27 | int set_sy_lfr_n_bp_p1( ccsdsTelecommandPacket_t *TC, rtems_id queue_id ); | |
24 | int set_sy_lfr_n_cwf_long_f3(ccsdsTelecommandPacket_t *TC, rtems_id queue_id); |
|
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 | // TC_LFR_UPDATE_INFO |
|
42 | // TC_LFR_UPDATE_INFO | |
27 | unsigned int check_update_info_hk_lfr_mode( unsigned char mode ); |
|
43 | unsigned int check_update_info_hk_lfr_mode( unsigned char mode ); | |
28 | unsigned int check_update_info_hk_tds_mode( unsigned char mode ); |
|
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 | volatile int wf_cont_f3_b [ (NB_SAMPLES_PER_SNAPSHOT) * NB_WORDS_SWF_BLK + TIME_OFFSET ] __attribute__((aligned(0x100))); |
|
45 | volatile int wf_cont_f3_b [ (NB_SAMPLES_PER_SNAPSHOT) * NB_WORDS_SWF_BLK + TIME_OFFSET ] __attribute__((aligned(0x100))); | |
46 | char wf_cont_f3_light[ (NB_SAMPLES_PER_SNAPSHOT) * NB_BYTES_CWF3_LIGHT_BLK + TIME_OFFSET_IN_BYTES ] __attribute__((aligned(0x100))); |
|
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 | // SPECTRAL MATRICES GLOBAL VARIABLES |
|
49 | // SPECTRAL MATRICES GLOBAL VARIABLES | |
|
50 | ||||
|
51 | nb_sm_t nb_sm; | |||
|
52 | nb_sm_before_bp_t nb_sm_before_bp; | |||
|
53 | ||||
49 | // alignment constraints for the spectral matrices buffers => the first data after the time (8 bytes) shall be aligned on 0x00 |
|
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_ |
|
55 | volatile int sm_f0[ NB_RING_NODES_SM_F0 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); | |
51 |
volatile int sm_f1[ NB_RING_NODES_ |
|
56 | volatile int sm_f1[ NB_RING_NODES_SM_F1 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); | |
52 |
volatile int sm_f2[ NB_RING_NODES_ |
|
57 | volatile int sm_f2[ NB_RING_NODES_SM_F2 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); | |
53 |
|
58 | |||
54 | // APB CONFIGURATION REGISTERS |
|
59 | // APB CONFIGURATION REGISTERS | |
55 | time_management_regs_t *time_management_regs = (time_management_regs_t*) REGS_ADDR_TIME_MANAGEMENT; |
|
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 | init_housekeeping_parameters(); |
|
97 | init_housekeeping_parameters(); | |
98 |
|
98 | |||
99 | init_waveform_rings(); // initialize the waveform rings |
|
99 | init_waveform_rings(); // initialize the waveform rings | |
100 |
init |
|
100 | SM_init_rings(); // initialize spectral matrices rings | |
101 | init_bp_ring_sbm1_bp1(); // initialize basic parameter ring for SBM1 BP1 set |
|
101 | ASM_init_ring(); // initialize the average spectral matrix ring (just for burst, sbm1 and sbm2 asm @ f0 storage) | |
102 | init_bp_ring_sbm1_bp2(); // initialize basic parameter ring for SBM1 BP2 set |
|
|||
103 |
|
102 | |||
104 | reset_wfp_burst_enable(); |
|
103 | reset_wfp_burst_enable(); | |
105 | reset_wfp_status(); |
|
104 | reset_wfp_status(); |
@@ -363,6 +363,19 void getTime( unsigned char *time) | |||||
363 | time[5] = (unsigned char) (time_management_regs->fine_time); |
|
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 | void send_dumb_hk( void ) |
|
379 | void send_dumb_hk( void ) | |
367 | { |
|
380 | { | |
368 | Packet_TM_LFR_HK_t dummy_hk_packet; |
|
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 | // spectral matrices rings |
|
15 | // spectral matrices rings | |
16 |
ring_node_sm sm_ring_f0[ 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_ |
|
17 | ring_node_sm sm_ring_f1[ NB_RING_NODES_SM_F1 ]; | |
18 |
ring_node_sm sm_ring_f2[ NB_RING_NODES_ |
|
18 | ring_node_sm sm_ring_f2[ NB_RING_NODES_SM_F2 ]; | |
19 | ring_node_sm *current_ring_node_sm_f0; |
|
19 | ring_node_sm *current_ring_node_sm_f0; | |
20 | ring_node_sm *ring_node_for_averaging_sm_f0; |
|
20 | ring_node_sm *ring_node_for_averaging_sm_f0; | |
21 | ring_node_sm *current_ring_node_sm_f1; |
|
21 | ring_node_sm *current_ring_node_sm_f1; | |
22 | ring_node_sm *current_ring_node_sm_f2; |
|
22 | ring_node_sm *current_ring_node_sm_f2; | |
23 |
|
23 | |||
24 | //********************** |
|
24 | ring_node_asm asm_ring_burst_sbm_f0[ NB_RING_NODES_ASM_BURST_SBM_F0 ]; | |
25 | // basic parameter rings |
|
25 | ring_node_asm *current_ring_node_asm_burst_sbm_f0; | |
26 | ring_node_bp *current_node_sbm1_bp1_f0; |
|
26 | ring_node_asm *ring_node_for_processing_asm_burst_sbm_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 ]; |
|
|||
30 |
|
27 | |||
31 | //***** |
|
28 | //***** | |
32 | // NORM |
|
29 | // NORM | |
33 | // F0 |
|
30 | // F0 | |
34 | float asm_norm_f0 [ TIME_OFFSET + TOTAL_SIZE_SM ]; |
|
31 | float asm_norm_f0 [ TIME_OFFSET + TOTAL_SIZE_SM ]; | |
35 | float asm_f0_reorganized [ TIME_OFFSET + TOTAL_SIZE_SM ]; |
|
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 | float compressed_sm_norm_f0[ TIME_OFFSET + TOTAL_SIZE_COMPRESSED_ASM_F0 ]; |
|
34 | float compressed_sm_norm_f0[ TIME_OFFSET + TOTAL_SIZE_COMPRESSED_ASM_F0 ]; | |
38 |
|
35 | |||
39 | //***** |
|
36 | //***** | |
40 | // SBM1 |
|
37 | // SBM1 | |
41 |
float asm_sbm |
|
38 | float asm_sbm_f0 [ TIME_OFFSET + TOTAL_SIZE_SM ]; | |
42 |
float compressed_sm_sbm |
|
39 | float compressed_sm_sbm[ TIME_OFFSET + TOTAL_SIZE_COMPRESSED_ASM_SBM1 ]; | |
43 |
|
40 | |||
44 | unsigned char LFR_BP1_F0[ TIME_OFFSET_IN_BYTES + TOTAL_SIZE_NORM_BP1_F0 * 2 ]; |
|
41 | unsigned char LFR_BP1_F0[ TIME_OFFSET_IN_BYTES + TOTAL_SIZE_NORM_BP1_F0 * 2 ]; | |
45 | unsigned char LFR_BP1_F1[ TIME_OFFSET_IN_BYTES + TOTAL_SIZE_NORM_BP1_F1 ]; |
|
42 | unsigned char LFR_BP1_F1[ TIME_OFFSET_IN_BYTES + TOTAL_SIZE_NORM_BP1_F1 ]; | |
46 | unsigned char LFR_BP1_F2[ TIME_OFFSET_IN_BYTES + TOTAL_SIZE_NORM_BP1_F2 ]; |
|
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 | unsigned char i; |
|
422 | unsigned char i; | |
53 |
|
423 | |||
54 | // F0 RING |
|
424 | // F0 RING | |
55 | sm_ring_f0[0].next = (ring_node_sm*) &sm_ring_f0[1]; |
|
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 | sm_ring_f0[0].buffer_address = |
|
427 | sm_ring_f0[0].buffer_address = | |
58 | (int) &sm_f0[ 0 ]; |
|
428 | (int) &sm_f0[ 0 ]; | |
59 |
|
429 | |||
60 |
sm_ring_f0[NB_RING_NODES_ |
|
430 | sm_ring_f0[NB_RING_NODES_SM_F0-1].next = (ring_node_sm*) &sm_ring_f0[0]; | |
61 |
sm_ring_f0[NB_RING_NODES_ |
|
431 | sm_ring_f0[NB_RING_NODES_SM_F0-1].previous = (ring_node_sm*) &sm_ring_f0[NB_RING_NODES_SM_F0-2]; | |
62 |
sm_ring_f0[NB_RING_NODES_ |
|
432 | sm_ring_f0[NB_RING_NODES_SM_F0-1].buffer_address = | |
63 |
(int) &sm_f0[ (NB_RING_NODES_ |
|
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 | sm_ring_f0[i].next = (ring_node_sm*) &sm_ring_f0[i+1]; |
|
437 | sm_ring_f0[i].next = (ring_node_sm*) &sm_ring_f0[i+1]; | |
68 | sm_ring_f0[i].previous = (ring_node_sm*) &sm_ring_f0[i-1]; |
|
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 | // F1 RING |
|
443 | // F1 RING | |
74 | sm_ring_f1[0].next = (ring_node_sm*) &sm_ring_f1[1]; |
|
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 | sm_ring_f1[0].buffer_address = |
|
446 | sm_ring_f1[0].buffer_address = | |
77 | (int) &sm_f1[ 0 ]; |
|
447 | (int) &sm_f1[ 0 ]; | |
78 |
|
448 | |||
79 |
sm_ring_f1[NB_RING_NODES_ |
|
449 | sm_ring_f1[NB_RING_NODES_SM_F1-1].next = (ring_node_sm*) &sm_ring_f1[0]; | |
80 |
sm_ring_f1[NB_RING_NODES_ |
|
450 | sm_ring_f1[NB_RING_NODES_SM_F1-1].previous = (ring_node_sm*) &sm_ring_f1[NB_RING_NODES_SM_F1-2]; | |
81 |
sm_ring_f1[NB_RING_NODES_ |
|
451 | sm_ring_f1[NB_RING_NODES_SM_F1-1].buffer_address = | |
82 |
(int) &sm_f1[ (NB_RING_NODES_ |
|
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 | sm_ring_f1[i].next = (ring_node_sm*) &sm_ring_f1[i+1]; |
|
456 | sm_ring_f1[i].next = (ring_node_sm*) &sm_ring_f1[i+1]; | |
87 | sm_ring_f1[i].previous = (ring_node_sm*) &sm_ring_f1[i-1]; |
|
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 | // F2 RING |
|
462 | // F2 RING | |
93 | sm_ring_f2[0].next = (ring_node_sm*) &sm_ring_f2[1]; |
|
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 | sm_ring_f2[0].buffer_address = |
|
465 | sm_ring_f2[0].buffer_address = | |
96 | (int) &sm_f2[ 0 ]; |
|
466 | (int) &sm_f2[ 0 ]; | |
97 |
|
467 | |||
98 |
sm_ring_f2[NB_RING_NODES_ |
|
468 | sm_ring_f2[NB_RING_NODES_SM_F2-1].next = (ring_node_sm*) &sm_ring_f2[0]; | |
99 |
sm_ring_f2[NB_RING_NODES_ |
|
469 | sm_ring_f2[NB_RING_NODES_SM_F2-1].previous = (ring_node_sm*) &sm_ring_f2[NB_RING_NODES_SM_F2-2]; | |
100 |
sm_ring_f2[NB_RING_NODES_ |
|
470 | sm_ring_f2[NB_RING_NODES_SM_F2-1].buffer_address = | |
101 |
(int) &sm_f2[ (NB_RING_NODES_ |
|
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 | sm_ring_f2[i].next = (ring_node_sm*) &sm_ring_f2[i+1]; |
|
475 | sm_ring_f2[i].next = (ring_node_sm*) &sm_ring_f2[i+1]; | |
106 | sm_ring_f2[i].previous = (ring_node_sm*) &sm_ring_f2[i-1]; |
|
476 | sm_ring_f2[i].previous = (ring_node_sm*) &sm_ring_f2[i-1]; | |
@@ -116,7 +486,26 void init_sm_rings( void ) | |||||
116 | DEBUG_PRINTF1("spectral_matrix_regs->matrixF0_Address0 @%x\n", spectral_matrix_regs->matrixF0_Address0) |
|
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 | current_ring_node_sm_f0 = sm_ring_f0; |
|
510 | current_ring_node_sm_f0 = sm_ring_f0; | |
122 | current_ring_node_sm_f1 = sm_ring_f1; |
|
511 | current_ring_node_sm_f1 = sm_ring_f1; | |
@@ -125,319 +514,51 void reset_current_sm_ring_nodes( void ) | |||||
125 | ring_node_for_averaging_sm_f0 = sm_ring_f0; |
|
514 | ring_node_for_averaging_sm_f0 = sm_ring_f0; | |
126 | } |
|
515 | } | |
127 |
|
516 | |||
128 |
void reset_current_ |
|
517 | void ASM_reset_current_ring_node( void ) | |
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 ) |
|
|||
142 | { |
|
518 | { | |
143 | rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 ); |
|
519 | current_ring_node_asm_burst_sbm_f0 = asm_ring_burst_sbm_f0; | |
144 |
|
520 | ring_node_for_processing_asm_burst_sbm_f0 = asm_ring_burst_sbm_f0; | ||
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 | } |
|
|||
212 | } |
|
521 | } | |
213 |
|
522 | |||
214 | rtems_task avf0_task(rtems_task_argument argument) |
|
523 | void ASM_init_header( Header_TM_LFR_SCIENCE_ASM_t *header) | |
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) |
|
|||
318 | { |
|
524 | { | |
319 | spw_ioctl_pkt_send spw_ioctl_send_ASM; |
|
525 | header->targetLogicalAddress = CCSDS_DESTINATION_ID; | |
320 | rtems_event_set event_out; |
|
526 | header->protocolIdentifier = CCSDS_PROTOCOLE_ID; | |
321 | rtems_status_code status; |
|
527 | header->reserved = 0x00; | |
322 | rtems_id queue_id; |
|
528 | header->userApplication = CCSDS_USER_APP; | |
323 | Header_TM_LFR_SCIENCE_ASM_t headerASM; |
|
529 | header->packetID[0] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST >> 8); | |
324 | ring_node_bp_with_spare current_node_norm_bp1_f0; |
|
530 | header->packetID[1] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST); | |
325 | ring_node_bp current_node_norm_bp2_f0; |
|
531 | header->packetSequenceControl[0] = 0xc0; | |
326 |
|
532 | header->packetSequenceControl[1] = 0x00; | ||
327 | init_header_asm( &headerASM ); |
|
533 | header->packetLength[0] = 0x00; | |
328 | init_header_bp_with_spare( ¤t_node_norm_bp1_f0.header, |
|
534 | header->packetLength[1] = 0x00; | |
329 | APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP1_F0, |
|
535 | // DATA FIELD HEADER | |
330 | PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0, NB_BINS_COMPRESSED_SM_F0 ); |
|
536 | header->spare1_pusVersion_spare2 = 0x10; | |
331 | init_header_bp( ¤t_node_norm_bp2_f0.header, |
|
537 | header->serviceType = TM_TYPE_LFR_SCIENCE; // service type | |
332 | APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP2_F0, |
|
538 | header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype | |
333 | PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0, NB_BINS_COMPRESSED_SM_F0); |
|
539 | header->destinationID = TM_DESTINATION_ID_GROUND; | |
334 |
|
540 | // AUXILIARY DATA HEADER | ||
335 | status = get_message_queue_id_send( &queue_id ); |
|
541 | header->sid = 0x00; | |
336 | if (status != RTEMS_SUCCESSFUL) |
|
542 | header->biaStatusInfo = 0x00; | |
337 | { |
|
543 | header->pa_lfr_pkt_cnt_asm = 0x00; | |
338 | PRINTF1("in MATR *** ERR get_message_queue_id_send %d\n", status) |
|
544 | header->pa_lfr_pkt_nr_asm = 0x00; | |
339 | } |
|
545 | header->time[0] = 0x00; | |
340 |
|
546 | header->time[0] = 0x00; | ||
341 | BOOT_PRINTF("in MATR *** \n") |
|
547 | header->time[0] = 0x00; | |
342 |
|
548 | header->time[0] = 0x00; | ||
343 | while(1){ |
|
549 | header->time[0] = 0x00; | |
344 | rtems_event_receive( RTEMS_EVENT_NORM_BP1_F0 | RTEMS_EVENT_NORM_BP2_F0 | RTEMS_EVENT_NORM_ASM_F0 |
|
550 | header->time[0] = 0x00; | |
345 | | RTEMS_EVENT_SBM1_BP1_F0 | RTEMS_EVENT_SBM1_BP2_F0, |
|
551 | header->pa_lfr_asm_blk_nr[0] = 0x00; // BLK_NR MSB | |
346 | RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out); |
|
552 | header->pa_lfr_asm_blk_nr[1] = 0x00; // BLK_NR LSB | |
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 | } |
|
|||
430 | } |
|
553 | } | |
431 |
|
554 | |||
432 | //***************************** |
|
|||
433 | // Spectral matrices processing |
|
|||
434 |
|
||||
435 | void SM_average( float *averaged_spec_mat_f0, float *averaged_spec_mat_f1, |
|
555 | void SM_average( float *averaged_spec_mat_f0, float *averaged_spec_mat_f1, | |
436 | ring_node_sm *ring_node_tab[], |
|
556 | ring_node_sm *ring_node_tab[], | |
437 | unsigned int nbAverageNormF0, unsigned int nbAverageSBM1F0 ) |
|
557 | unsigned int nbAverageNormF0, unsigned int nbAverageSBM1F0 ) | |
438 | { |
|
558 | { | |
439 | float sum; |
|
559 | float sum; | |
440 | unsigned int i; |
|
560 | unsigned int i; | |
|
561 | unsigned char *ptr; | |||
441 |
|
562 | |||
442 | for(i=0; i<TOTAL_SIZE_SM; i++) |
|
563 | for(i=0; i<TOTAL_SIZE_SM; i++) | |
443 | { |
|
564 | { | |
@@ -470,6 +591,27 void SM_average( float *averaged_spec_ma | |||||
470 | PRINTF2("ERR *** in SM_average *** unexpected parameters %d %d\n", nbAverageNormF0, nbAverageSBM1F0) |
|
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 | void ASM_reorganize_and_divide( float *averaged_spec_mat, float *averaged_spec_mat_reorganized, float divider ) |
|
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 | int offsetCompressed; |
|
642 | int offsetCompressed; | |
501 | int k; |
|
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 | for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++) |
|
650 | for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++) | |
504 | { |
|
651 | { | |
505 | for( frequencyBin = 0; frequencyBin < nbBinsCompressedMatrix; frequencyBin++ ) |
|
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 ) |
|
766 | //***************** | |
620 | { |
|
767 | // Basic Parameters | |
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]; |
|
|||
671 |
|
768 | |||
672 | bp_ring_sbm1_bp1[NB_RING_NODES_SBM1_BP1-1].next = (ring_node_bp*) &bp_ring_sbm1_bp1[0]; |
|
769 | void BP_init_header( Header_TM_LFR_SCIENCE_BP_t *header, | |
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, |
|
|||
724 | unsigned int apid, unsigned char sid, |
|
770 | unsigned int apid, unsigned char sid, | |
725 | unsigned int packetLength, unsigned char blkNr ) |
|
771 | unsigned int packetLength, unsigned char blkNr ) | |
726 | { |
|
772 | { | |
@@ -752,7 +798,7 void init_header_bp( Header_TM_LFR_SCIEN | |||||
752 | header->pa_lfr_bp_blk_nr[1] = blkNr; // BLK_NR LSB |
|
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 | unsigned int apid, unsigned char sid, |
|
802 | unsigned int apid, unsigned char sid, | |
757 | unsigned int packetLength , unsigned char blkNr) |
|
803 | unsigned int packetLength , unsigned char blkNr) | |
758 | { |
|
804 | { | |
@@ -784,6 +830,21 void init_header_bp_with_spare(Header_TM | |||||
784 | header->pa_lfr_bp_blk_nr[1] = blkNr; // BLK_NR LSB |
|
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 | void reset_spectral_matrix_regs( void ) |
|
848 | void reset_spectral_matrix_regs( void ) | |
788 | { |
|
849 | { | |
789 | /** This function resets the spectral matrices module registers. |
|
850 | /** This function resets the spectral matrices module registers. | |
@@ -808,17 +869,21 void reset_spectral_matrix_regs( void ) | |||||
808 | spectral_matrix_regs->matrixF2_Address = current_ring_node_sm_f2->buffer_address; |
|
869 | spectral_matrix_regs->matrixF2_Address = current_ring_node_sm_f2->buffer_address; | |
809 | } |
|
870 | } | |
810 |
|
871 | |||
811 | //****************** |
|
872 | void set_time( unsigned char *time, unsigned char * timeInBuffer ) | |
812 | // general functions |
|
|||
813 |
|
||||
814 | void set_time( unsigned char *time, unsigned int coarseTime, unsigned int fineTime ) |
|
|||
815 | { |
|
873 | { | |
816 | time[0] = (unsigned char) (coarseTime>>24); |
|
874 | // time[0] = timeInBuffer[2]; | |
817 | time[1] = (unsigned char) (coarseTime>>16); |
|
875 | // time[1] = timeInBuffer[3]; | |
818 | time[2] = (unsigned char) (coarseTime>>8); |
|
876 | // time[2] = timeInBuffer[0]; | |
819 | time[3] = (unsigned char) (coarseTime); |
|
877 | // time[3] = timeInBuffer[1]; | |
820 | time[4] = (unsigned char) (fineTime>>8); |
|
878 | // time[4] = timeInBuffer[6]; | |
821 | time[5] = (unsigned char) (fineTime); |
|
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 | rtems_cpu_usage_reset(); |
|
530 | rtems_cpu_usage_reset(); | |
531 | maxCount = 0; |
|
531 | maxCount = 0; | |
532 | #endif |
|
532 | #endif | |
533 | status = restart_science_tasks(); |
|
533 | status = restart_science_tasks( mode ); | |
534 | launch_waveform_picker( mode, transitionCoarseTime ); |
|
534 | launch_waveform_picker( mode, transitionCoarseTime ); | |
535 | launch_spectral_matrix_simu( mode ); |
|
535 | launch_spectral_matrix_simu( mode ); | |
536 | } |
|
536 | } | |
@@ -559,7 +559,7 int enter_mode( unsigned char mode, unsi | |||||
559 | return status; |
|
559 | return status; | |
560 | } |
|
560 | } | |
561 |
|
561 | |||
562 | int restart_science_tasks() |
|
562 | int restart_science_tasks(unsigned char lfrRequestedMode ) | |
563 | { |
|
563 | { | |
564 | /** This function is used to restart all science tasks. |
|
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 | rtems_status_code ret; |
|
577 | rtems_status_code ret; | |
578 |
|
578 | |||
579 | ret = RTEMS_SUCCESSFUL; |
|
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 | if (status[0] != RTEMS_SUCCESSFUL) |
|
582 | if (status[0] != RTEMS_SUCCESSFUL) | |
583 | { |
|
583 | { | |
584 | PRINTF1("in restart_science_task *** 0 ERR %d\n", status[0]) |
|
584 | PRINTF1("in restart_science_task *** 0 ERR %d\n", status[0]) | |
@@ -608,8 +608,15 int restart_science_tasks() | |||||
608 | PRINTF1("in restart_science_task *** 5 ERR %d\n", status[5]) |
|
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 | if ( (status[0] != RTEMS_SUCCESSFUL) || (status[2] != RTEMS_SUCCESSFUL) || |
|
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 | ret = RTEMS_UNSATISFIED; |
|
621 | ret = RTEMS_UNSATISFIED; | |
615 | } |
|
622 | } | |
@@ -697,9 +704,8 void launch_waveform_picker( unsigned ch | |||||
697 |
|
704 | |||
698 | void launch_spectral_matrix( unsigned char mode ) |
|
705 | void launch_spectral_matrix( unsigned char mode ) | |
699 | { |
|
706 | { | |
700 | reset_nb_sm_f0(); |
|
707 | SM_reset_current_ring_nodes(); | |
701 |
reset_current_ |
|
708 | ASM_reset_current_ring_node(); | |
702 | reset_current_bp_ring_nodes(); |
|
|||
703 | reset_spectral_matrix_regs(); |
|
709 | reset_spectral_matrix_regs(); | |
704 |
|
710 | |||
705 | struct grgpio_regs_str *grgpio_regs = (struct grgpio_regs_str *) REGS_ADDR_GRGPIO; |
|
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 | void launch_spectral_matrix_simu( unsigned char mode ) |
|
746 | void launch_spectral_matrix_simu( unsigned char mode ) | |
741 | { |
|
747 | { | |
742 | reset_nb_sm_f0(); |
|
748 | SM_reset_current_ring_nodes(); | |
743 |
reset_current_ |
|
749 | ASM_reset_current_ring_node(); | |
744 | reset_current_bp_ring_nodes(); |
|
|||
745 | reset_spectral_matrix_regs(); |
|
750 | reset_spectral_matrix_regs(); | |
746 |
|
751 | |||
747 | // Spectral Matrices simulator |
|
752 | // Spectral Matrices simulator |
@@ -41,6 +41,9 int action_load_normal_par(ccsdsTelecomm | |||||
41 | int result; |
|
41 | int result; | |
42 | int flag; |
|
42 | int flag; | |
43 | rtems_status_code status; |
|
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 | flag = LFR_SUCCESSFUL; |
|
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 | // sy_lfr_n_bp_p0 |
|
104 | // sy_lfr_n_bp_p0 | |
88 | if (flag == LFR_SUCCESSFUL) |
|
105 | if (flag == LFR_SUCCESSFUL) | |
@@ -129,24 +146,56 int action_load_burst_par(ccsdsTelecomma | |||||
129 | */ |
|
146 | */ | |
130 |
|
147 | |||
131 | int result; |
|
148 | int result; | |
132 | unsigned char lfrMode; |
|
149 | int flag; | |
133 | rtems_status_code status; |
|
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 |
|
|
155 | flag = LFR_SUCCESSFUL; | |
136 | lfrMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4; |
|
|||
137 |
|
156 | |||
138 | if ( lfrMode == LFR_MODE_BURST ) { |
|
157 | if ( lfrCurrentMode == LFR_MODE_BURST ) { | |
139 | status = send_tm_lfr_tc_exe_not_executable( TC, queue_id ); |
|
158 | status = send_tm_lfr_tc_exe_not_executable( TC, queue_id ); | |
140 | result = LFR_DEFAULT; |
|
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 | int action_load_sbm1_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time) |
|
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 | * @param queue_id is the id of the queue which handles TM related to this execution step |
|
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; |
|
210 | int result; | |
165 | lfrMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4; |
|
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 | status = send_tm_lfr_tc_exe_not_executable( TC, queue_id ); |
|
220 | status = send_tm_lfr_tc_exe_not_executable( TC, queue_id ); | |
169 | result = LFR_DEFAULT; |
|
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 | int action_load_sbm2_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time) |
|
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 | int result; |
|
272 | int result; | |
191 | unsigned char lfrMode; |
|
273 | int flag; | |
192 | rtems_status_code status; |
|
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 |
|
|
279 | flag = LFR_SUCCESSFUL; | |
195 | lfrMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4; |
|
|||
196 |
|
280 | |||
197 | if ( lfrMode == LFR_MODE_SBM2 ) { |
|
281 | if ( lfrCurrentMode == LFR_MODE_SBM2 ) { | |
198 | status = send_tm_lfr_tc_exe_not_executable( TC, queue_id ); |
|
282 | status = send_tm_lfr_tc_exe_not_executable( TC, queue_id ); | |
199 | result = LFR_DEFAULT; |
|
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 | int action_dump_par( rtems_id queue_id ) |
|
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 | // BURST MODE PARAMETERS |
|
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 | // SBM1 MODE PARAMETERS |
|
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 | // SBM2 MODE PARAMETERS |
|
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 | // TC_LFR_UPDATE_INFO |
|
634 | // TC_LFR_UPDATE_INFO |
General Comments 0
You need to be logged in to leave comments.
Login now