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

Fork of HG_REPOSITORIES/LPP/INSTRUMENTATION/SOLO_LFR/DEV_PLE

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

Rev 3.0.0.5...
paul -
r213:d1d105094d26 R3
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,112 +1,112
1 1 TEMPLATE = app
2 2 # CONFIG += console v8 sim
3 3 # CONFIG options = verbose *** boot_messages *** debug_messages *** cpu_usage_report *** stack_report *** vhdl_dev *** debug_tch
4 4 # lpp_dpu_destid
5 5 CONFIG += console verbose lpp_dpu_destid
6 6 CONFIG -= qt
7 7
8 8 include(./sparc.pri)
9 9
10 10 # flight software version
11 11 SWVERSION=-1-0
12 12 DEFINES += SW_VERSION_N1=3 # major
13 13 DEFINES += SW_VERSION_N2=0 # minor
14 14 DEFINES += SW_VERSION_N3=0 # patch
15 DEFINES += SW_VERSION_N4=4 # internal
15 DEFINES += SW_VERSION_N4=5 # internal
16 16
17 17 # <GCOV>
18 18 #QMAKE_CFLAGS_RELEASE += -fprofile-arcs -ftest-coverage
19 19 #LIBS += -lgcov /opt/GCOV/01A/lib/overload.o -lc
20 20 # </GCOV>
21 21
22 22 # <CHANGE BEFORE FLIGHT>
23 23 contains( CONFIG, lpp_dpu_destid ) {
24 24 DEFINES += LPP_DPU_DESTID
25 25 }
26 26 # </CHANGE BEFORE FLIGHT>
27 27
28 28 contains( CONFIG, debug_tch ) {
29 29 DEFINES += DEBUG_TCH
30 30 }
31 31 DEFINES += MSB_FIRST_TCH
32 32
33 33 contains( CONFIG, vhdl_dev ) {
34 34 DEFINES += VHDL_DEV
35 35 }
36 36
37 37 contains( CONFIG, verbose ) {
38 38 DEFINES += PRINT_MESSAGES_ON_CONSOLE
39 39 }
40 40
41 41 contains( CONFIG, debug_messages ) {
42 42 DEFINES += DEBUG_MESSAGES
43 43 }
44 44
45 45 contains( CONFIG, cpu_usage_report ) {
46 46 DEFINES += PRINT_TASK_STATISTICS
47 47 }
48 48
49 49 contains( CONFIG, stack_report ) {
50 50 DEFINES += PRINT_STACK_REPORT
51 51 }
52 52
53 53 contains( CONFIG, boot_messages ) {
54 54 DEFINES += BOOT_MESSAGES
55 55 }
56 56
57 57 #doxygen.target = doxygen
58 58 #doxygen.commands = doxygen ../doc/Doxyfile
59 59 #QMAKE_EXTRA_TARGETS += doxygen
60 60
61 61 TARGET = fsw
62 62
63 63 INCLUDEPATH += \
64 64 $${PWD}/../src \
65 65 $${PWD}/../header \
66 66 $${PWD}/../header/lfr_common_headers \
67 67 $${PWD}/../header/processing \
68 68 $${PWD}/../LFR_basic-parameters
69 69
70 70 SOURCES += \
71 71 ../src/wf_handler.c \
72 72 ../src/tc_handler.c \
73 73 ../src/fsw_misc.c \
74 74 ../src/fsw_init.c \
75 75 ../src/fsw_globals.c \
76 76 ../src/fsw_spacewire.c \
77 77 ../src/tc_load_dump_parameters.c \
78 78 ../src/tm_lfr_tc_exe.c \
79 79 ../src/tc_acceptance.c \
80 80 ../src/processing/fsw_processing.c \
81 81 ../src/processing/avf0_prc0.c \
82 82 ../src/processing/avf1_prc1.c \
83 83 ../src/processing/avf2_prc2.c \
84 84 ../src/lfr_cpu_usage_report.c \
85 85 ../LFR_basic-parameters/basic_parameters.c
86 86
87 87 HEADERS += \
88 88 ../header/wf_handler.h \
89 89 ../header/tc_handler.h \
90 90 ../header/grlib_regs.h \
91 91 ../header/fsw_misc.h \
92 92 ../header/fsw_init.h \
93 93 ../header/fsw_spacewire.h \
94 94 ../header/tc_load_dump_parameters.h \
95 95 ../header/tm_lfr_tc_exe.h \
96 96 ../header/tc_acceptance.h \
97 97 ../header/processing/fsw_processing.h \
98 98 ../header/processing/avf0_prc0.h \
99 99 ../header/processing/avf1_prc1.h \
100 100 ../header/processing/avf2_prc2.h \
101 101 ../header/fsw_params_wf_handler.h \
102 102 ../header/lfr_cpu_usage_report.h \
103 103 ../header/lfr_common_headers/ccsds_types.h \
104 104 ../header/lfr_common_headers/fsw_params.h \
105 105 ../header/lfr_common_headers/fsw_params_nb_bytes.h \
106 106 ../header/lfr_common_headers/fsw_params_processing.h \
107 107 ../header/lfr_common_headers/TC_types.h \
108 108 ../header/lfr_common_headers/tm_byte_positions.h \
109 109 ../LFR_basic-parameters/basic_parameters.h \
110 110 ../LFR_basic-parameters/basic_parameters_params.h \
111 111 ../header/GscMemoryLPP.hpp
112 112
Show file before | Show file after | Hide comments
@@ -1,1372 +1,1372
1 1 /** Functions and tasks related to waveform packet generation.
2 2 *
3 3 * @file
4 4 * @author P. LEROY
5 5 *
6 6 * A group of functions to handle waveforms, in snapshot or continuous format.\n
7 7 *
8 8 */
9 9
10 10 #include "wf_handler.h"
11 11
12 12 //***************
13 13 // waveform rings
14 14 // F0
15 15 ring_node waveform_ring_f0[NB_RING_NODES_F0];
16 16 ring_node *current_ring_node_f0;
17 17 ring_node *ring_node_to_send_swf_f0;
18 18 // F1
19 19 ring_node waveform_ring_f1[NB_RING_NODES_F1];
20 20 ring_node *current_ring_node_f1;
21 21 ring_node *ring_node_to_send_swf_f1;
22 22 ring_node *ring_node_to_send_cwf_f1;
23 23 // F2
24 24 ring_node waveform_ring_f2[NB_RING_NODES_F2];
25 25 ring_node *current_ring_node_f2;
26 26 ring_node *ring_node_to_send_swf_f2;
27 27 ring_node *ring_node_to_send_cwf_f2;
28 28 // F3
29 29 ring_node waveform_ring_f3[NB_RING_NODES_F3];
30 30 ring_node *current_ring_node_f3;
31 31 ring_node *ring_node_to_send_cwf_f3;
32 32 char wf_cont_f3_light[ (NB_SAMPLES_PER_SNAPSHOT) * NB_BYTES_CWF3_LIGHT_BLK ];
33 33
34 34 bool extractSWF = false;
35 35 bool swf_f0_ready = false;
36 36 bool swf_f1_ready = false;
37 37 bool swf_f2_ready = false;
38 38
39 39 int wf_snap_extracted[ (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK) ];
40 40 ring_node ring_node_wf_snap_extracted;
41 41
42 42 //*********************
43 43 // Interrupt SubRoutine
44 44
45 45 ring_node * getRingNodeToSendCWF( unsigned char frequencyChannel)
46 46 {
47 47 ring_node *node;
48 48
49 49 node = NULL;
50 50 switch ( frequencyChannel ) {
51 51 case 1:
52 52 node = ring_node_to_send_cwf_f1;
53 53 break;
54 54 case 2:
55 55 node = ring_node_to_send_cwf_f2;
56 56 break;
57 57 case 3:
58 58 node = ring_node_to_send_cwf_f3;
59 59 break;
60 60 default:
61 61 break;
62 62 }
63 63
64 64 return node;
65 65 }
66 66
67 67 ring_node * getRingNodeToSendSWF( unsigned char frequencyChannel)
68 68 {
69 69 ring_node *node;
70 70
71 71 node = NULL;
72 72 switch ( frequencyChannel ) {
73 73 case 0:
74 74 node = ring_node_to_send_swf_f0;
75 75 break;
76 76 case 1:
77 77 node = ring_node_to_send_swf_f1;
78 78 break;
79 79 case 2:
80 80 node = ring_node_to_send_swf_f2;
81 81 break;
82 82 default:
83 83 break;
84 84 }
85 85
86 86 return node;
87 87 }
88 88
89 89 void reset_extractSWF( void )
90 90 {
91 91 extractSWF = false;
92 92 swf_f0_ready = false;
93 93 swf_f1_ready = false;
94 94 swf_f2_ready = false;
95 95 }
96 96
97 97 inline void waveforms_isr_f3( void )
98 98 {
99 99 rtems_status_code spare_status;
100 100
101 101 if ( (lfrCurrentMode == LFR_MODE_NORMAL) || (lfrCurrentMode == LFR_MODE_BURST) // in BURST the data are used to place v, e1 and e2 in the HK packet
102 102 || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )
103 103 { // in modes other than STANDBY and BURST, send the CWF_F3 data
104 104 //***
105 105 // F3
106 106 if ( (waveform_picker_regs->status & 0xc0) != 0x00 ) { // [1100 0000] check the f3 full bits
107 107 ring_node_to_send_cwf_f3 = current_ring_node_f3->previous;
108 108 current_ring_node_f3 = current_ring_node_f3->next;
109 109 if ((waveform_picker_regs->status & 0x40) == 0x40){ // [0100 0000] f3 buffer 0 is full
110 110 ring_node_to_send_cwf_f3->coarseTime = waveform_picker_regs->f3_0_coarse_time;
111 111 ring_node_to_send_cwf_f3->fineTime = waveform_picker_regs->f3_0_fine_time;
112 112 waveform_picker_regs->addr_data_f3_0 = current_ring_node_f3->buffer_address;
113 113 waveform_picker_regs->status = waveform_picker_regs->status & 0x00008840; // [1000 1000 0100 0000]
114 114 }
115 115 else if ((waveform_picker_regs->status & 0x80) == 0x80){ // [1000 0000] f3 buffer 1 is full
116 116 ring_node_to_send_cwf_f3->coarseTime = waveform_picker_regs->f3_1_coarse_time;
117 117 ring_node_to_send_cwf_f3->fineTime = waveform_picker_regs->f3_1_fine_time;
118 118 waveform_picker_regs->addr_data_f3_1 = current_ring_node_f3->buffer_address;
119 119 waveform_picker_regs->status = waveform_picker_regs->status & 0x00008880; // [1000 1000 1000 0000]
120 120 }
121 121 if (rtems_event_send( Task_id[TASKID_CWF3], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
122 122 spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );
123 123 }
124 124 }
125 125 }
126 126 }
127 127
128 128 inline void waveforms_isr_normal( void )
129 129 {
130 130 rtems_status_code status;
131 131
132 132 if ( ( (waveform_picker_regs->status & 0x30) != 0x00 ) // [0011 0000] check the f2 full bits
133 133 && ( (waveform_picker_regs->status & 0x0c) != 0x00 ) // [0000 1100] check the f1 full bits
134 134 && ( (waveform_picker_regs->status & 0x03) != 0x00 )) // [0000 0011] check the f0 full bits
135 135 {
136 136 //***
137 137 // F0
138 138 ring_node_to_send_swf_f0 = current_ring_node_f0->previous;
139 139 current_ring_node_f0 = current_ring_node_f0->next;
140 140 if ( (waveform_picker_regs->status & 0x01) == 0x01)
141 141 {
142 142
143 143 ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_0_coarse_time;
144 144 ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_0_fine_time;
145 145 waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->buffer_address;
146 146 waveform_picker_regs->status = waveform_picker_regs->status & 0x00001101; // [0001 0001 0000 0001]
147 147 }
148 148 else if ( (waveform_picker_regs->status & 0x02) == 0x02)
149 149 {
150 150 ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_1_coarse_time;
151 151 ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_1_fine_time;
152 152 waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address;
153 153 waveform_picker_regs->status = waveform_picker_regs->status & 0x00001102; // [0001 0001 0000 0010]
154 154 }
155 155
156 156 //***
157 157 // F1
158 158 ring_node_to_send_swf_f1 = current_ring_node_f1->previous;
159 159 current_ring_node_f1 = current_ring_node_f1->next;
160 160 if ( (waveform_picker_regs->status & 0x04) == 0x04)
161 161 {
162 162 ring_node_to_send_swf_f1->coarseTime = waveform_picker_regs->f1_0_coarse_time;
163 163 ring_node_to_send_swf_f1->fineTime = waveform_picker_regs->f1_0_fine_time;
164 164 waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->buffer_address;
165 165 waveform_picker_regs->status = waveform_picker_regs->status & 0x00002204; // [0010 0010 0000 0100] f1 bits = 0
166 166 }
167 167 else if ( (waveform_picker_regs->status & 0x08) == 0x08)
168 168 {
169 169 ring_node_to_send_swf_f1->coarseTime = waveform_picker_regs->f1_1_coarse_time;
170 170 ring_node_to_send_swf_f1->fineTime = waveform_picker_regs->f1_1_fine_time;
171 171 waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address;
172 172 waveform_picker_regs->status = waveform_picker_regs->status & 0x00002208; // [0010 0010 0000 1000] f1 bits = 0
173 173 }
174 174
175 175 //***
176 176 // F2
177 177 ring_node_to_send_swf_f2 = current_ring_node_f2->previous;
178 178 current_ring_node_f2 = current_ring_node_f2->next;
179 179 if ( (waveform_picker_regs->status & 0x10) == 0x10)
180 180 {
181 181 ring_node_to_send_swf_f2->coarseTime = waveform_picker_regs->f2_0_coarse_time;
182 182 ring_node_to_send_swf_f2->fineTime = waveform_picker_regs->f2_0_fine_time;
183 183 waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address;
184 184 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]
185 185 }
186 186 else if ( (waveform_picker_regs->status & 0x20) == 0x20)
187 187 {
188 188 ring_node_to_send_swf_f2->coarseTime = waveform_picker_regs->f2_1_coarse_time;
189 189 ring_node_to_send_swf_f2->fineTime = waveform_picker_regs->f2_1_fine_time;
190 190 waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address;
191 191 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]
192 192 }
193 193 //
194 194 status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_NORMAL );
195 195 if ( status != RTEMS_SUCCESSFUL)
196 196 {
197 197 status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );
198 198 }
199 199 }
200 200 }
201 201
202 202 inline void waveforms_isr_burst( void )
203 203 {
204 204 unsigned char status;
205 205 rtems_status_code spare_status;
206 206
207 207 status = (waveform_picker_regs->status & 0x30) >> 4; // [0011 0000] get the status bits for f2
208 208
209 209
210 210 switch(status)
211 211 {
212 212 case 1:
213 213 ring_node_to_send_cwf_f2 = current_ring_node_f2->previous;
214 214 ring_node_to_send_cwf_f2->sid = SID_BURST_CWF_F2;
215 215 ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_0_coarse_time;
216 216 ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_0_fine_time;
217 217 current_ring_node_f2 = current_ring_node_f2->next;
218 218 waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address;
219 219 if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) {
220 220 spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );
221 221 }
222 222 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]
223 223 break;
224 224 case 2:
225 225 ring_node_to_send_cwf_f2 = current_ring_node_f2->previous;
226 226 ring_node_to_send_cwf_f2->sid = SID_BURST_CWF_F2;
227 227 ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_1_coarse_time;
228 228 ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_1_fine_time;
229 229 current_ring_node_f2 = current_ring_node_f2->next;
230 230 waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address;
231 231 if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) {
232 232 spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );
233 233 }
234 234 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]
235 235 break;
236 236 default:
237 237 break;
238 238 }
239 239 }
240 240
241 241 inline void waveforms_isr_sbm1( void )
242 242 {
243 243 rtems_status_code status;
244 244
245 245 //***
246 246 // F1
247 247 if ( (waveform_picker_regs->status & 0x0c) != 0x00 ) { // [0000 1100] check the f1 full bits
248 248 // (1) change the receiving buffer for the waveform picker
249 249 ring_node_to_send_cwf_f1 = current_ring_node_f1->previous;
250 250 current_ring_node_f1 = current_ring_node_f1->next;
251 251 if ( (waveform_picker_regs->status & 0x04) == 0x04)
252 252 {
253 253 ring_node_to_send_cwf_f1->coarseTime = waveform_picker_regs->f1_0_coarse_time;
254 254 ring_node_to_send_cwf_f1->fineTime = waveform_picker_regs->f1_0_fine_time;
255 255 waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->buffer_address;
256 256 waveform_picker_regs->status = waveform_picker_regs->status & 0x00002204; // [0010 0010 0000 0100] f1 bits = 0
257 257 }
258 258 else if ( (waveform_picker_regs->status & 0x08) == 0x08)
259 259 {
260 260 ring_node_to_send_cwf_f1->coarseTime = waveform_picker_regs->f1_1_coarse_time;
261 261 ring_node_to_send_cwf_f1->fineTime = waveform_picker_regs->f1_1_fine_time;
262 262 waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address;
263 263 waveform_picker_regs->status = waveform_picker_regs->status & 0x00002208; // [0010 0010 0000 1000] f1 bits = 0
264 264 }
265 265 // (2) send an event for the the CWF1 task for transmission (and snapshot extraction if needed)
266 266 status = rtems_event_send( Task_id[TASKID_CWF1], RTEMS_EVENT_MODE_SBM1 );
267 267 }
268 268
269 269 //***
270 270 // F0
271 271 if ( (waveform_picker_regs->status & 0x03) != 0x00 ) { // [0000 0011] check the f0 full bits
272 272 swf_f0_ready = true;
273 273 // change f0 buffer
274 274 ring_node_to_send_swf_f0 = current_ring_node_f0->previous;
275 275 current_ring_node_f0 = current_ring_node_f0->next;
276 276 if ( (waveform_picker_regs->status & 0x01) == 0x01)
277 277 {
278 278
279 279 ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_0_coarse_time;
280 280 ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_0_fine_time;
281 281 waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->buffer_address;
282 282 waveform_picker_regs->status = waveform_picker_regs->status & 0x00001101; // [0001 0001 0000 0001]
283 283 }
284 284 else if ( (waveform_picker_regs->status & 0x02) == 0x02)
285 285 {
286 286 ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_1_coarse_time;
287 287 ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_1_fine_time;
288 288 waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address;
289 289 waveform_picker_regs->status = waveform_picker_regs->status & 0x00001102; // [0001 0001 0000 0010]
290 290 }
291 291 }
292 292
293 293 //***
294 294 // F2
295 295 if ( (waveform_picker_regs->status & 0x30) != 0x00 ) { // [0011 0000] check the f2 full bits
296 296 swf_f2_ready = true;
297 297 // change f2 buffer
298 298 ring_node_to_send_swf_f2 = current_ring_node_f2->previous;
299 299 current_ring_node_f2 = current_ring_node_f2->next;
300 300 if ( (waveform_picker_regs->status & 0x10) == 0x10)
301 301 {
302 302 ring_node_to_send_swf_f2->coarseTime = waveform_picker_regs->f2_0_coarse_time;
303 303 ring_node_to_send_swf_f2->fineTime = waveform_picker_regs->f2_0_fine_time;
304 304 waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address;
305 305 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]
306 306 }
307 307 else if ( (waveform_picker_regs->status & 0x20) == 0x20)
308 308 {
309 309 ring_node_to_send_swf_f2->coarseTime = waveform_picker_regs->f2_1_coarse_time;
310 310 ring_node_to_send_swf_f2->fineTime = waveform_picker_regs->f2_1_fine_time;
311 311 waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address;
312 312 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]
313 313 }
314 314 }
315 315 }
316 316
317 317 inline void waveforms_isr_sbm2( void )
318 318 {
319 319 rtems_status_code status;
320 320
321 321 //***
322 322 // F2
323 323 if ( (waveform_picker_regs->status & 0x30) != 0x00 ) { // [0011 0000] check the f2 full bit
324 324 // (1) change the receiving buffer for the waveform picker
325 325 ring_node_to_send_cwf_f2 = current_ring_node_f2->previous;
326 326 ring_node_to_send_cwf_f2->sid = SID_SBM2_CWF_F2;
327 327 current_ring_node_f2 = current_ring_node_f2->next;
328 328 if ( (waveform_picker_regs->status & 0x10) == 0x10)
329 329 {
330 330 ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_0_coarse_time;
331 331 ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_0_fine_time;
332 332 waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address;
333 333 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]
334 334 }
335 335 else if ( (waveform_picker_regs->status & 0x20) == 0x20)
336 336 {
337 337 ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_1_coarse_time;
338 338 ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_1_fine_time;
339 339 waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address;
340 340 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]
341 341 }
342 342 // (2) send an event for the waveforms transmission
343 343 status = rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_SBM2 );
344 344 }
345 345
346 346 //***
347 347 // F0
348 348 if ( (waveform_picker_regs->status & 0x03) != 0x00 ) { // [0000 0011] check the f0 full bit
349 349 swf_f0_ready = true;
350 350 // change f0 buffer
351 351 ring_node_to_send_swf_f0 = current_ring_node_f0->previous;
352 352 current_ring_node_f0 = current_ring_node_f0->next;
353 353 if ( (waveform_picker_regs->status & 0x01) == 0x01)
354 354 {
355 355
356 356 ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_0_coarse_time;
357 357 ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_0_fine_time;
358 358 waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->buffer_address;
359 359 waveform_picker_regs->status = waveform_picker_regs->status & 0x00001101; // [0001 0001 0000 0001]
360 360 }
361 361 else if ( (waveform_picker_regs->status & 0x02) == 0x02)
362 362 {
363 363 ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_1_coarse_time;
364 364 ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_1_fine_time;
365 365 waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address;
366 366 waveform_picker_regs->status = waveform_picker_regs->status & 0x00001102; // [0001 0001 0000 0010]
367 367 }
368 368 }
369 369
370 370 //***
371 371 // F1
372 372 if ( (waveform_picker_regs->status & 0x0c) != 0x00 ) { // [0000 1100] check the f1 full bit
373 373 swf_f1_ready = true;
374 374 ring_node_to_send_swf_f1 = current_ring_node_f1->previous;
375 375 current_ring_node_f1 = current_ring_node_f1->next;
376 376 if ( (waveform_picker_regs->status & 0x04) == 0x04)
377 377 {
378 378 ring_node_to_send_swf_f1->coarseTime = waveform_picker_regs->f1_0_coarse_time;
379 379 ring_node_to_send_swf_f1->fineTime = waveform_picker_regs->f1_0_fine_time;
380 380 waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->buffer_address;
381 381 waveform_picker_regs->status = waveform_picker_regs->status & 0x00002204; // [0010 0010 0000 0100] f1 bits = 0
382 382 }
383 383 else if ( (waveform_picker_regs->status & 0x08) == 0x08)
384 384 {
385 385 ring_node_to_send_swf_f1->coarseTime = waveform_picker_regs->f1_1_coarse_time;
386 386 ring_node_to_send_swf_f1->fineTime = waveform_picker_regs->f1_1_fine_time;
387 387 waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address;
388 388 waveform_picker_regs->status = waveform_picker_regs->status & 0x00002208; // [0010 0010 0000 1000] f1 bits = 0
389 389 }
390 390 }
391 391 }
392 392
393 393 rtems_isr waveforms_isr( rtems_vector_number vector )
394 394 {
395 395 /** This is the interrupt sub routine called by the waveform picker core.
396 396 *
397 397 * This ISR launch different actions depending mainly on two pieces of information:
398 398 * 1. the values read in the registers of the waveform picker.
399 399 * 2. the current LFR mode.
400 400 *
401 401 */
402 402
403 403 // STATUS
404 404 // new error error buffer full
405 405 // 15 14 13 12 11 10 9 8
406 406 // f3 f2 f1 f0 f3 f2 f1 f0
407 407 //
408 408 // ready buffer
409 409 // 7 6 5 4 3 2 1 0
410 410 // f3_1 f3_0 f2_1 f2_0 f1_1 f1_0 f0_1 f0_0
411 411
412 412 rtems_status_code spare_status;
413 413
414 414 waveforms_isr_f3();
415 415
416 416 if ( (waveform_picker_regs->status & 0xff00) != 0x00) // [1111 1111 0000 0000] check the error bits
417 417 {
418 418 spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_10 );
419 419 }
420 420
421 421 switch(lfrCurrentMode)
422 422 {
423 423 //********
424 424 // STANDBY
425 425 case(LFR_MODE_STANDBY):
426 426 break;
427 427
428 428 //******
429 429 // NORMAL
430 430 case(LFR_MODE_NORMAL):
431 431 waveforms_isr_normal();
432 432 break;
433 433
434 434 //******
435 435 // BURST
436 436 case(LFR_MODE_BURST):
437 437 waveforms_isr_burst();
438 438 break;
439 439
440 440 //*****
441 441 // SBM1
442 442 case(LFR_MODE_SBM1):
443 443 waveforms_isr_sbm1();
444 444 break;
445 445
446 446 //*****
447 447 // SBM2
448 448 case(LFR_MODE_SBM2):
449 449 waveforms_isr_sbm2();
450 450 break;
451 451
452 452 //********
453 453 // DEFAULT
454 454 default:
455 455 break;
456 456 }
457 457 }
458 458
459 459 //************
460 460 // RTEMS TASKS
461 461
462 462 rtems_task wfrm_task(rtems_task_argument argument) //used with the waveform picker VHDL IP
463 463 {
464 464 /** This RTEMS task is dedicated to the transmission of snapshots of the NORMAL mode.
465 465 *
466 466 * @param unused is the starting argument of the RTEMS task
467 467 *
468 468 * The following data packets are sent by this task:
469 469 * - TM_LFR_SCIENCE_NORMAL_SWF_F0
470 470 * - TM_LFR_SCIENCE_NORMAL_SWF_F1
471 471 * - TM_LFR_SCIENCE_NORMAL_SWF_F2
472 472 *
473 473 */
474 474
475 475 rtems_event_set event_out;
476 476 rtems_id queue_id;
477 477 rtems_status_code status;
478 478 bool resynchronisationEngaged;
479 479 ring_node *ring_node_wf_snap_extracted_ptr;
480 480
481 481 ring_node_wf_snap_extracted_ptr = (ring_node *) &ring_node_wf_snap_extracted;
482 482
483 483 resynchronisationEngaged = false;
484 484
485 485 status = get_message_queue_id_send( &queue_id );
486 486 if (status != RTEMS_SUCCESSFUL)
487 487 {
488 488 PRINTF1("in WFRM *** ERR get_message_queue_id_send %d\n", status)
489 489 }
490 490
491 491 BOOT_PRINTF("in WFRM ***\n")
492 492
493 493 while(1){
494 494 // wait for an RTEMS_EVENT
495 495 rtems_event_receive(RTEMS_EVENT_MODE_NORMAL | RTEMS_EVENT_MODE_SBM1
496 496 | RTEMS_EVENT_MODE_SBM2 | RTEMS_EVENT_MODE_SBM2_WFRM,
497 497 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
498 498 if(resynchronisationEngaged == false)
499 499 { // engage resynchronisation
500 500 snapshot_resynchronization( (unsigned char *) &ring_node_to_send_swf_f0->coarseTime );
501 501 resynchronisationEngaged = true;
502 502 }
503 503 else
504 504 { // reset delta_snapshot to the nominal value
505 505 PRINTF("no resynchronisation, reset delta_snapshot to the nominal value\n")
506 506 set_wfp_delta_snapshot();
507 507 resynchronisationEngaged = false;
508 508 }
509 509 //
510 510
511 511 if (event_out == RTEMS_EVENT_MODE_NORMAL)
512 512 {
513 513 DEBUG_PRINTF("WFRM received RTEMS_EVENT_MODE_NORMAL\n")
514 514 ring_node_to_send_swf_f0->sid = SID_NORM_SWF_F0;
515 515 ring_node_to_send_swf_f1->sid = SID_NORM_SWF_F1;
516 516 ring_node_to_send_swf_f2->sid = SID_NORM_SWF_F2;
517 517 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f0, sizeof( ring_node* ) );
518 518 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f1, sizeof( ring_node* ) );
519 519 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f2, sizeof( ring_node* ) );
520 520 }
521 521 if (event_out == RTEMS_EVENT_MODE_SBM1)
522 522 {
523 523 DEBUG_PRINTF("WFRM received RTEMS_EVENT_MODE_SBM1\n")
524 524 ring_node_to_send_swf_f0->sid = SID_NORM_SWF_F0;
525 525 ring_node_wf_snap_extracted_ptr->sid = SID_NORM_SWF_F1;
526 526 ring_node_to_send_swf_f2->sid = SID_NORM_SWF_F2;
527 527 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f0, sizeof( ring_node* ) );
528 528 status = rtems_message_queue_send( queue_id, &ring_node_wf_snap_extracted_ptr, sizeof( ring_node* ) );
529 529 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f2, sizeof( ring_node* ) );
530 530 }
531 531 if (event_out == RTEMS_EVENT_MODE_SBM2)
532 532 {
533 533 DEBUG_PRINTF("WFRM received RTEMS_EVENT_MODE_SBM2\n")
534 534 ring_node_to_send_swf_f0->sid = SID_NORM_SWF_F0;
535 535 ring_node_to_send_swf_f1->sid = SID_NORM_SWF_F1;
536 536 ring_node_wf_snap_extracted_ptr->sid = SID_NORM_SWF_F2;
537 537 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f0, sizeof( ring_node* ) );
538 538 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f1, sizeof( ring_node* ) );
539 539 status = rtems_message_queue_send( queue_id, &ring_node_wf_snap_extracted_ptr, sizeof( ring_node* ) );
540 540 }
541 541 }
542 542 }
543 543
544 544 rtems_task cwf3_task(rtems_task_argument argument) //used with the waveform picker VHDL IP
545 545 {
546 546 /** This RTEMS task is dedicated to the transmission of continuous waveforms at f3.
547 547 *
548 548 * @param unused is the starting argument of the RTEMS task
549 549 *
550 550 * The following data packet is sent by this task:
551 551 * - TM_LFR_SCIENCE_NORMAL_CWF_F3
552 552 *
553 553 */
554 554
555 555 rtems_event_set event_out;
556 556 rtems_id queue_id;
557 557 rtems_status_code status;
558 558 ring_node ring_node_cwf3_light;
559 559 ring_node *ring_node_to_send_cwf;
560 560
561 561 status = get_message_queue_id_send( &queue_id );
562 562 if (status != RTEMS_SUCCESSFUL)
563 563 {
564 564 PRINTF1("in CWF3 *** ERR get_message_queue_id_send %d\n", status)
565 565 }
566 566
567 567 ring_node_to_send_cwf_f3->sid = SID_NORM_CWF_LONG_F3;
568 568
569 569 // init the ring_node_cwf3_light structure
570 570 ring_node_cwf3_light.buffer_address = (int) wf_cont_f3_light;
571 571 ring_node_cwf3_light.coarseTime = 0x00;
572 572 ring_node_cwf3_light.fineTime = 0x00;
573 573 ring_node_cwf3_light.next = NULL;
574 574 ring_node_cwf3_light.previous = NULL;
575 575 ring_node_cwf3_light.sid = SID_NORM_CWF_F3;
576 576 ring_node_cwf3_light.status = 0x00;
577 577
578 578 BOOT_PRINTF("in CWF3 ***\n")
579 579
580 580 while(1){
581 581 // wait for an RTEMS_EVENT
582 582 rtems_event_receive( RTEMS_EVENT_0,
583 583 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
584 584 if ( (lfrCurrentMode == LFR_MODE_NORMAL)
585 585 || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode==LFR_MODE_SBM2) )
586 586 {
587 587 ring_node_to_send_cwf = getRingNodeToSendCWF( 3 );
588 588 if ( (parameter_dump_packet.sy_lfr_n_cwf_long_f3 & 0x01) == 0x01)
589 589 {
590 590 PRINTF("send CWF_LONG_F3\n")
591 591 ring_node_to_send_cwf_f3->sid = SID_NORM_CWF_LONG_F3;
592 592 status = rtems_message_queue_send( queue_id, &ring_node_to_send_cwf, sizeof( ring_node* ) );
593 593 }
594 594 else
595 595 {
596 596 PRINTF("send CWF_F3 (light)\n")
597 597 send_waveform_CWF3_light( ring_node_to_send_cwf, &ring_node_cwf3_light, queue_id );
598 598 }
599 599
600 600 }
601 601 else
602 602 {
603 603 PRINTF1("in CWF3 *** lfrCurrentMode is %d, no data will be sent\n", lfrCurrentMode)
604 604 }
605 605 }
606 606 }
607 607
608 608 rtems_task cwf2_task(rtems_task_argument argument) // ONLY USED IN BURST AND SBM2
609 609 {
610 610 /** This RTEMS task is dedicated to the transmission of continuous waveforms at f2.
611 611 *
612 612 * @param unused is the starting argument of the RTEMS task
613 613 *
614 614 * The following data packet is sent by this function:
615 615 * - TM_LFR_SCIENCE_BURST_CWF_F2
616 616 * - TM_LFR_SCIENCE_SBM2_CWF_F2
617 617 *
618 618 */
619 619
620 620 rtems_event_set event_out;
621 621 rtems_id queue_id;
622 622 rtems_status_code status;
623 623 ring_node *ring_node_to_send;
624 624 unsigned long long int acquisitionTimeF0_asLong;
625 625
626 626 acquisitionTimeF0_asLong = 0x00;
627 627
628 628 status = get_message_queue_id_send( &queue_id );
629 629 if (status != RTEMS_SUCCESSFUL)
630 630 {
631 631 PRINTF1("in CWF2 *** ERR get_message_queue_id_send %d\n", status)
632 632 }
633 633
634 634 BOOT_PRINTF("in CWF2 ***\n")
635 635
636 636 while(1){
637 637 // wait for an RTEMS_EVENT
638 638 rtems_event_receive( RTEMS_EVENT_MODE_BURST | RTEMS_EVENT_MODE_SBM2,
639 639 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
640 640 ring_node_to_send = getRingNodeToSendCWF( 2 );
641 641 if (event_out == RTEMS_EVENT_MODE_BURST)
642 642 {
643 643 status = rtems_message_queue_send( queue_id, &ring_node_to_send, sizeof( ring_node* ) );
644 644 }
645 645 if (event_out == RTEMS_EVENT_MODE_SBM2)
646 646 {
647 647 status = rtems_message_queue_send( queue_id, &ring_node_to_send, sizeof( ring_node* ) );
648 648 // launch snapshot extraction if needed
649 649 if (extractSWF == true)
650 650 {
651 651 ring_node_to_send_swf_f2 = ring_node_to_send_cwf_f2;
652 652 // extract the snapshot
653 653 build_snapshot_from_ring( ring_node_to_send_swf_f2, 2, acquisitionTimeF0_asLong );
654 654 // send the snapshot when built
655 655 status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_SBM2 );
656 656 extractSWF = false;
657 657 }
658 658 if (swf_f0_ready && swf_f1_ready)
659 659 {
660 660 extractSWF = true;
661 661 // record the acquition time of the fΓ  snapshot to use to build the snapshot at f2
662 662 acquisitionTimeF0_asLong = get_acquisition_time( (unsigned char *) &ring_node_to_send_swf_f0->coarseTime );
663 663 swf_f0_ready = false;
664 664 swf_f1_ready = false;
665 665 }
666 666 }
667 667 }
668 668 }
669 669
670 670 rtems_task cwf1_task(rtems_task_argument argument) // ONLY USED IN SBM1
671 671 {
672 672 /** This RTEMS task is dedicated to the transmission of continuous waveforms at f1.
673 673 *
674 674 * @param unused is the starting argument of the RTEMS task
675 675 *
676 676 * The following data packet is sent by this function:
677 677 * - TM_LFR_SCIENCE_SBM1_CWF_F1
678 678 *
679 679 */
680 680
681 681 rtems_event_set event_out;
682 682 rtems_id queue_id;
683 683 rtems_status_code status;
684 684
685 685 ring_node *ring_node_to_send_cwf;
686 686
687 687 status = get_message_queue_id_send( &queue_id );
688 688 if (status != RTEMS_SUCCESSFUL)
689 689 {
690 690 PRINTF1("in CWF1 *** ERR get_message_queue_id_send %d\n", status)
691 691 }
692 692
693 693 BOOT_PRINTF("in CWF1 ***\n")
694 694
695 695 while(1){
696 696 // wait for an RTEMS_EVENT
697 697 rtems_event_receive( RTEMS_EVENT_MODE_SBM1,
698 698 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
699 699 ring_node_to_send_cwf = getRingNodeToSendCWF( 1 );
700 700 ring_node_to_send_cwf_f1->sid = SID_SBM1_CWF_F1;
701 701 status = rtems_message_queue_send( queue_id, &ring_node_to_send_cwf, sizeof( ring_node* ) );
702 702 if (status != 0)
703 703 printf("cwf sending failed\n");
704 704 // launch snapshot extraction if needed
705 705 if (extractSWF == true)
706 706 {
707 707 ring_node_to_send_swf_f1 = ring_node_to_send_cwf;
708 708 // launch the snapshot extraction
709 709 status = rtems_event_send( Task_id[TASKID_SWBD], RTEMS_EVENT_MODE_SBM1 );
710 710 extractSWF = false;
711 711 }
712 712 if (swf_f0_ready == true)
713 713 {
714 714 extractSWF = true;
715 715 swf_f0_ready = false; // this step shall be executed only one time
716 716 }
717 717 if ((swf_f1_ready == true) && (swf_f2_ready == true)) // swf_f1 is ready after the extraction
718 718 {
719 719 status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_SBM1 );
720 720 swf_f1_ready = false;
721 721 swf_f2_ready = false;
722 722 }
723 723 }
724 724 }
725 725
726 726 rtems_task swbd_task(rtems_task_argument argument)
727 727 {
728 728 /** This RTEMS task is dedicated to the building of snapshots from different continuous waveforms buffers.
729 729 *
730 730 * @param unused is the starting argument of the RTEMS task
731 731 *
732 732 */
733 733
734 734 rtems_event_set event_out;
735 735 unsigned long long int acquisitionTimeF0_asLong;
736 736
737 737 acquisitionTimeF0_asLong = 0x00;
738 738
739 739 BOOT_PRINTF("in SWBD ***\n")
740 740
741 741 while(1){
742 742 // wait for an RTEMS_EVENT
743 743 rtems_event_receive( RTEMS_EVENT_MODE_SBM1 | RTEMS_EVENT_MODE_SBM2,
744 744 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
745 745 if (event_out == RTEMS_EVENT_MODE_SBM1)
746 746 {
747 747 acquisitionTimeF0_asLong = get_acquisition_time( (unsigned char *) &ring_node_to_send_swf_f0->coarseTime );
748 748 build_snapshot_from_ring( ring_node_to_send_swf_f1, 1, acquisitionTimeF0_asLong );
749 749 swf_f1_ready = true; // the snapshot has been extracted and is ready to be sent
750 750 }
751 751 else
752 752 {
753 753 PRINTF1("in SWBD *** unexpected rtems event received %x\n", (int) event_out)
754 754 }
755 755 }
756 756 }
757 757
758 758 //******************
759 759 // general functions
760 760
761 761 void WFP_init_rings( void )
762 762 {
763 763 // F0 RING
764 764 init_ring( waveform_ring_f0, NB_RING_NODES_F0, wf_buffer_f0, WFRM_BUFFER );
765 765 // F1 RING
766 766 init_ring( waveform_ring_f1, NB_RING_NODES_F1, wf_buffer_f1, WFRM_BUFFER );
767 767 // F2 RING
768 768 init_ring( waveform_ring_f2, NB_RING_NODES_F2, wf_buffer_f2, WFRM_BUFFER );
769 769 // F3 RING
770 770 init_ring( waveform_ring_f3, NB_RING_NODES_F3, wf_buffer_f3, WFRM_BUFFER );
771 771
772 772 ring_node_wf_snap_extracted.buffer_address = (int) wf_snap_extracted;
773 773
774 774 DEBUG_PRINTF1("waveform_ring_f0 @%x\n", (unsigned int) waveform_ring_f0)
775 775 DEBUG_PRINTF1("waveform_ring_f1 @%x\n", (unsigned int) waveform_ring_f1)
776 776 DEBUG_PRINTF1("waveform_ring_f2 @%x\n", (unsigned int) waveform_ring_f2)
777 777 DEBUG_PRINTF1("waveform_ring_f3 @%x\n", (unsigned int) waveform_ring_f3)
778 778 DEBUG_PRINTF1("wf_buffer_f0 @%x\n", (unsigned int) wf_buffer_f0)
779 779 DEBUG_PRINTF1("wf_buffer_f1 @%x\n", (unsigned int) wf_buffer_f1)
780 780 DEBUG_PRINTF1("wf_buffer_f2 @%x\n", (unsigned int) wf_buffer_f2)
781 781 DEBUG_PRINTF1("wf_buffer_f3 @%x\n", (unsigned int) wf_buffer_f3)
782 782
783 783 }
784 784
785 785 void WFP_reset_current_ring_nodes( void )
786 786 {
787 787 current_ring_node_f0 = waveform_ring_f0[0].next;
788 788 current_ring_node_f1 = waveform_ring_f1[0].next;
789 789 current_ring_node_f2 = waveform_ring_f2[0].next;
790 790 current_ring_node_f3 = waveform_ring_f3[0].next;
791 791
792 792 ring_node_to_send_swf_f0 = waveform_ring_f0;
793 793 ring_node_to_send_swf_f1 = waveform_ring_f1;
794 794 ring_node_to_send_swf_f2 = waveform_ring_f2;
795 795
796 796 ring_node_to_send_cwf_f1 = waveform_ring_f1;
797 797 ring_node_to_send_cwf_f2 = waveform_ring_f2;
798 798 ring_node_to_send_cwf_f3 = waveform_ring_f3;
799 799 }
800 800
801 801 int send_waveform_CWF3_light( ring_node *ring_node_to_send, ring_node *ring_node_cwf3_light, rtems_id queue_id )
802 802 {
803 803 /** This function sends CWF_F3 CCSDS packets without the b1, b2 and b3 data.
804 804 *
805 805 * @param waveform points to the buffer containing the data that will be send.
806 806 * @param headerCWF points to a table of headers that have been prepared for the data transmission.
807 807 * @param queue_id is the id of the rtems queue to which spw_ioctl_pkt_send structures will be send. The structures
808 808 * contain information to setup the transmission of the data packets.
809 809 *
810 810 * By default, CWF_F3 packet are send without the b1, b2 and b3 data. This function rebuilds a data buffer
811 811 * from the incoming data and sends it in 7 packets, 6 containing 340 blocks and 1 one containing 8 blocks.
812 812 *
813 813 */
814 814
815 815 unsigned int i;
816 816 int ret;
817 817 rtems_status_code status;
818 818
819 819 char *sample;
820 820 int *dataPtr;
821 821
822 822 ret = LFR_DEFAULT;
823 823
824 824 dataPtr = (int*) ring_node_to_send->buffer_address;
825 825
826 826 ring_node_cwf3_light->coarseTime = ring_node_to_send->coarseTime;
827 827 ring_node_cwf3_light->fineTime = ring_node_to_send->fineTime;
828 828
829 829 //**********************
830 830 // BUILD CWF3_light DATA
831 831 for ( i=0; i< NB_SAMPLES_PER_SNAPSHOT; i++)
832 832 {
833 833 sample = (char*) &dataPtr[ (i * NB_WORDS_SWF_BLK) ];
834 834 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) ] = sample[ 0 ];
835 835 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 1 ] = sample[ 1 ];
836 836 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 2 ] = sample[ 2 ];
837 837 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 3 ] = sample[ 3 ];
838 838 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 4 ] = sample[ 4 ];
839 839 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 5 ] = sample[ 5 ];
840 840 }
841 841
842 842 // SEND PACKET
843 843 status = rtems_message_queue_send( queue_id, &ring_node_cwf3_light, sizeof( ring_node* ) );
844 844 if (status != RTEMS_SUCCESSFUL) {
845 845 printf("%d-%d, ERR %d\n", SID_NORM_CWF_F3, i, (int) status);
846 846 ret = LFR_DEFAULT;
847 847 }
848 848
849 849 return ret;
850 850 }
851 851
852 852 void compute_acquisition_time( unsigned int coarseTime, unsigned int fineTime,
853 853 unsigned int sid, unsigned char pa_lfr_pkt_nr, unsigned char * acquisitionTime )
854 854 {
855 855 unsigned long long int acquisitionTimeAsLong;
856 856 unsigned char localAcquisitionTime[6];
857 857 double deltaT;
858 858
859 859 deltaT = 0.;
860 860
861 861 localAcquisitionTime[0] = (unsigned char) ( coarseTime >> 24 );
862 862 localAcquisitionTime[1] = (unsigned char) ( coarseTime >> 16 );
863 863 localAcquisitionTime[2] = (unsigned char) ( coarseTime >> 8 );
864 864 localAcquisitionTime[3] = (unsigned char) ( coarseTime );
865 865 localAcquisitionTime[4] = (unsigned char) ( fineTime >> 8 );
866 866 localAcquisitionTime[5] = (unsigned char) ( fineTime );
867 867
868 868 acquisitionTimeAsLong = ( (unsigned long long int) localAcquisitionTime[0] << 40 )
869 869 + ( (unsigned long long int) localAcquisitionTime[1] << 32 )
870 870 + ( (unsigned long long int) localAcquisitionTime[2] << 24 )
871 871 + ( (unsigned long long int) localAcquisitionTime[3] << 16 )
872 872 + ( (unsigned long long int) localAcquisitionTime[4] << 8 )
873 873 + ( (unsigned long long int) localAcquisitionTime[5] );
874 874
875 875 switch( sid )
876 876 {
877 877 case SID_NORM_SWF_F0:
878 878 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 24576. ;
879 879 break;
880 880
881 881 case SID_NORM_SWF_F1:
882 882 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 4096. ;
883 883 break;
884 884
885 885 case SID_NORM_SWF_F2:
886 886 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 256. ;
887 887 break;
888 888
889 889 case SID_SBM1_CWF_F1:
890 890 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 4096. ;
891 891 break;
892 892
893 893 case SID_SBM2_CWF_F2:
894 894 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 256. ;
895 895 break;
896 896
897 897 case SID_BURST_CWF_F2:
898 898 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 256. ;
899 899 break;
900 900
901 901 case SID_NORM_CWF_F3:
902 902 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF_SHORT_F3 * 65536. / 16. ;
903 903 break;
904 904
905 905 case SID_NORM_CWF_LONG_F3:
906 906 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 16. ;
907 907 break;
908 908
909 909 default:
910 910 PRINTF1("in compute_acquisition_time *** ERR unexpected sid %d\n", sid)
911 911 deltaT = 0.;
912 912 break;
913 913 }
914 914
915 915 acquisitionTimeAsLong = acquisitionTimeAsLong + (unsigned long long int) deltaT;
916 916 //
917 917 acquisitionTime[0] = (unsigned char) (acquisitionTimeAsLong >> 40);
918 918 acquisitionTime[1] = (unsigned char) (acquisitionTimeAsLong >> 32);
919 919 acquisitionTime[2] = (unsigned char) (acquisitionTimeAsLong >> 24);
920 920 acquisitionTime[3] = (unsigned char) (acquisitionTimeAsLong >> 16);
921 921 acquisitionTime[4] = (unsigned char) (acquisitionTimeAsLong >> 8 );
922 922 acquisitionTime[5] = (unsigned char) (acquisitionTimeAsLong );
923 923
924 924 }
925 925
926 926 void build_snapshot_from_ring( ring_node *ring_node_to_send, unsigned char frequencyChannel, unsigned long long int acquisitionTimeF0_asLong )
927 927 {
928 928 unsigned int i;
929 929 unsigned long long int centerTime_asLong;
930 930 unsigned long long int acquisitionTime_asLong;
931 931 unsigned long long int bufferAcquisitionTime_asLong;
932 932 unsigned char *ptr1;
933 933 unsigned char *ptr2;
934 934 unsigned char *timeCharPtr;
935 935 unsigned char nb_ring_nodes;
936 936 unsigned long long int frequency_asLong;
937 937 unsigned long long int nbTicksPerSample_asLong;
938 938 unsigned long long int nbSamplesPart1_asLong;
939 939 unsigned long long int sampleOffset_asLong;
940 940
941 941 unsigned int deltaT_F0;
942 942 unsigned int deltaT_F1;
943 943 unsigned long long int deltaT_F2;
944 944
945 945 deltaT_F0 = 2731; // (2048. / 24576. / 2.) * 65536. = 2730.667;
946 946 deltaT_F1 = 16384; // (2048. / 4096. / 2.) * 65536. = 16384;
947 947 deltaT_F2 = 262144; // (2048. / 256. / 2.) * 65536. = 262144;
948 948 sampleOffset_asLong = 0x00;
949 949
950 950 // (1) get the f0 acquisition time => the value is passed in argument
951 951
952 952 // (2) compute the central reference time
953 953 centerTime_asLong = acquisitionTimeF0_asLong + deltaT_F0;
954 954
955 955 // (3) compute the acquisition time of the current snapshot
956 956 switch(frequencyChannel)
957 957 {
958 958 case 1: // 1 is for F1 = 4096 Hz
959 959 acquisitionTime_asLong = centerTime_asLong - deltaT_F1;
960 960 nb_ring_nodes = NB_RING_NODES_F1;
961 961 frequency_asLong = 4096;
962 962 nbTicksPerSample_asLong = 16; // 65536 / 4096;
963 963 break;
964 964 case 2: // 2 is for F2 = 256 Hz
965 965 acquisitionTime_asLong = centerTime_asLong - deltaT_F2;
966 966 nb_ring_nodes = NB_RING_NODES_F2;
967 967 frequency_asLong = 256;
968 968 nbTicksPerSample_asLong = 256; // 65536 / 256;
969 969 break;
970 970 default:
971 971 acquisitionTime_asLong = centerTime_asLong;
972 972 frequency_asLong = 256;
973 973 nbTicksPerSample_asLong = 256;
974 974 break;
975 975 }
976 976
977 977 //****************************************************************************
978 978 // (4) search the ring_node with the acquisition time <= acquisitionTime_asLong
979 979 for (i=0; i<nb_ring_nodes; i++)
980 980 {
981 981 PRINTF1("%d ... ", i)
982 982 bufferAcquisitionTime_asLong = get_acquisition_time( (unsigned char *) &ring_node_to_send->coarseTime );
983 983 if (bufferAcquisitionTime_asLong <= acquisitionTime_asLong)
984 984 {
985 985 PRINTF1("buffer found with acquisition time = %llx\n", bufferAcquisitionTime_asLong)
986 986 break;
987 987 }
988 988 ring_node_to_send = ring_node_to_send->previous;
989 989 }
990 990
991 991 // (5) compute the number of samples to take in the current buffer
992 992 sampleOffset_asLong = ((acquisitionTime_asLong - bufferAcquisitionTime_asLong) * frequency_asLong ) >> 16;
993 993 nbSamplesPart1_asLong = NB_SAMPLES_PER_SNAPSHOT - sampleOffset_asLong;
994 994 PRINTF2("sampleOffset_asLong = %lld, nbSamplesPart1_asLong = %lld\n", sampleOffset_asLong, nbSamplesPart1_asLong)
995 995
996 996 // (6) compute the final acquisition time
997 997 acquisitionTime_asLong = bufferAcquisitionTime_asLong +
998 998 sampleOffset_asLong * nbTicksPerSample_asLong;
999 999
1000 1000 // (7) copy the acquisition time at the beginning of the extrated snapshot
1001 1001 ptr1 = (unsigned char*) &acquisitionTime_asLong;
1002 1002 // fine time
1003 1003 ptr2 = (unsigned char*) &ring_node_wf_snap_extracted.fineTime;
1004 1004 ptr2[2] = ptr1[ 4 + 2 ];
1005 1005 ptr2[3] = ptr1[ 5 + 2 ];
1006 1006 // coarse time
1007 1007 ptr2 = (unsigned char*) &ring_node_wf_snap_extracted.coarseTime;
1008 1008 ptr2[0] = ptr1[ 0 + 2 ];
1009 1009 ptr2[1] = ptr1[ 1 + 2 ];
1010 1010 ptr2[2] = ptr1[ 2 + 2 ];
1011 1011 ptr2[3] = ptr1[ 3 + 2 ];
1012 1012
1013 1013 // re set the synchronization bit
1014 1014 timeCharPtr = (unsigned char*) &ring_node_to_send->coarseTime;
1015 1015 ptr2[0] = ptr2[0] | (timeCharPtr[0] & 0x80); // [1000 0000]
1016 1016
1017 1017 if ( (nbSamplesPart1_asLong >= NB_SAMPLES_PER_SNAPSHOT) | (nbSamplesPart1_asLong < 0) )
1018 1018 {
1019 1019 nbSamplesPart1_asLong = 0;
1020 1020 }
1021 1021 // copy the part 1 of the snapshot in the extracted buffer
1022 1022 for ( i = 0; i < (nbSamplesPart1_asLong * NB_WORDS_SWF_BLK); i++ )
1023 1023 {
1024 1024 wf_snap_extracted[i] =
1025 1025 ((int*) ring_node_to_send->buffer_address)[ i + (sampleOffset_asLong * NB_WORDS_SWF_BLK) ];
1026 1026 }
1027 1027 // copy the part 2 of the snapshot in the extracted buffer
1028 1028 ring_node_to_send = ring_node_to_send->next;
1029 1029 for ( i = (nbSamplesPart1_asLong * NB_WORDS_SWF_BLK); i < (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK); i++ )
1030 1030 {
1031 1031 wf_snap_extracted[i] =
1032 1032 ((int*) ring_node_to_send->buffer_address)[ (i-(nbSamplesPart1_asLong * NB_WORDS_SWF_BLK)) ];
1033 1033 }
1034 1034 }
1035 1035
1036 1036 void snapshot_resynchronization( unsigned char *timePtr )
1037 1037 {
1038 1038 unsigned long long int acquisitionTime;
1039 1039 unsigned long long int centerTime;
1040 1040 unsigned long long int previousTick;
1041 1041 unsigned long long int nextTick;
1042 1042 unsigned long long int deltaPreviousTick;
1043 1043 unsigned long long int deltaNextTick;
1044 1044 unsigned int deltaTickInF2;
1045 1045 double deltaPrevious;
1046 1046 double deltaNext;
1047 1047
1048 1048 acquisitionTime = get_acquisition_time( timePtr );
1049 1049
1050 1050 // compute center time
1051 1051 centerTime = acquisitionTime + 2731; // (2048. / 24576. / 2.) * 65536. = 2730.667;
1052 1052 previousTick = centerTime - (centerTime & 0xffff);
1053 1053 nextTick = previousTick + 65536;
1054 1054
1055 1055 deltaPreviousTick = centerTime - previousTick;
1056 1056 deltaNextTick = nextTick - centerTime;
1057 1057
1058 1058 deltaPrevious = ((double) deltaPreviousTick) / 65536. * 1000.;
1059 1059 deltaNext = ((double) deltaNextTick) / 65536. * 1000.;
1060 1060
1061 1061 PRINTF2("delta previous = %f ms, delta next = %f ms\n", deltaPrevious, deltaNext)
1062 1062 PRINTF2("delta previous = %llu, delta next = %llu\n", deltaPreviousTick, deltaNextTick)
1063 1063
1064 1064 // which tick is the closest
1065 1065 if (deltaPreviousTick > deltaNextTick)
1066 1066 {
1067 1067 deltaTickInF2 = floor( (deltaNext * 256. / 1000.) ); // the division by 2 is important here
1068 1068 waveform_picker_regs->delta_snapshot = waveform_picker_regs->delta_snapshot + deltaTickInF2;
1069 1069 printf("correction of = + %u\n", deltaTickInF2);
1070 1070 }
1071 1071 else
1072 1072 {
1073 1073 deltaTickInF2 = floor( (deltaPrevious * 256. / 1000.) ); // the division by 2 is important here
1074 1074 waveform_picker_regs->delta_snapshot = waveform_picker_regs->delta_snapshot - deltaTickInF2;
1075 1075 printf("correction of = - %u\n", deltaTickInF2);
1076 1076 }
1077 1077 }
1078 1078
1079 1079 //**************
1080 1080 // wfp registers
1081 1081 void reset_wfp_burst_enable( void )
1082 1082 {
1083 1083 /** This function resets the waveform picker burst_enable register.
1084 1084 *
1085 1085 * The burst bits [f2 f1 f0] and the enable bits [f3 f2 f1 f0] are set to 0.
1086 1086 *
1087 1087 */
1088 1088
1089 1089 // [1000 000] burst f2, f1, f0 enable f3, f2, f1, f0
1090 1090 waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable & 0x80;
1091 1091 }
1092 1092
1093 1093 void reset_wfp_status( void )
1094 1094 {
1095 1095 /** This function resets the waveform picker status register.
1096 1096 *
1097 1097 * All status bits are set to 0 [new_err full_err full].
1098 1098 *
1099 1099 */
1100 1100
1101 1101 waveform_picker_regs->status = 0xffff;
1102 1102 }
1103 1103
1104 1104 void reset_wfp_buffer_addresses( void )
1105 1105 {
1106 1106 // F0
1107 1107 waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->previous->buffer_address; // 0x08
1108 1108 waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address; // 0x0c
1109 1109 // F1
1110 1110 waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->previous->buffer_address; // 0x10
1111 1111 waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address; // 0x14
1112 1112 // F2
1113 1113 waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->previous->buffer_address; // 0x18
1114 1114 waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address; // 0x1c
1115 1115 // F3
1116 1116 waveform_picker_regs->addr_data_f3_0 = current_ring_node_f3->previous->buffer_address; // 0x20
1117 1117 waveform_picker_regs->addr_data_f3_1 = current_ring_node_f3->buffer_address; // 0x24
1118 1118 }
1119 1119
1120 1120 void reset_waveform_picker_regs( void )
1121 1121 {
1122 1122 /** This function resets the waveform picker module registers.
1123 1123 *
1124 1124 * The registers affected by this function are located at the following offset addresses:
1125 1125 * - 0x00 data_shaping
1126 1126 * - 0x04 run_burst_enable
1127 1127 * - 0x08 addr_data_f0
1128 1128 * - 0x0C addr_data_f1
1129 1129 * - 0x10 addr_data_f2
1130 1130 * - 0x14 addr_data_f3
1131 1131 * - 0x18 status
1132 1132 * - 0x1C delta_snapshot
1133 1133 * - 0x20 delta_f0
1134 1134 * - 0x24 delta_f0_2
1135 1135 * - 0x28 delta_f1
1136 1136 * - 0x2c delta_f2
1137 1137 * - 0x30 nb_data_by_buffer
1138 1138 * - 0x34 nb_snapshot_param
1139 1139 * - 0x38 start_date
1140 1140 * - 0x3c nb_word_in_buffer
1141 1141 *
1142 1142 */
1143 1143
1144 1144 set_wfp_data_shaping(); // 0x00 *** R1 R0 SP1 SP0 BW
1145 1145
1146 1146 reset_wfp_burst_enable(); // 0x04 *** [run *** burst f2, f1, f0 *** enable f3, f2, f1, f0 ]
1147 1147
1148 1148 reset_wfp_buffer_addresses();
1149 1149
1150 1150 reset_wfp_status(); // 0x18
1151 1151
1152 1152 set_wfp_delta_snapshot(); // 0x1c *** 300 s => 0x12bff
1153 1153
1154 1154 set_wfp_delta_f0_f0_2(); // 0x20, 0x24
1155 1155
1156 1156 set_wfp_delta_f1(); // 0x28
1157 1157
1158 1158 set_wfp_delta_f2(); // 0x2c
1159 1159
1160 1160 DEBUG_PRINTF1("delta_snapshot %x\n", waveform_picker_regs->delta_snapshot)
1161 1161 DEBUG_PRINTF1("delta_f0 %x\n", waveform_picker_regs->delta_f0)
1162 1162 DEBUG_PRINTF1("delta_f0_2 %x\n", waveform_picker_regs->delta_f0_2)
1163 1163 DEBUG_PRINTF1("delta_f1 %x\n", waveform_picker_regs->delta_f1)
1164 1164 DEBUG_PRINTF1("delta_f2 %x\n", waveform_picker_regs->delta_f2)
1165 1165 // 2688 = 8 * 336
1166 1166 waveform_picker_regs->nb_data_by_buffer = 0xa7f; // 0x30 *** 2688 - 1 => nb samples -1
1167 1167 waveform_picker_regs->snapshot_param = 0xa80; // 0x34 *** 2688 => nb samples
1168 1168 waveform_picker_regs->start_date = 0x7fffffff; // 0x38
1169 1169 //
1170 1170 // coarse time and fine time registers are not initialized, they are volatile
1171 1171 //
1172 1172 waveform_picker_regs->buffer_length = 0x1f8;// buffer length in burst = 3 * 2688 / 16 = 504 = 0x1f8
1173 1173 }
1174 1174
1175 1175 void set_wfp_data_shaping( void )
1176 1176 {
1177 1177 /** This function sets the data_shaping register of the waveform picker module.
1178 1178 *
1179 1179 * The value is read from one field of the parameter_dump_packet structure:\n
1180 1180 * bw_sp0_sp1_r0_r1
1181 1181 *
1182 1182 */
1183 1183
1184 1184 unsigned char data_shaping;
1185 1185
1186 1186 // get the parameters for the data shaping [BW SP0 SP1 R0 R1] in sy_lfr_common1 and configure the register
1187 1187 // waveform picker : [R1 R0 SP1 SP0 BW]
1188 1188
1189 1189 data_shaping = parameter_dump_packet.sy_lfr_common_parameters;
1190 1190
1191 1191 waveform_picker_regs->data_shaping =
1192 1192 ( (data_shaping & 0x20) >> 5 ) // BW
1193 1193 + ( (data_shaping & 0x10) >> 3 ) // SP0
1194 1194 + ( (data_shaping & 0x08) >> 1 ) // SP1
1195 + ( (data_shaping & 0x04) ) // R0
1195 + ( (data_shaping & 0x04) << 1 ) // R0
1196 1196 + ( (data_shaping & 0x02) << 3 ) // R1
1197 1197 + ( (data_shaping & 0x01) << 5 ); // R2
1198 1198 }
1199 1199
1200 1200 void set_wfp_burst_enable_register( unsigned char mode )
1201 1201 {
1202 1202 /** This function sets the waveform picker burst_enable register depending on the mode.
1203 1203 *
1204 1204 * @param mode is the LFR mode to launch.
1205 1205 *
1206 1206 * The burst bits shall be before the enable bits.
1207 1207 *
1208 1208 */
1209 1209
1210 1210 // [0000 0000] burst f2, f1, f0 enable f3 f2 f1 f0
1211 1211 // the burst bits shall be set first, before the enable bits
1212 1212 switch(mode) {
1213 1213 case(LFR_MODE_NORMAL):
1214 1214 waveform_picker_regs->run_burst_enable = 0x00; // [0000 0000] no burst enable
1215 1215 waveform_picker_regs->run_burst_enable = 0x0f; // [0000 1111] enable f3 f2 f1 f0
1216 1216 break;
1217 1217 case(LFR_MODE_BURST):
1218 1218 waveform_picker_regs->run_burst_enable = 0x40; // [0100 0000] f2 burst enabled
1219 1219 // waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x04; // [0100] enable f2
1220 1220 waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x0c; // [1100] enable f3 AND f2
1221 1221 break;
1222 1222 case(LFR_MODE_SBM1):
1223 1223 waveform_picker_regs->run_burst_enable = 0x20; // [0010 0000] f1 burst enabled
1224 1224 waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x0f; // [1111] enable f3 f2 f1 f0
1225 1225 break;
1226 1226 case(LFR_MODE_SBM2):
1227 1227 waveform_picker_regs->run_burst_enable = 0x40; // [0100 0000] f2 burst enabled
1228 1228 waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x0f; // [1111] enable f3 f2 f1 f0
1229 1229 break;
1230 1230 default:
1231 1231 waveform_picker_regs->run_burst_enable = 0x00; // [0000 0000] no burst enabled, no waveform enabled
1232 1232 break;
1233 1233 }
1234 1234 }
1235 1235
1236 1236 void set_wfp_delta_snapshot( void )
1237 1237 {
1238 1238 /** This function sets the delta_snapshot register of the waveform picker module.
1239 1239 *
1240 1240 * The value is read from two (unsigned char) of the parameter_dump_packet structure:
1241 1241 * - sy_lfr_n_swf_p[0]
1242 1242 * - sy_lfr_n_swf_p[1]
1243 1243 *
1244 1244 */
1245 1245
1246 1246 unsigned int delta_snapshot;
1247 1247 unsigned int delta_snapshot_in_T2;
1248 1248
1249 1249 delta_snapshot = parameter_dump_packet.sy_lfr_n_swf_p[0]*256
1250 1250 + parameter_dump_packet.sy_lfr_n_swf_p[1];
1251 1251
1252 1252 delta_snapshot_in_T2 = delta_snapshot * 256;
1253 1253 waveform_picker_regs->delta_snapshot = delta_snapshot_in_T2 - 1; // max 4 bytes
1254 1254 }
1255 1255
1256 1256 void set_wfp_delta_f0_f0_2( void )
1257 1257 {
1258 1258 unsigned int delta_snapshot;
1259 1259 unsigned int nb_samples_per_snapshot;
1260 1260 float delta_f0_in_float;
1261 1261
1262 1262 delta_snapshot = waveform_picker_regs->delta_snapshot;
1263 1263 nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];
1264 1264 delta_f0_in_float =nb_samples_per_snapshot / 2. * ( 1. / 256. - 1. / 24576.) * 256.;
1265 1265
1266 1266 waveform_picker_regs->delta_f0 = delta_snapshot - floor( delta_f0_in_float );
1267 1267 waveform_picker_regs->delta_f0_2 = 0x30; // 48 = 11 0000, max 7 bits
1268 1268 }
1269 1269
1270 1270 void set_wfp_delta_f1( void )
1271 1271 {
1272 1272 unsigned int delta_snapshot;
1273 1273 unsigned int nb_samples_per_snapshot;
1274 1274 float delta_f1_in_float;
1275 1275
1276 1276 delta_snapshot = waveform_picker_regs->delta_snapshot;
1277 1277 nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];
1278 1278 delta_f1_in_float = nb_samples_per_snapshot / 2. * ( 1. / 256. - 1. / 4096.) * 256.;
1279 1279
1280 1280 waveform_picker_regs->delta_f1 = delta_snapshot - floor( delta_f1_in_float );
1281 1281 }
1282 1282
1283 1283 void set_wfp_delta_f2()
1284 1284 {
1285 1285 unsigned int delta_snapshot;
1286 1286 unsigned int nb_samples_per_snapshot;
1287 1287
1288 1288 delta_snapshot = waveform_picker_regs->delta_snapshot;
1289 1289 nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];
1290 1290
1291 1291 waveform_picker_regs->delta_f2 = delta_snapshot - nb_samples_per_snapshot / 2;
1292 1292 }
1293 1293
1294 1294 //*****************
1295 1295 // local parameters
1296 1296
1297 1297 void increment_seq_counter_source_id( unsigned char *packet_sequence_control, unsigned int sid )
1298 1298 {
1299 1299 /** This function increments the parameter "sequence_cnt" depending on the sid passed in argument.
1300 1300 *
1301 1301 * @param packet_sequence_control is a pointer toward the parameter sequence_cnt to update.
1302 1302 * @param sid is the source identifier of the packet being updated.
1303 1303 *
1304 1304 * REQ-LFR-SRS-5240 / SSS-CP-FS-590
1305 1305 * The sequence counters shall wrap around from 2^14 to zero.
1306 1306 * The sequence counter shall start at zero at startup.
1307 1307 *
1308 1308 * REQ-LFR-SRS-5239 / SSS-CP-FS-580
1309 1309 * All TM_LFR_SCIENCE_ packets are sent to ground, i.e. destination id = 0
1310 1310 *
1311 1311 */
1312 1312
1313 1313 unsigned short *sequence_cnt;
1314 1314 unsigned short segmentation_grouping_flag;
1315 1315 unsigned short new_packet_sequence_control;
1316 1316 rtems_mode initial_mode_set;
1317 1317 rtems_mode current_mode_set;
1318 1318 rtems_status_code status;
1319 1319
1320 1320 //******************************************
1321 1321 // CHANGE THE MODE OF THE CALLING RTEMS TASK
1322 1322 status = rtems_task_mode( RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &initial_mode_set );
1323 1323
1324 1324 if ( (sid == SID_NORM_SWF_F0) || (sid == SID_NORM_SWF_F1) || (sid == SID_NORM_SWF_F2)
1325 1325 || (sid == SID_NORM_CWF_F3) || (sid == SID_NORM_CWF_LONG_F3)
1326 1326 || (sid == SID_BURST_CWF_F2)
1327 1327 || (sid == SID_NORM_ASM_F0) || (sid == SID_NORM_ASM_F1) || (sid == SID_NORM_ASM_F2)
1328 1328 || (sid == SID_NORM_BP1_F0) || (sid == SID_NORM_BP1_F1) || (sid == SID_NORM_BP1_F2)
1329 1329 || (sid == SID_NORM_BP2_F0) || (sid == SID_NORM_BP2_F1) || (sid == SID_NORM_BP2_F2)
1330 1330 || (sid == SID_BURST_BP1_F0) || (sid == SID_BURST_BP2_F0)
1331 1331 || (sid == SID_BURST_BP1_F1) || (sid == SID_BURST_BP2_F1) )
1332 1332 {
1333 1333 sequence_cnt = (unsigned short *) &sequenceCounters_SCIENCE_NORMAL_BURST;
1334 1334 }
1335 1335 else if ( (sid ==SID_SBM1_CWF_F1) || (sid ==SID_SBM2_CWF_F2)
1336 1336 || (sid == SID_SBM1_BP1_F0) || (sid == SID_SBM1_BP2_F0)
1337 1337 || (sid == SID_SBM2_BP1_F0) || (sid == SID_SBM2_BP2_F0)
1338 1338 || (sid == SID_SBM2_BP1_F1) || (sid == SID_SBM2_BP2_F1) )
1339 1339 {
1340 1340 sequence_cnt = (unsigned short *) &sequenceCounters_SCIENCE_SBM1_SBM2;
1341 1341 }
1342 1342 else
1343 1343 {
1344 1344 sequence_cnt = (unsigned short *) NULL;
1345 1345 PRINTF1("in increment_seq_counter_source_id *** ERR apid_destid %d not known\n", sid)
1346 1346 }
1347 1347
1348 1348 if (sequence_cnt != NULL)
1349 1349 {
1350 1350 segmentation_grouping_flag = TM_PACKET_SEQ_CTRL_STANDALONE << 8;
1351 1351 *sequence_cnt = (*sequence_cnt) & 0x3fff;
1352 1352
1353 1353 new_packet_sequence_control = segmentation_grouping_flag | (*sequence_cnt) ;
1354 1354
1355 1355 packet_sequence_control[0] = (unsigned char) (new_packet_sequence_control >> 8);
1356 1356 packet_sequence_control[1] = (unsigned char) (new_packet_sequence_control );
1357 1357
1358 1358 // increment the sequence counter
1359 1359 if ( *sequence_cnt < SEQ_CNT_MAX)
1360 1360 {
1361 1361 *sequence_cnt = *sequence_cnt + 1;
1362 1362 }
1363 1363 else
1364 1364 {
1365 1365 *sequence_cnt = 0;
1366 1366 }
1367 1367 }
1368 1368
1369 1369 //***********************************
1370 1370 // RESET THE MODE OF THE CALLING TASK
1371 1371 status = rtems_task_mode( initial_mode_set, RTEMS_PREEMPT_MASK, &current_mode_set );
1372 1372 }
General Comments 0
You need to be logged in to leave comments. Login now