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