@@ -1,6 +1,6 | |||
|
1 | 1 | ############################################################################# |
|
2 | 2 | # Makefile for building: bin/fsw |
|
3 |
# Generated by qmake (2.01a) (Qt 4.8.6) on: |
|
|
3 | # Generated by qmake (2.01a) (Qt 4.8.6) on: Fri Nov 14 07:56:09 2014 | |
|
4 | 4 | # Project: fsw-qt.pro |
|
5 | 5 | # Template: app |
|
6 | 6 | # Command: /usr/bin/qmake-qt4 -spec /usr/lib64/qt4/mkspecs/linux-g++ -o Makefile fsw-qt.pro |
@@ -1,6 +1,6 | |||
|
1 | 1 | <?xml version="1.0" encoding="UTF-8"?> |
|
2 | 2 | <!DOCTYPE QtCreatorProject> |
|
3 |
<!-- Written by QtCreator 3.2.1, 2014-11-1 |
|
|
3 | <!-- Written by QtCreator 3.2.1, 2014-11-13T16:06:58. --> | |
|
4 | 4 | <qtcreator> |
|
5 | 5 | <data> |
|
6 | 6 | <variable>EnvironmentId</variable> |
@@ -16,9 +16,11 | |||
|
16 | 16 | #define NB_RING_NODES_SM_F1 12 // AT LEAST 8 due to the way the averaging is done |
|
17 | 17 | #define NB_RING_NODES_ASM_BURST_SBM_F1 5 // AT LEAST 3 |
|
18 | 18 | #define NB_RING_NODES_ASM_NORM_F1 5 // AT LEAST 3 |
|
19 | #define NB_RING_NODES_ASM_F1 3 // AT LEAST 3 | |
|
19 | 20 | #define NB_RING_NODES_SM_F2 3 // AT LEAST 3 |
|
20 | 21 | #define NB_RING_NODES_ASM_BURST_SBM_F2 3 // AT LEAST 3 |
|
21 | 22 | #define NB_RING_NODES_ASM_NORM_F2 3 // AT LEAST 3 |
|
23 | #define NB_RING_NODES_ASM_F2 3 // AT LEAST 3 | |
|
22 | 24 | // |
|
23 | 25 | #define NB_BINS_PER_ASM_F0 88 |
|
24 | 26 | #define NB_BINS_PER_PKT_ASM_F0 44 |
@@ -30,7 +30,7 void reset_nb_sm_f0( unsigned char lfrMo | |||
|
30 | 30 | |
|
31 | 31 | //******* |
|
32 | 32 | // EXTERN |
|
33 |
extern ring_node |
|
|
33 | extern ring_node *ring_node_for_averaging_sm_f0; | |
|
34 | 34 | extern rtems_status_code get_message_queue_id_prc0( rtems_id *queue_id ); |
|
35 | 35 | |
|
36 | 36 | #endif // AVF0_PRC0_H_INCLUDED |
@@ -27,7 +27,7 void reset_nb_sm_f1( unsigned char lfrMo | |||
|
27 | 27 | |
|
28 | 28 | //******* |
|
29 | 29 | // EXTERN |
|
30 |
extern struct ring_node |
|
|
30 | extern struct ring_node *ring_node_for_averaging_sm_f1; | |
|
31 | 31 | extern rtems_status_code get_message_queue_id_prc1( rtems_id *queue_id ); |
|
32 | 32 | |
|
33 | 33 | #endif // AVF1_PRC1_H |
@@ -18,11 +18,11 rtems_task prc2_task( rtems_task_argumen | |||
|
18 | 18 | // FUNCTIONS |
|
19 | 19 | |
|
20 | 20 | void reset_nb_sm_f2( void ); |
|
21 |
void SM_average_f2(float *averaged_spec_mat_f2, ring_node |
|
|
21 | void SM_average_f2(float *averaged_spec_mat_f2, ring_node *ring_node, unsigned int nbAverageNormF2 ); | |
|
22 | 22 | |
|
23 | 23 | //******* |
|
24 | 24 | // EXTERN |
|
25 |
extern struct ring_node |
|
|
25 | extern struct ring_node *ring_node_for_averaging_sm_f2; | |
|
26 | 26 | extern rtems_status_code get_message_queue_id_prc2( rtems_id *queue_id ); |
|
27 | 27 | |
|
28 | 28 | #endif // AVF2_PRC2_H |
@@ -11,16 +11,6 | |||
|
11 | 11 | #include "fsw_params.h" |
|
12 | 12 | #include "fsw_spacewire.h" |
|
13 | 13 | |
|
14 | typedef struct ring_node_sm | |
|
15 | { | |
|
16 | struct ring_node_sm *previous; | |
|
17 | struct ring_node_sm *next; | |
|
18 | int buffer_address; | |
|
19 | unsigned int status; | |
|
20 | unsigned int coarseTime; | |
|
21 | unsigned int fineTime; | |
|
22 | } ring_node_sm; | |
|
23 | ||
|
24 | 14 | typedef struct ring_node_asm |
|
25 | 15 | { |
|
26 | 16 | struct ring_node_asm *next; |
@@ -75,9 +65,6 void SM_init_rings( void ); | |||
|
75 | 65 | void SM_reset_current_ring_nodes( void ); |
|
76 | 66 | // ASM |
|
77 | 67 | void ASM_generic_init_ring(ring_node_asm *ring, unsigned char nbNodes ); |
|
78 | void ASM_init_header( Header_TM_LFR_SCIENCE_ASM_t *header); | |
|
79 | void ASM_send(Header_TM_LFR_SCIENCE_ASM_t *header, char *spectral_matrix, | |
|
80 | unsigned int sid, spw_ioctl_pkt_send *spw_ioctl_send, rtems_id queue_id); | |
|
81 | 68 | |
|
82 | 69 | //***************** |
|
83 | 70 | // Basic Parameters |
@@ -100,7 +87,7 void reset_spectral_matrix_regs( void ); | |||
|
100 | 87 | void set_time(unsigned char *time, unsigned char *timeInBuffer ); |
|
101 | 88 | unsigned long long int get_acquisition_time( unsigned char *timePtr ); |
|
102 | 89 | void close_matrix_actions( unsigned int *nb_sm, unsigned int nb_sm_before_avf, rtems_id avf_task_id, |
|
103 |
ring_node |
|
|
90 | ring_node *node_for_averaging, ring_node *ringNode, unsigned long long int time ); | |
|
104 | 91 | unsigned char getSID( rtems_event_set event ); |
|
105 | 92 | |
|
106 | 93 | extern rtems_status_code get_message_queue_id_prc1( rtems_id *queue_id ); |
@@ -109,10 +96,10 extern rtems_status_code get_message_que | |||
|
109 | 96 | //*************************************** |
|
110 | 97 | // DEFINITIONS OF STATIC INLINE FUNCTIONS |
|
111 | 98 | static inline void SM_average(float *averaged_spec_mat_NORM, float *averaged_spec_mat_SBM, |
|
112 |
ring_node |
|
|
99 | ring_node *ring_node_tab[], | |
|
113 | 100 | unsigned int nbAverageNORM, unsigned int nbAverageSBM ); |
|
114 | 101 | static inline void SM_average_debug( float *averaged_spec_mat_NORM, float *averaged_spec_mat_SBM, |
|
115 |
ring_node |
|
|
102 | ring_node *ring_node_tab[], | |
|
116 | 103 | unsigned int nbAverageNORM, unsigned int nbAverageSBM ); |
|
117 | 104 | static inline void ASM_reorganize_and_divide(float *averaged_spec_mat, float *averaged_spec_mat_reorganized, |
|
118 | 105 | float divider ); |
@@ -121,8 +108,8 static inline void ASM_compress_reorgani | |||
|
121 | 108 | unsigned char nbBinsCompressedMatrix, unsigned char nbBinsToAverage , unsigned char ASMIndexStart); |
|
122 | 109 | static inline void ASM_convert(volatile float *input_matrix, char *output_matrix); |
|
123 | 110 | |
|
124 |
void SM_average |
|
|
125 |
ring_node |
|
|
111 | void SM_average( float *averaged_spec_mat_NORM, float *averaged_spec_mat_SBM, | |
|
112 | ring_node *ring_node_tab[], | |
|
126 | 113 | unsigned int nbAverageNORM, unsigned int nbAverageSBM ) |
|
127 | 114 | { |
|
128 | 115 | float sum; |
@@ -161,8 +148,8 void SM_average_debug( float *averaged_s | |||
|
161 | 148 | } |
|
162 | 149 | } |
|
163 | 150 | |
|
164 | void SM_average( float *averaged_spec_mat_NORM, float *averaged_spec_mat_SBM, | |
|
165 |
ring_node |
|
|
151 | void SM_average_debug( float *averaged_spec_mat_NORM, float *averaged_spec_mat_SBM, | |
|
152 | ring_node *ring_node_tab[], | |
|
166 | 153 | unsigned int nbAverageNORM, unsigned int nbAverageSBM ) |
|
167 | 154 | { |
|
168 | 155 | float sum; |
@@ -18,7 +18,7 ring_node_asm asm_ring_norm_f0 [ NB | |||
|
18 | 18 | ring_node_asm asm_ring_burst_sbm_f0 [ NB_RING_NODES_ASM_BURST_SBM_F0 ]; |
|
19 | 19 | |
|
20 | 20 | ring_node ring_to_send_asm_f0 [ NB_RING_NODES_ASM_F0 ]; |
|
21 |
|
|
|
21 | int buffer_asm_f0 [ NB_RING_NODES_ASM_F0 * TOTAL_SIZE_SM ]; | |
|
22 | 22 | |
|
23 | 23 | float asm_f0_reorganized [ TOTAL_SIZE_SM ]; |
|
24 | 24 | char asm_f0_char [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ]; |
@@ -38,7 +38,7 rtems_task avf0_task( rtems_task_argumen | |||
|
38 | 38 | rtems_status_code status; |
|
39 | 39 | rtems_id queue_id_prc0; |
|
40 | 40 | asm_msg msgForMATR; |
|
41 |
ring_node |
|
|
41 | ring_node *ring_node_tab[8]; | |
|
42 | 42 | ring_node_asm *current_ring_node_asm_burst_sbm_f0; |
|
43 | 43 | ring_node_asm *current_ring_node_asm_norm_f0; |
|
44 | 44 | |
@@ -75,7 +75,7 rtems_task avf0_task( rtems_task_argumen | |||
|
75 | 75 | // initialize the mesage for the MATR task |
|
76 | 76 | msgForMATR.norm = current_ring_node_asm_norm_f0; |
|
77 | 77 | msgForMATR.burst_sbm = current_ring_node_asm_burst_sbm_f0; |
|
78 |
msgForMATR.event = 0x00; // this composite event will be sent to the |
|
|
78 | msgForMATR.event = 0x00; // this composite event will be sent to the PRC0 task | |
|
79 | 79 | msgForMATR.coarseTime = ring_node_for_averaging_sm_f0->coarseTime; |
|
80 | 80 | msgForMATR.fineTime = ring_node_for_averaging_sm_f0->fineTime; |
|
81 | 81 | // |
@@ -182,21 +182,17 rtems_task prc0_task( rtems_task_argumen | |||
|
182 | 182 | asm_msg *incomingMsg; |
|
183 | 183 | // |
|
184 | 184 | unsigned char sid; |
|
185 | spw_ioctl_pkt_send spw_ioctl_send_ASM; | |
|
186 | 185 | rtems_status_code status; |
|
187 | 186 | rtems_id queue_id; |
|
188 | 187 | rtems_id queue_id_q_p0; |
|
189 | Header_TM_LFR_SCIENCE_ASM_t headerASM; | |
|
190 |
bp_packet |
|
|
191 |
bp_packet packet_ |
|
|
192 |
bp_packet packet_sbm_bp |
|
|
193 | bp_packet packet_sbm_bp2_f0; | |
|
194 | ring_node *current_ring_node_to_send_asm_f0; | |
|
188 | bp_packet_with_spare packet_norm_bp1_f0; | |
|
189 | bp_packet packet_norm_bp2_f0; | |
|
190 | bp_packet packet_sbm_bp1_f0; | |
|
191 | bp_packet packet_sbm_bp2_f0; | |
|
192 | ring_node *current_ring_node_to_send_asm_f0; | |
|
195 | 193 | |
|
196 | 194 | unsigned long long int localTime; |
|
197 | 195 | |
|
198 | ASM_init_header( &headerASM ); | |
|
199 | ||
|
200 | 196 | // init the ring of the averaged spectral matrices which will be transmitted to the DPU |
|
201 | 197 | init_ring( ring_to_send_asm_f0, NB_RING_NODES_ASM_F0, (volatile int*) buffer_asm_f0, TOTAL_SIZE_SM ); |
|
202 | 198 | current_ring_node_to_send_asm_f0 = ring_to_send_asm_f0; |
@@ -335,29 +331,19 rtems_task prc0_task( rtems_task_argumen | |||
|
335 | 331 | |
|
336 | 332 | if (incomingMsg->event & RTEMS_EVENT_NORM_ASM_F0) |
|
337 | 333 | { |
|
338 | // // 1) reorganize the ASM and divide | |
|
339 | // ASM_reorganize_and_divide( incomingMsg->norm->matrix, | |
|
340 | // asm_f0_reorganized, | |
|
341 | // nb_sm_before_f0.norm_bp1 ); | |
|
342 | // // 2) convert the float array in a char array | |
|
343 | // ASM_convert( asm_f0_reorganized, (char*) current_ring_node_to_send_asm_f0->buffer_address ); | |
|
344 | // current_ring_node_to_send_asm_f0->coarseTime = incomingMsg->coarseTime; | |
|
345 | // current_ring_node_to_send_asm_f0->fineTime = incomingMsg->fineTime; | |
|
346 | // current_ring_node_to_send_asm_f0->sid = SID_NORM_ASM_F0; | |
|
347 | // // 3) send the spectral matrix packets | |
|
348 | // status = rtems_message_queue_send( queue_id, ¤t_ring_node_to_send_asm_f0, sizeof( ring_node* ) ); | |
|
349 | // // change asm ring node | |
|
350 | // current_ring_node_to_send_asm_f0 = current_ring_node_to_send_asm_f0->next; | |
|
351 | 334 | // 1) reorganize the ASM and divide |
|
352 | 335 | ASM_reorganize_and_divide( incomingMsg->norm->matrix, |
|
353 | asm_f0_reorganized, | |
|
354 | nb_sm_before_f0.norm_bp1 ); | |
|
336 | asm_f0_reorganized, | |
|
337 | nb_sm_before_f0.norm_bp1 ); | |
|
355 | 338 | // 2) convert the float array in a char array |
|
356 |
ASM_convert( asm_f0_reorganized, asm_f0_ |
|
|
339 | ASM_convert( asm_f0_reorganized, (char*) current_ring_node_to_send_asm_f0->buffer_address ); | |
|
340 | current_ring_node_to_send_asm_f0->coarseTime = incomingMsg->coarseTime; | |
|
341 | current_ring_node_to_send_asm_f0->fineTime = incomingMsg->fineTime; | |
|
342 | current_ring_node_to_send_asm_f0->sid = SID_NORM_ASM_F0; | |
|
357 | 343 | // 3) send the spectral matrix packets |
|
358 | set_time( headerASM.time , (unsigned char *) &incomingMsg->coarseTime ); | |
|
359 | set_time( headerASM.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime ); | |
|
360 | ASM_send( &headerASM, asm_f0_char, SID_NORM_ASM_F0, &spw_ioctl_send_ASM, queue_id); | |
|
344 | status = rtems_message_queue_send( queue_id, ¤t_ring_node_to_send_asm_f0, sizeof( ring_node* ) ); | |
|
345 | // change asm ring node | |
|
346 | current_ring_node_to_send_asm_f0 = current_ring_node_to_send_asm_f0->next; | |
|
361 | 347 | } |
|
362 | 348 | |
|
363 | 349 | } |
@@ -13,8 +13,11 nb_sm_before_bp_asm_f1 nb_sm_before_f1; | |||
|
13 | 13 | |
|
14 | 14 | //*** |
|
15 | 15 | // F1 |
|
16 | ring_node_asm asm_ring_norm_f1 [ NB_RING_NODES_ASM_NORM_F1 ]; | |
|
17 | ring_node_asm asm_ring_burst_sbm_f1[ NB_RING_NODES_ASM_BURST_SBM_F1 ]; | |
|
16 | ring_node_asm asm_ring_norm_f1 [ NB_RING_NODES_ASM_NORM_F1 ]; | |
|
17 | ring_node_asm asm_ring_burst_sbm_f1 [ NB_RING_NODES_ASM_BURST_SBM_F1 ]; | |
|
18 | ||
|
19 | ring_node ring_to_send_asm_f1 [ NB_RING_NODES_ASM_F1 ]; | |
|
20 | int buffer_asm_f1 [ NB_RING_NODES_ASM_F1 * TOTAL_SIZE_SM ]; | |
|
18 | 21 | |
|
19 | 22 | float asm_f1_reorganized [ TOTAL_SIZE_SM ]; |
|
20 | 23 | char asm_f1_char [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ]; |
@@ -32,7 +35,7 rtems_task avf1_task( rtems_task_argumen | |||
|
32 | 35 | rtems_status_code status; |
|
33 | 36 | rtems_id queue_id_prc1; |
|
34 | 37 | asm_msg msgForMATR; |
|
35 |
ring_node |
|
|
38 | ring_node *ring_node_tab[8]; | |
|
36 | 39 | ring_node_asm *current_ring_node_asm_burst_sbm_f1; |
|
37 | 40 | ring_node_asm *current_ring_node_asm_norm_f1; |
|
38 | 41 | |
@@ -67,9 +70,9 rtems_task avf1_task( rtems_task_argumen | |||
|
67 | 70 | |
|
68 | 71 | //**************************************** |
|
69 | 72 | // initialize the mesage for the MATR task |
|
70 | msgForMATR.event = 0x00; // this composite event will be sent to the PRC1 task | |
|
73 | msgForMATR.norm = current_ring_node_asm_norm_f1; | |
|
71 | 74 | msgForMATR.burst_sbm = current_ring_node_asm_burst_sbm_f1; |
|
72 | msgForMATR.norm = current_ring_node_asm_norm_f1; | |
|
75 | msgForMATR.event = 0x00; // this composite event will be sent to the PRC1 task | |
|
73 | 76 | msgForMATR.coarseTime = ring_node_for_averaging_sm_f1->coarseTime; |
|
74 | 77 | msgForMATR.fineTime = ring_node_for_averaging_sm_f1->fineTime; |
|
75 | 78 | // |
@@ -175,19 +178,20 rtems_task prc1_task( rtems_task_argumen | |||
|
175 | 178 | asm_msg *incomingMsg; |
|
176 | 179 | // |
|
177 | 180 | unsigned char sid; |
|
178 | spw_ioctl_pkt_send spw_ioctl_send_ASM; | |
|
179 | 181 | rtems_status_code status; |
|
180 | 182 | rtems_id queue_id_send; |
|
181 | 183 | rtems_id queue_id_q_p1; |
|
182 | Header_TM_LFR_SCIENCE_ASM_t headerASM; | |
|
183 |
bp_packet |
|
|
184 |
bp_packet packet_ |
|
|
185 |
bp_packet packet_sbm_bp |
|
|
186 | bp_packet packet_sbm_bp2; | |
|
184 | bp_packet_with_spare packet_norm_bp1; | |
|
185 | bp_packet packet_norm_bp2; | |
|
186 | bp_packet packet_sbm_bp1; | |
|
187 | bp_packet packet_sbm_bp2; | |
|
188 | ring_node *current_ring_node_to_send_asm_f1; | |
|
187 | 189 | |
|
188 | 190 | unsigned long long int localTime; |
|
189 | 191 | |
|
190 | ASM_init_header( &headerASM ); | |
|
192 | // init the ring of the averaged spectral matrices which will be transmitted to the DPU | |
|
193 | init_ring( ring_to_send_asm_f1, NB_RING_NODES_ASM_F1, (volatile int*) buffer_asm_f1, TOTAL_SIZE_SM ); | |
|
194 | current_ring_node_to_send_asm_f1 = ring_to_send_asm_f1; | |
|
191 | 195 | |
|
192 | 196 | //************* |
|
193 | 197 | // NORM headers |
@@ -318,11 +322,14 rtems_task prc1_task( rtems_task_argumen | |||
|
318 | 322 | asm_f1_reorganized, |
|
319 | 323 | nb_sm_before_f1.norm_bp1 ); |
|
320 | 324 | // 2) convert the float array in a char array |
|
321 |
ASM_convert( asm_f1_reorganized, asm_f1_ |
|
|
325 | ASM_convert( asm_f1_reorganized, (char*) current_ring_node_to_send_asm_f1->buffer_address ); | |
|
326 | current_ring_node_to_send_asm_f1->coarseTime = incomingMsg->coarseTime; | |
|
327 | current_ring_node_to_send_asm_f1->fineTime = incomingMsg->fineTime; | |
|
328 | current_ring_node_to_send_asm_f1->sid = SID_NORM_ASM_F1; | |
|
322 | 329 | // 3) send the spectral matrix packets |
|
323 | set_time( headerASM.time , (unsigned char *) &incomingMsg->coarseTime ); | |
|
324 | set_time( headerASM.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime ); | |
|
325 | ASM_send( &headerASM, asm_f1_char, SID_NORM_ASM_F1, &spw_ioctl_send_ASM, queue_id_send); | |
|
330 | status = rtems_message_queue_send( queue_id_send, ¤t_ring_node_to_send_asm_f1, sizeof( ring_node* ) ); | |
|
331 | // change asm ring node | |
|
332 | current_ring_node_to_send_asm_f1 = current_ring_node_to_send_asm_f1->next; | |
|
326 | 333 | } |
|
327 | 334 | |
|
328 | 335 | } |
@@ -16,6 +16,9 nb_sm_before_bp_asm_f2 nb_sm_before_f2; | |||
|
16 | 16 | ring_node_asm asm_ring_norm_f2 [ NB_RING_NODES_ASM_NORM_F2 ]; |
|
17 | 17 | ring_node_asm asm_ring_burst_sbm_f2[ NB_RING_NODES_ASM_BURST_SBM_F2 ]; |
|
18 | 18 | |
|
19 | ring_node ring_to_send_asm_f2 [ NB_RING_NODES_ASM_F2 ]; | |
|
20 | int buffer_asm_f2 [ NB_RING_NODES_ASM_F2 * TOTAL_SIZE_SM ]; | |
|
21 | ||
|
19 | 22 | float asm_f2_reorganized [ TOTAL_SIZE_SM ]; |
|
20 | 23 | char asm_f2_char [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ]; |
|
21 | 24 | float compressed_sm_norm_f2[ TOTAL_SIZE_COMPRESSED_ASM_NORM_F2]; |
@@ -59,9 +62,9 rtems_task avf2_task( rtems_task_argumen | |||
|
59 | 62 | |
|
60 | 63 | //**************************************** |
|
61 | 64 | // initialize the mesage for the MATR task |
|
62 | msgForMATR.event = 0x00; // this composite event will be sent to the MATR task | |
|
65 | msgForMATR.norm = current_ring_node_asm_norm_f2; | |
|
63 | 66 | msgForMATR.burst_sbm = NULL; |
|
64 | msgForMATR.norm = current_ring_node_asm_norm_f2; | |
|
67 | msgForMATR.event = 0x00; // this composite event will be sent to the PRC2 task | |
|
65 | 68 | msgForMATR.coarseTime = ring_node_for_averaging_sm_f2->coarseTime; |
|
66 | 69 | msgForMATR.fineTime = ring_node_for_averaging_sm_f2->fineTime; |
|
67 | 70 | // |
@@ -129,19 +132,20 rtems_task prc2_task( rtems_task_argumen | |||
|
129 | 132 | size_t size; // size of the incoming TC packet |
|
130 | 133 | asm_msg *incomingMsg; |
|
131 | 134 | // |
|
132 | spw_ioctl_pkt_send spw_ioctl_send_ASM; | |
|
133 | 135 | rtems_status_code status; |
|
134 | 136 | rtems_id queue_id; |
|
135 | 137 | rtems_id queue_id_q_p2; |
|
136 | Header_TM_LFR_SCIENCE_ASM_t headerASM; | |
|
137 |
bp_packet packet_norm_bp |
|
|
138 | bp_packet packet_norm_bp2_f2; | |
|
138 | bp_packet packet_norm_bp1_f2; | |
|
139 | bp_packet packet_norm_bp2_f2; | |
|
140 | ring_node *current_ring_node_to_send_asm_f2; | |
|
139 | 141 | |
|
140 | 142 | unsigned long long int localTime; |
|
141 | 143 | |
|
142 | incomingMsg = NULL; | |
|
144 | // init the ring of the averaged spectral matrices which will be transmitted to the DPU | |
|
145 | init_ring( ring_to_send_asm_f2, NB_RING_NODES_ASM_F2, (volatile int*) buffer_asm_f2, TOTAL_SIZE_SM ); | |
|
146 | current_ring_node_to_send_asm_f2 = ring_to_send_asm_f2; | |
|
143 | 147 | |
|
144 | ASM_init_header( &headerASM ); | |
|
148 | incomingMsg = NULL; | |
|
145 | 149 | |
|
146 | 150 | //************* |
|
147 | 151 | // NORM headers |
@@ -213,11 +217,14 rtems_task prc2_task( rtems_task_argumen | |||
|
213 | 217 | asm_f2_reorganized, |
|
214 | 218 | nb_sm_before_f2.norm_bp1 ); |
|
215 | 219 | // 2) convert the float array in a char array |
|
216 |
ASM_convert( asm_f2_reorganized, asm_f2_ |
|
|
220 | ASM_convert( asm_f2_reorganized, (char*) current_ring_node_to_send_asm_f2->buffer_address ); | |
|
221 | current_ring_node_to_send_asm_f2->coarseTime = incomingMsg->coarseTime; | |
|
222 | current_ring_node_to_send_asm_f2->fineTime = incomingMsg->fineTime; | |
|
223 | current_ring_node_to_send_asm_f2->sid = SID_NORM_ASM_F2; | |
|
217 | 224 | // 3) send the spectral matrix packets |
|
218 | set_time( headerASM.time , (unsigned char *) &incomingMsg->coarseTime ); | |
|
219 | set_time( headerASM.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime ); | |
|
220 | ASM_send( &headerASM, asm_f2_char, SID_NORM_ASM_F2, &spw_ioctl_send_ASM, queue_id); | |
|
225 | status = rtems_message_queue_send( queue_id, ¤t_ring_node_to_send_asm_f2, sizeof( ring_node* ) ); | |
|
226 | // change asm ring node | |
|
227 | current_ring_node_to_send_asm_f2 = current_ring_node_to_send_asm_f2->next; | |
|
221 | 228 | } |
|
222 | 229 | |
|
223 | 230 | } |
@@ -234,7 +241,7 void reset_nb_sm_f2( void ) | |||
|
234 | 241 | } |
|
235 | 242 | |
|
236 | 243 | void SM_average_f2( float *averaged_spec_mat_f2, |
|
237 |
ring_node |
|
|
244 | ring_node *ring_node, | |
|
238 | 245 | unsigned int nbAverageNormF2 ) |
|
239 | 246 | { |
|
240 | 247 | float sum; |
@@ -17,15 +17,15 unsigned int nb_sm_f0_aux_f2; | |||
|
17 | 17 | |
|
18 | 18 | //************************ |
|
19 | 19 | // spectral matrices rings |
|
20 |
ring_node |
|
|
21 |
ring_node |
|
|
22 |
ring_node |
|
|
23 |
ring_node |
|
|
24 |
ring_node |
|
|
25 |
ring_node |
|
|
26 |
ring_node |
|
|
27 |
ring_node |
|
|
28 |
ring_node |
|
|
20 | ring_node sm_ring_f0[ NB_RING_NODES_SM_F0 ]; | |
|
21 | ring_node sm_ring_f1[ NB_RING_NODES_SM_F1 ]; | |
|
22 | ring_node sm_ring_f2[ NB_RING_NODES_SM_F2 ]; | |
|
23 | ring_node *current_ring_node_sm_f0; | |
|
24 | ring_node *current_ring_node_sm_f1; | |
|
25 | ring_node *current_ring_node_sm_f2; | |
|
26 | ring_node *ring_node_for_averaging_sm_f0; | |
|
27 | ring_node *ring_node_for_averaging_sm_f1; | |
|
28 | ring_node *ring_node_for_averaging_sm_f2; | |
|
29 | 29 | |
|
30 | 30 | //*********************************************************** |
|
31 | 31 | // Interrupt Service Routine for spectral matrices processing |
@@ -261,79 +261,20 void reset_nb_sm( void ) | |||
|
261 | 261 | nb_sm_f1 = 0; |
|
262 | 262 | } |
|
263 | 263 | |
|
264 | //void SM_init_rings_alt( void ) | |
|
265 | //{ | |
|
266 | // init_ring( sm_ring_f0, NB_RING_NODES_SM_F0, sm_f0, TOTAL_SIZE_SM ); | |
|
267 | // init_ring( sm_ring_f1, NB_RING_NODES_SM_F1, sm_f0, TOTAL_SIZE_SM ); | |
|
268 | // init_ring( sm_ring_f2, NB_RING_NODES_SM_F2, sm_f0, TOTAL_SIZE_SM ); | |
|
269 | ||
|
270 | // DEBUG_PRINTF1("sm_ring_f0 @%x\n", (unsigned int) sm_ring_f0) | |
|
271 | // DEBUG_PRINTF1("sm_ring_f1 @%x\n", (unsigned int) sm_ring_f1) | |
|
272 | // DEBUG_PRINTF1("sm_ring_f2 @%x\n", (unsigned int) sm_ring_f2) | |
|
273 | // DEBUG_PRINTF1("sm_f0 @%x\n", (unsigned int) sm_f0) | |
|
274 | // DEBUG_PRINTF1("sm_f1 @%x\n", (unsigned int) sm_f1) | |
|
275 | // DEBUG_PRINTF1("sm_f2 @%x\n", (unsigned int) sm_f2) | |
|
276 | //} | |
|
277 | ||
|
278 | 264 | void SM_init_rings( void ) |
|
279 | 265 | { |
|
280 | unsigned char i; | |
|
281 | // F0 RING | |
|
282 | sm_ring_f0[0].next = (ring_node_sm*) &sm_ring_f0[1]; | |
|
283 | sm_ring_f0[0].previous = (ring_node_sm*) &sm_ring_f0[NB_RING_NODES_SM_F0-1]; | |
|
284 | sm_ring_f0[0].buffer_address = | |
|
285 | (int) &sm_f0[ 0 ]; | |
|
286 | sm_ring_f0[NB_RING_NODES_SM_F0-1].next = (ring_node_sm*) &sm_ring_f0[0]; | |
|
287 | sm_ring_f0[NB_RING_NODES_SM_F0-1].previous = (ring_node_sm*) &sm_ring_f0[NB_RING_NODES_SM_F0-2]; | |
|
288 | sm_ring_f0[NB_RING_NODES_SM_F0-1].buffer_address = | |
|
289 | (int) &sm_f0[ (NB_RING_NODES_SM_F0-1) * TOTAL_SIZE_SM ]; | |
|
290 | for(i=1; i<NB_RING_NODES_SM_F0-1; i++) | |
|
291 | { | |
|
292 | sm_ring_f0[i].next = (ring_node_sm*) &sm_ring_f0[i+1]; | |
|
293 | sm_ring_f0[i].previous = (ring_node_sm*) &sm_ring_f0[i-1]; | |
|
294 | sm_ring_f0[i].buffer_address = | |
|
295 | (int) &sm_f0[ i * TOTAL_SIZE_SM ]; | |
|
296 | } | |
|
297 | // F1 RING | |
|
298 | sm_ring_f1[0].next = (ring_node_sm*) &sm_ring_f1[1]; | |
|
299 | sm_ring_f1[0].previous = (ring_node_sm*) &sm_ring_f1[NB_RING_NODES_SM_F1-1]; | |
|
300 | sm_ring_f1[0].buffer_address = | |
|
301 | (int) &sm_f1[ 0 ]; | |
|
302 | sm_ring_f1[NB_RING_NODES_SM_F1-1].next = (ring_node_sm*) &sm_ring_f1[0]; | |
|
303 | sm_ring_f1[NB_RING_NODES_SM_F1-1].previous = (ring_node_sm*) &sm_ring_f1[NB_RING_NODES_SM_F1-2]; | |
|
304 | sm_ring_f1[NB_RING_NODES_SM_F1-1].buffer_address = | |
|
305 | (int) &sm_f1[ (NB_RING_NODES_SM_F1-1) * TOTAL_SIZE_SM ]; | |
|
306 | for(i=1; i<NB_RING_NODES_SM_F1-1; i++) | |
|
307 | { | |
|
308 | sm_ring_f1[i].next = (ring_node_sm*) &sm_ring_f1[i+1]; | |
|
309 | sm_ring_f1[i].previous = (ring_node_sm*) &sm_ring_f1[i-1]; | |
|
310 | sm_ring_f1[i].buffer_address = | |
|
311 | (int) &sm_f1[ i * TOTAL_SIZE_SM ]; | |
|
312 | } | |
|
313 | // F2 RING | |
|
314 | sm_ring_f2[0].next = (ring_node_sm*) &sm_ring_f2[1]; | |
|
315 | sm_ring_f2[0].previous = (ring_node_sm*) &sm_ring_f2[NB_RING_NODES_SM_F2-1]; | |
|
316 | sm_ring_f2[0].buffer_address = | |
|
317 | (int) &sm_f2[ 0 ]; | |
|
318 | sm_ring_f2[NB_RING_NODES_SM_F2-1].next = (ring_node_sm*) &sm_ring_f2[0]; | |
|
319 | sm_ring_f2[NB_RING_NODES_SM_F2-1].previous = (ring_node_sm*) &sm_ring_f2[NB_RING_NODES_SM_F2-2]; | |
|
320 | sm_ring_f2[NB_RING_NODES_SM_F2-1].buffer_address = | |
|
321 | (int) &sm_f2[ (NB_RING_NODES_SM_F2-1) * TOTAL_SIZE_SM ]; | |
|
322 | for(i=1; i<NB_RING_NODES_SM_F2-1; i++) | |
|
323 | { | |
|
324 | sm_ring_f2[i].next = (ring_node_sm*) &sm_ring_f2[i+1]; | |
|
325 | sm_ring_f2[i].previous = (ring_node_sm*) &sm_ring_f2[i-1]; | |
|
326 | sm_ring_f2[i].buffer_address = | |
|
327 | (int) &sm_f2[ i * TOTAL_SIZE_SM ]; | |
|
328 | } | |
|
329 | DEBUG_PRINTF1("asm_ring_f0 @%x\n", (unsigned int) sm_ring_f0) | |
|
330 | DEBUG_PRINTF1("asm_ring_f1 @%x\n", (unsigned int) sm_ring_f1) | |
|
331 | DEBUG_PRINTF1("asm_ring_f2 @%x\n", (unsigned int) sm_ring_f2) | |
|
332 | spectral_matrix_regs->f0_0_address = sm_ring_f0[0].buffer_address; | |
|
333 | DEBUG_PRINTF1("spectral_matrix_regs->matrixF0_Address0 @%x\n", spectral_matrix_regs->f0_0_address) | |
|
266 | init_ring( sm_ring_f0, NB_RING_NODES_SM_F0, sm_f0, TOTAL_SIZE_SM ); | |
|
267 | init_ring( sm_ring_f1, NB_RING_NODES_SM_F1, sm_f1, TOTAL_SIZE_SM ); | |
|
268 | init_ring( sm_ring_f2, NB_RING_NODES_SM_F2, sm_f2, TOTAL_SIZE_SM ); | |
|
269 | ||
|
270 | DEBUG_PRINTF1("sm_ring_f0 @%x\n", (unsigned int) sm_ring_f0) | |
|
271 | DEBUG_PRINTF1("sm_ring_f1 @%x\n", (unsigned int) sm_ring_f1) | |
|
272 | DEBUG_PRINTF1("sm_ring_f2 @%x\n", (unsigned int) sm_ring_f2) | |
|
273 | DEBUG_PRINTF1("sm_f0 @%x\n", (unsigned int) sm_f0) | |
|
274 | DEBUG_PRINTF1("sm_f1 @%x\n", (unsigned int) sm_f1) | |
|
275 | DEBUG_PRINTF1("sm_f2 @%x\n", (unsigned int) sm_f2) | |
|
334 | 276 | } |
|
335 | 277 | |
|
336 | ||
|
337 | 278 | void ASM_generic_init_ring( ring_node_asm *ring, unsigned char nbNodes ) |
|
338 | 279 | { |
|
339 | 280 | unsigned char i; |
@@ -358,116 +299,6 void SM_reset_current_ring_nodes( void ) | |||
|
358 | 299 | ring_node_for_averaging_sm_f2 = sm_ring_f2; |
|
359 | 300 | } |
|
360 | 301 | |
|
361 | void ASM_init_header( Header_TM_LFR_SCIENCE_ASM_t *header) | |
|
362 | { | |
|
363 | header->targetLogicalAddress = CCSDS_DESTINATION_ID; | |
|
364 | header->protocolIdentifier = CCSDS_PROTOCOLE_ID; | |
|
365 | header->reserved = 0x00; | |
|
366 | header->userApplication = CCSDS_USER_APP; | |
|
367 | header->packetID[0] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST >> 8); | |
|
368 | header->packetID[1] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST); | |
|
369 | header->packetSequenceControl[0] = 0xc0; | |
|
370 | header->packetSequenceControl[1] = 0x00; | |
|
371 | header->packetLength[0] = 0x00; | |
|
372 | header->packetLength[1] = 0x00; | |
|
373 | // DATA FIELD HEADER | |
|
374 | header->spare1_pusVersion_spare2 = 0x10; | |
|
375 | header->serviceType = TM_TYPE_LFR_SCIENCE; // service type | |
|
376 | header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype | |
|
377 | header->destinationID = TM_DESTINATION_ID_GROUND; | |
|
378 | header->time[0] = 0x00; | |
|
379 | header->time[0] = 0x00; | |
|
380 | header->time[0] = 0x00; | |
|
381 | header->time[0] = 0x00; | |
|
382 | header->time[0] = 0x00; | |
|
383 | header->time[0] = 0x00; | |
|
384 | // AUXILIARY DATA HEADER | |
|
385 | header->sid = 0x00; | |
|
386 | header->biaStatusInfo = 0x00; | |
|
387 | header->pa_lfr_pkt_cnt_asm = 0x00; | |
|
388 | header->pa_lfr_pkt_nr_asm = 0x00; | |
|
389 | header->pa_lfr_asm_blk_nr[0] = 0x00; // BLK_NR MSB | |
|
390 | header->pa_lfr_asm_blk_nr[1] = 0x00; // BLK_NR LSB | |
|
391 | } | |
|
392 | ||
|
393 | void ASM_send(Header_TM_LFR_SCIENCE_ASM_t *header, char *spectral_matrix, | |
|
394 | unsigned int sid, spw_ioctl_pkt_send *spw_ioctl_send, rtems_id queue_id) | |
|
395 | { | |
|
396 | unsigned int i; | |
|
397 | unsigned int length = 0; | |
|
398 | rtems_status_code status; | |
|
399 | ||
|
400 | for (i=0; i<2; i++) | |
|
401 | { | |
|
402 | // (1) BUILD THE DATA | |
|
403 | switch(sid) | |
|
404 | { | |
|
405 | case SID_NORM_ASM_F0: | |
|
406 | spw_ioctl_send->dlen = TOTAL_SIZE_ASM_F0_IN_BYTES / 2; // 2 packets will be sent | |
|
407 | spw_ioctl_send->data = &spectral_matrix[ | |
|
408 | ( (ASM_F0_INDICE_START + (i*NB_BINS_PER_PKT_ASM_F0) ) * NB_VALUES_PER_SM ) * 2 | |
|
409 | ]; | |
|
410 | length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F0; | |
|
411 | header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F0) >> 8 ); // BLK_NR MSB | |
|
412 | header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F0); // BLK_NR LSB | |
|
413 | break; | |
|
414 | case SID_NORM_ASM_F1: | |
|
415 | spw_ioctl_send->dlen = TOTAL_SIZE_ASM_F1_IN_BYTES / 2; // 2 packets will be sent | |
|
416 | spw_ioctl_send->data = &spectral_matrix[ | |
|
417 | ( (ASM_F1_INDICE_START + (i*NB_BINS_PER_PKT_ASM_F1) ) * NB_VALUES_PER_SM ) * 2 | |
|
418 | ]; | |
|
419 | length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F1; | |
|
420 | header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F1) >> 8 ); // BLK_NR MSB | |
|
421 | header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F1); // BLK_NR LSB | |
|
422 | break; | |
|
423 | case SID_NORM_ASM_F2: | |
|
424 | spw_ioctl_send->dlen = TOTAL_SIZE_ASM_F2_IN_BYTES / 2; // 2 packets will be sent | |
|
425 | spw_ioctl_send->data = &spectral_matrix[ | |
|
426 | ( (ASM_F2_INDICE_START + (i*NB_BINS_PER_PKT_ASM_F2) ) * NB_VALUES_PER_SM ) * 2 | |
|
427 | ]; | |
|
428 | length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F2; | |
|
429 | header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F2) >> 8 ); // BLK_NR MSB | |
|
430 | header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F2); // BLK_NR LSB | |
|
431 | break; | |
|
432 | default: | |
|
433 | PRINTF1("ERR *** in ASM_send *** unexpected sid %d\n", sid) | |
|
434 | break; | |
|
435 | } | |
|
436 | spw_ioctl_send->hlen = HEADER_LENGTH_TM_LFR_SCIENCE_ASM + CCSDS_PROTOCOLE_EXTRA_BYTES; | |
|
437 | spw_ioctl_send->hdr = (char *) header; | |
|
438 | spw_ioctl_send->options = 0; | |
|
439 | ||
|
440 | // (2) BUILD THE HEADER | |
|
441 | increment_seq_counter_source_id( header->packetSequenceControl, sid ); | |
|
442 | header->packetLength[0] = (unsigned char) (length>>8); | |
|
443 | header->packetLength[1] = (unsigned char) (length); | |
|
444 | header->sid = (unsigned char) sid; // SID | |
|
445 | header->pa_lfr_pkt_cnt_asm = 2; | |
|
446 | header->pa_lfr_pkt_nr_asm = (unsigned char) (i+1); | |
|
447 | ||
|
448 | // (3) SET PACKET TIME | |
|
449 | header->time[0] = (unsigned char) (time_management_regs->coarse_time>>24); | |
|
450 | header->time[1] = (unsigned char) (time_management_regs->coarse_time>>16); | |
|
451 | header->time[2] = (unsigned char) (time_management_regs->coarse_time>>8); | |
|
452 | header->time[3] = (unsigned char) (time_management_regs->coarse_time); | |
|
453 | header->time[4] = (unsigned char) (time_management_regs->fine_time>>8); | |
|
454 | header->time[5] = (unsigned char) (time_management_regs->fine_time); | |
|
455 | // | |
|
456 | header->acquisitionTime[0] = header->time[0]; | |
|
457 | header->acquisitionTime[1] = header->time[1]; | |
|
458 | header->acquisitionTime[2] = header->time[2]; | |
|
459 | header->acquisitionTime[3] = header->time[3]; | |
|
460 | header->acquisitionTime[4] = header->time[4]; | |
|
461 | header->acquisitionTime[5] = header->time[5]; | |
|
462 | ||
|
463 | // (4) SEND PACKET | |
|
464 | status = rtems_message_queue_send( queue_id, spw_ioctl_send, ACTION_MSG_SPW_IOCTL_SEND_SIZE); | |
|
465 | if (status != RTEMS_SUCCESSFUL) { | |
|
466 | printf("in ASM_send *** ERR %d\n", (int) status); | |
|
467 | } | |
|
468 | } | |
|
469 | } | |
|
470 | ||
|
471 | 302 | //***************** |
|
472 | 303 | // Basic Parameters |
|
473 | 304 | |
@@ -619,7 +450,7 unsigned long long int get_acquisition_t | |||
|
619 | 450 | } |
|
620 | 451 | |
|
621 | 452 | void close_matrix_actions(unsigned int *nb_sm, unsigned int nb_sm_before_avf, rtems_id avf_task_id, |
|
622 |
ring_node |
|
|
453 | ring_node *node_for_averaging, ring_node *ringNode, | |
|
623 | 454 | unsigned long long int time ) |
|
624 | 455 | { |
|
625 | 456 | unsigned char *timePtr; |
General Comments 0
You need to be logged in to leave comments.
Login now