##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » SOLO_LFR » DEV_PLE
RSS

Clone from http://pc-instru.lpp.polytechnique.fr:5000/DEV_PLE

sync with LFR_basic-parameters
paul -
r180:3fe0b645620c VHDL_0_1_28
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,2 +1,2
1 a309a930a482e851061936696121f4a1cf7005de LFR_basic-parameters
1 d896e23033404156cdc95f5bf66e038de84de04b LFR_basic-parameters
2 2b5dc338fb623046072d6eb98c26ad884e17f95e header/lfr_common_headers
2 5cfb4f574403f86583ac510d5921709548a9c902 header/lfr_common_headers
Show file before | Show file after | Hide comments
@@ -1,111 +1,111
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 cpu_usage_report
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=2 # major
12 DEFINES += SW_VERSION_N1=2 # major
13 DEFINES += SW_VERSION_N2=0 # minor
13 DEFINES += SW_VERSION_N2=0 # minor
14 DEFINES += SW_VERSION_N3=2 # patch
14 DEFINES += SW_VERSION_N3=2 # patch
15 DEFINES += SW_VERSION_N4=1 # internal
15 DEFINES += SW_VERSION_N4=1 # 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 += LSB_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
111
Show file before | Show file after | Hide comments
@@ -1,498 +1,391
1 /** Functions related to data processing.
1 /** Functions related to data processing.
2 *
2 *
3 * @file
3 * @file
4 * @author P. LEROY
4 * @author P. LEROY
5 *
5 *
6 * These function are related to data processing, i.e. spectral matrices averaging and basic parameters computation.
6 * These function are related to data processing, i.e. spectral matrices averaging and basic parameters computation.
7 *
7 *
8 */
8 */
9
9
10 #include "avf0_prc0.h"
10 #include "avf0_prc0.h"
11 #include "fsw_processing.h"
11 #include "fsw_processing.h"
12
12
13 nb_sm_before_bp_asm_f0 nb_sm_before_f0;
13 nb_sm_before_bp_asm_f0 nb_sm_before_f0;
14
14
15 //***
15 //***
16 // F0
16 // F0
17 ring_node_asm asm_ring_norm_f0 [ NB_RING_NODES_ASM_NORM_F0 ];
17 ring_node_asm asm_ring_norm_f0 [ NB_RING_NODES_ASM_NORM_F0 ];
18 ring_node_asm asm_ring_burst_sbm_f0 [ NB_RING_NODES_ASM_BURST_SBM_F0 ];
18 ring_node_asm asm_ring_burst_sbm_f0 [ NB_RING_NODES_ASM_BURST_SBM_F0 ];
19
19
20 ring_node ring_to_send_asm_f0 [ NB_RING_NODES_ASM_F0 ];
20 ring_node ring_to_send_asm_f0 [ NB_RING_NODES_ASM_F0 ];
21 int buffer_asm_f0 [ NB_RING_NODES_ASM_F0 * TOTAL_SIZE_SM ];
21 int buffer_asm_f0 [ NB_RING_NODES_ASM_F0 * TOTAL_SIZE_SM ];
22
22
23 float asm_f0_reorganized [ TOTAL_SIZE_SM ];
23 float asm_f0_reorganized [ TOTAL_SIZE_SM ];
24 char asm_f0_char [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ];
24 char asm_f0_char [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ];
25 float compressed_sm_norm_f0[ TOTAL_SIZE_COMPRESSED_ASM_NORM_F0];
25 float compressed_sm_norm_f0[ TOTAL_SIZE_COMPRESSED_ASM_NORM_F0];
26 float compressed_sm_sbm_f0 [ TOTAL_SIZE_COMPRESSED_ASM_SBM_F0 ];
26 float compressed_sm_sbm_f0 [ TOTAL_SIZE_COMPRESSED_ASM_SBM_F0 ];
27
27
28 float k_coeff_intercalib_f0_norm[ NB_BINS_COMPRESSED_SM_F0 * NB_K_COEFF_PER_BIN ]; // 11 * 32 = 352
28 float k_coeff_intercalib_f0_norm[ NB_BINS_COMPRESSED_SM_F0 * NB_K_COEFF_PER_BIN ]; // 11 * 32 = 352
29 float k_coeff_intercalib_f0_sbm[ NB_BINS_COMPRESSED_SM_SBM_F0 * NB_K_COEFF_PER_BIN ]; // 22 * 32 = 704
29 float k_coeff_intercalib_f0_sbm[ NB_BINS_COMPRESSED_SM_SBM_F0 * NB_K_COEFF_PER_BIN ]; // 22 * 32 = 704
30
30
31 //************
31 //************
32 // RTEMS TASKS
32 // RTEMS TASKS
33
33
34 rtems_task avf0_task( rtems_task_argument lfrRequestedMode )
34 rtems_task avf0_task( rtems_task_argument lfrRequestedMode )
35 {
35 {
36 int i;
36 int i;
37
37
38 rtems_event_set event_out;
38 rtems_event_set event_out;
39 rtems_status_code status;
39 rtems_status_code status;
40 rtems_id queue_id_prc0;
40 rtems_id queue_id_prc0;
41 asm_msg msgForMATR;
41 asm_msg msgForMATR;
42 ring_node *nodeForAveraging;
42 ring_node *nodeForAveraging;
43 ring_node *ring_node_tab[8];
43 ring_node *ring_node_tab[8];
44 ring_node_asm *current_ring_node_asm_burst_sbm_f0;
44 ring_node_asm *current_ring_node_asm_burst_sbm_f0;
45 ring_node_asm *current_ring_node_asm_norm_f0;
45 ring_node_asm *current_ring_node_asm_norm_f0;
46
46
47 unsigned int nb_norm_bp1;
47 unsigned int nb_norm_bp1;
48 unsigned int nb_norm_bp2;
48 unsigned int nb_norm_bp2;
49 unsigned int nb_norm_asm;
49 unsigned int nb_norm_asm;
50 unsigned int nb_sbm_bp1;
50 unsigned int nb_sbm_bp1;
51 unsigned int nb_sbm_bp2;
51 unsigned int nb_sbm_bp2;
52
52
53 nb_norm_bp1 = 0;
53 nb_norm_bp1 = 0;
54 nb_norm_bp2 = 0;
54 nb_norm_bp2 = 0;
55 nb_norm_asm = 0;
55 nb_norm_asm = 0;
56 nb_sbm_bp1 = 0;
56 nb_sbm_bp1 = 0;
57 nb_sbm_bp2 = 0;
57 nb_sbm_bp2 = 0;
58
58
59 reset_nb_sm_f0( lfrRequestedMode ); // reset the sm counters that drive the BP and ASM computations / transmissions
59 reset_nb_sm_f0( lfrRequestedMode ); // reset the sm counters that drive the BP and ASM computations / transmissions
60 ASM_generic_init_ring( asm_ring_norm_f0, NB_RING_NODES_ASM_NORM_F0 );
60 ASM_generic_init_ring( asm_ring_norm_f0, NB_RING_NODES_ASM_NORM_F0 );
61 ASM_generic_init_ring( asm_ring_burst_sbm_f0, NB_RING_NODES_ASM_BURST_SBM_F0 );
61 ASM_generic_init_ring( asm_ring_burst_sbm_f0, NB_RING_NODES_ASM_BURST_SBM_F0 );
62 current_ring_node_asm_norm_f0 = asm_ring_norm_f0;
62 current_ring_node_asm_norm_f0 = asm_ring_norm_f0;
63 current_ring_node_asm_burst_sbm_f0 = asm_ring_burst_sbm_f0;
63 current_ring_node_asm_burst_sbm_f0 = asm_ring_burst_sbm_f0;
64
64
65 BOOT_PRINTF1("in AVFO *** lfrRequestedMode = %d\n", (int) lfrRequestedMode)
65 BOOT_PRINTF1("in AVFO *** lfrRequestedMode = %d\n", (int) lfrRequestedMode)
66
66
67 status = get_message_queue_id_prc0( &queue_id_prc0 );
67 status = get_message_queue_id_prc0( &queue_id_prc0 );
68 if (status != RTEMS_SUCCESSFUL)
68 if (status != RTEMS_SUCCESSFUL)
69 {
69 {
70 PRINTF1("in MATR *** ERR get_message_queue_id_prc0 %d\n", status)
70 PRINTF1("in MATR *** ERR get_message_queue_id_prc0 %d\n", status)
71 }
71 }
72
72
73 while(1){
73 while(1){
74 rtems_event_receive(RTEMS_EVENT_0, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT0
74 rtems_event_receive(RTEMS_EVENT_0, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT0
75
75
76 //****************************************
76 //****************************************
77 // initialize the mesage for the MATR task
77 // initialize the mesage for the MATR task
78 msgForMATR.norm = current_ring_node_asm_norm_f0;
78 msgForMATR.norm = current_ring_node_asm_norm_f0;
79 msgForMATR.burst_sbm = current_ring_node_asm_burst_sbm_f0;
79 msgForMATR.burst_sbm = current_ring_node_asm_burst_sbm_f0;
80 msgForMATR.event = 0x00; // this composite event will be sent to the PRC0 task
80 msgForMATR.event = 0x00; // this composite event will be sent to the PRC0 task
81 //
81 //
82 //****************************************
82 //****************************************
83
83
84 nodeForAveraging = getRingNodeForAveraging( 0 );
84 nodeForAveraging = getRingNodeForAveraging( 0 );
85
85
86 ring_node_tab[NB_SM_BEFORE_AVF0-1] = nodeForAveraging;
86 ring_node_tab[NB_SM_BEFORE_AVF0-1] = nodeForAveraging;
87 for ( i = 2; i < (NB_SM_BEFORE_AVF0+1); i++ )
87 for ( i = 2; i < (NB_SM_BEFORE_AVF0+1); i++ )
88 {
88 {
89 nodeForAveraging = nodeForAveraging->previous;
89 nodeForAveraging = nodeForAveraging->previous;
90 ring_node_tab[NB_SM_BEFORE_AVF0-i] = nodeForAveraging;
90 ring_node_tab[NB_SM_BEFORE_AVF0-i] = nodeForAveraging;
91 }
91 }
92
92
93 // compute the average and store it in the averaged_sm_f1 buffer
93 // compute the average and store it in the averaged_sm_f1 buffer
94 SM_average( current_ring_node_asm_norm_f0->matrix,
94 SM_average( current_ring_node_asm_norm_f0->matrix,
95 current_ring_node_asm_burst_sbm_f0->matrix,
95 current_ring_node_asm_burst_sbm_f0->matrix,
96 ring_node_tab,
96 ring_node_tab,
97 nb_norm_bp1, nb_sbm_bp1,
97 nb_norm_bp1, nb_sbm_bp1,
98 &msgForMATR );
98 &msgForMATR );
99
99
100 // update nb_average
100 // update nb_average
101 nb_norm_bp1 = nb_norm_bp1 + NB_SM_BEFORE_AVF0;
101 nb_norm_bp1 = nb_norm_bp1 + NB_SM_BEFORE_AVF0;
102 nb_norm_bp2 = nb_norm_bp2 + NB_SM_BEFORE_AVF0;
102 nb_norm_bp2 = nb_norm_bp2 + NB_SM_BEFORE_AVF0;
103 nb_norm_asm = nb_norm_asm + NB_SM_BEFORE_AVF0;
103 nb_norm_asm = nb_norm_asm + NB_SM_BEFORE_AVF0;
104 nb_sbm_bp1 = nb_sbm_bp1 + NB_SM_BEFORE_AVF0;
104 nb_sbm_bp1 = nb_sbm_bp1 + NB_SM_BEFORE_AVF0;
105 nb_sbm_bp2 = nb_sbm_bp2 + NB_SM_BEFORE_AVF0;
105 nb_sbm_bp2 = nb_sbm_bp2 + NB_SM_BEFORE_AVF0;
106
106
107 if (nb_sbm_bp1 == nb_sm_before_f0.burst_sbm_bp1)
107 if (nb_sbm_bp1 == nb_sm_before_f0.burst_sbm_bp1)
108 {
108 {
109 nb_sbm_bp1 = 0;
109 nb_sbm_bp1 = 0;
110 // set another ring for the ASM storage
110 // set another ring for the ASM storage
111 current_ring_node_asm_burst_sbm_f0 = current_ring_node_asm_burst_sbm_f0->next;
111 current_ring_node_asm_burst_sbm_f0 = current_ring_node_asm_burst_sbm_f0->next;
112 if ( lfrCurrentMode == LFR_MODE_BURST )
112 if ( lfrCurrentMode == LFR_MODE_BURST )
113 {
113 {
114 msgForMATR.event = msgForMATR.event | RTEMS_EVENT_BURST_BP1_F0;
114 msgForMATR.event = msgForMATR.event | RTEMS_EVENT_BURST_BP1_F0;
115 }
115 }
116 else if ( (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )
116 else if ( (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )
117 {
117 {
118 msgForMATR.event = msgForMATR.event | RTEMS_EVENT_SBM_BP1_F0;
118 msgForMATR.event = msgForMATR.event | RTEMS_EVENT_SBM_BP1_F0;
119 }
119 }
120 }
120 }
121
121
122 if (nb_sbm_bp2 == nb_sm_before_f0.burst_sbm_bp2)
122 if (nb_sbm_bp2 == nb_sm_before_f0.burst_sbm_bp2)
123 {
123 {
124 nb_sbm_bp2 = 0;
124 nb_sbm_bp2 = 0;
125 if ( lfrCurrentMode == LFR_MODE_BURST )
125 if ( lfrCurrentMode == LFR_MODE_BURST )
126 {
126 {
127 msgForMATR.event = msgForMATR.event | RTEMS_EVENT_BURST_BP2_F0;
127 msgForMATR.event = msgForMATR.event | RTEMS_EVENT_BURST_BP2_F0;
128 }
128 }
129 else if ( (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )
129 else if ( (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )
130 {
130 {
131 msgForMATR.event = msgForMATR.event | RTEMS_EVENT_SBM_BP2_F0;
131 msgForMATR.event = msgForMATR.event | RTEMS_EVENT_SBM_BP2_F0;
132 }
132 }
133 }
133 }
134
134
135 if (nb_norm_bp1 == nb_sm_before_f0.norm_bp1)
135 if (nb_norm_bp1 == nb_sm_before_f0.norm_bp1)
136 {
136 {
137 nb_norm_bp1 = 0;
137 nb_norm_bp1 = 0;
138 // set another ring for the ASM storage
138 // set another ring for the ASM storage
139 current_ring_node_asm_norm_f0 = current_ring_node_asm_norm_f0->next;
139 current_ring_node_asm_norm_f0 = current_ring_node_asm_norm_f0->next;
140 if ( (lfrCurrentMode == LFR_MODE_NORMAL)
140 if ( (lfrCurrentMode == LFR_MODE_NORMAL)
141 || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )
141 || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )
142 {
142 {
143 msgForMATR.event = msgForMATR.event | RTEMS_EVENT_NORM_BP1_F0;
143 msgForMATR.event = msgForMATR.event | RTEMS_EVENT_NORM_BP1_F0;
144 }
144 }
145 }
145 }
146
146
147 if (nb_norm_bp2 == nb_sm_before_f0.norm_bp2)
147 if (nb_norm_bp2 == nb_sm_before_f0.norm_bp2)
148 {
148 {
149 nb_norm_bp2 = 0;
149 nb_norm_bp2 = 0;
150 if ( (lfrCurrentMode == LFR_MODE_NORMAL)
150 if ( (lfrCurrentMode == LFR_MODE_NORMAL)
151 || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )
151 || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )
152 {
152 {
153 msgForMATR.event = msgForMATR.event | RTEMS_EVENT_NORM_BP2_F0;
153 msgForMATR.event = msgForMATR.event | RTEMS_EVENT_NORM_BP2_F0;
154 }
154 }
155 }
155 }
156
156
157 if (nb_norm_asm == nb_sm_before_f0.norm_asm)
157 if (nb_norm_asm == nb_sm_before_f0.norm_asm)
158 {
158 {
159 nb_norm_asm = 0;
159 nb_norm_asm = 0;
160 if ( (lfrCurrentMode == LFR_MODE_NORMAL)
160 if ( (lfrCurrentMode == LFR_MODE_NORMAL)
161 || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )
161 || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )
162 {
162 {
163 msgForMATR.event = msgForMATR.event | RTEMS_EVENT_NORM_ASM_F0;
163 msgForMATR.event = msgForMATR.event | RTEMS_EVENT_NORM_ASM_F0;
164 }
164 }
165 }
165 }
166
166
167 //*************************
167 //*************************
168 // send the message to MATR
168 // send the message to MATR
169 if (msgForMATR.event != 0x00)
169 if (msgForMATR.event != 0x00)
170 {
170 {
171 status = rtems_message_queue_send( queue_id_prc0, (char *) &msgForMATR, MSG_QUEUE_SIZE_PRC0);
171 status = rtems_message_queue_send( queue_id_prc0, (char *) &msgForMATR, MSG_QUEUE_SIZE_PRC0);
172 }
172 }
173
173
174 if (status != RTEMS_SUCCESSFUL) {
174 if (status != RTEMS_SUCCESSFUL) {
175 printf("in AVF0 *** Error sending message to MATR, code %d\n", status);
175 printf("in AVF0 *** Error sending message to MATR, code %d\n", status);
176 }
176 }
177 }
177 }
178 }
178 }
179
179
180 rtems_task prc0_task( rtems_task_argument lfrRequestedMode )
180 rtems_task prc0_task( rtems_task_argument lfrRequestedMode )
181 {
181 {
182 char incomingData[MSG_QUEUE_SIZE_SEND]; // incoming data buffer
182 char incomingData[MSG_QUEUE_SIZE_SEND]; // incoming data buffer
183 size_t size; // size of the incoming TC packet
183 size_t size; // size of the incoming TC packet
184 asm_msg *incomingMsg;
184 asm_msg *incomingMsg;
185 //
185 //
186 unsigned char sid;
186 unsigned char sid;
187 rtems_status_code status;
187 rtems_status_code status;
188 rtems_id queue_id;
188 rtems_id queue_id;
189 rtems_id queue_id_q_p0;
189 rtems_id queue_id_q_p0;
190 bp_packet_with_spare packet_norm_bp1;
190 bp_packet_with_spare packet_norm_bp1;
191 bp_packet packet_norm_bp2;
191 bp_packet packet_norm_bp2;
192 bp_packet packet_sbm_bp1;
192 bp_packet packet_sbm_bp1;
193 bp_packet packet_sbm_bp2;
193 bp_packet packet_sbm_bp2;
194 ring_node *current_ring_node_to_send_asm_f0;
194 ring_node *current_ring_node_to_send_asm_f0;
195
195
196 unsigned long long int localTime;
197
198 // init the ring of the averaged spectral matrices which will be transmitted to the DPU
196 // init the ring of the averaged spectral matrices which will be transmitted to the DPU
199 init_ring( ring_to_send_asm_f0, NB_RING_NODES_ASM_F0, (volatile int*) buffer_asm_f0, TOTAL_SIZE_SM );
197 init_ring( ring_to_send_asm_f0, NB_RING_NODES_ASM_F0, (volatile int*) buffer_asm_f0, TOTAL_SIZE_SM );
200 current_ring_node_to_send_asm_f0 = ring_to_send_asm_f0;
198 current_ring_node_to_send_asm_f0 = ring_to_send_asm_f0;
201
199
202 //*************
200 //*************
203 // NORM headers
201 // NORM headers
204 BP_init_header_with_spare( &packet_norm_bp1.header,
202 BP_init_header_with_spare( &packet_norm_bp1.header,
205 APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP1_F0,
203 APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP1_F0,
206 PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0, NB_BINS_COMPRESSED_SM_F0 );
204 PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0, NB_BINS_COMPRESSED_SM_F0 );
207 BP_init_header( &packet_norm_bp2,
205 BP_init_header( &packet_norm_bp2,
208 APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP2_F0,
206 APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP2_F0,
209 PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0, NB_BINS_COMPRESSED_SM_F0);
207 PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0, NB_BINS_COMPRESSED_SM_F0);
210
208
211 //****************************
209 //****************************
212 // BURST SBM1 and SBM2 headers
210 // BURST SBM1 and SBM2 headers
213 if ( lfrRequestedMode == LFR_MODE_BURST )
211 if ( lfrRequestedMode == LFR_MODE_BURST )
214 {
212 {
215 BP_init_header( &packet_sbm_bp1,
213 BP_init_header( &packet_sbm_bp1,
216 APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP1_F0,
214 APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP1_F0,
217 PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
215 PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
218 BP_init_header( &packet_sbm_bp2,
216 BP_init_header( &packet_sbm_bp2,
219 APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP2_F0,
217 APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP2_F0,
220 PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
218 PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
221 }
219 }
222 else if ( lfrRequestedMode == LFR_MODE_SBM1 )
220 else if ( lfrRequestedMode == LFR_MODE_SBM1 )
223 {
221 {
224 BP_init_header( &packet_sbm_bp1,
222 BP_init_header( &packet_sbm_bp1,
225 APID_TM_SCIENCE_SBM1_SBM2, SID_SBM1_BP1_F0,
223 APID_TM_SCIENCE_SBM1_SBM2, SID_SBM1_BP1_F0,
226 PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
224 PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
227 BP_init_header( &packet_sbm_bp2,
225 BP_init_header( &packet_sbm_bp2,
228 APID_TM_SCIENCE_SBM1_SBM2, SID_SBM1_BP2_F0,
226 APID_TM_SCIENCE_SBM1_SBM2, SID_SBM1_BP2_F0,
229 PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
227 PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
230 }
228 }
231 else if ( lfrRequestedMode == LFR_MODE_SBM2 )
229 else if ( lfrRequestedMode == LFR_MODE_SBM2 )
232 {
230 {
233 BP_init_header( &packet_sbm_bp1,
231 BP_init_header( &packet_sbm_bp1,
234 APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP1_F0,
232 APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP1_F0,
235 PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
233 PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
236 BP_init_header( &packet_sbm_bp2,
234 BP_init_header( &packet_sbm_bp2,
237 APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP2_F0,
235 APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP2_F0,
238 PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
236 PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
239 }
237 }
240 else
238 else
241 {
239 {
242 PRINTF1("in PRC0 *** lfrRequestedMode is %d, several headers not initialized\n", (unsigned int) lfrRequestedMode)
240 PRINTF1("in PRC0 *** lfrRequestedMode is %d, several headers not initialized\n", (unsigned int) lfrRequestedMode)
243 }
241 }
244
242
245 status = get_message_queue_id_send( &queue_id );
243 status = get_message_queue_id_send( &queue_id );
246 if (status != RTEMS_SUCCESSFUL)
244 if (status != RTEMS_SUCCESSFUL)
247 {
245 {
248 PRINTF1("in PRC0 *** ERR get_message_queue_id_send %d\n", status)
246 PRINTF1("in PRC0 *** ERR get_message_queue_id_send %d\n", status)
249 }
247 }
250 status = get_message_queue_id_prc0( &queue_id_q_p0);
248 status = get_message_queue_id_prc0( &queue_id_q_p0);
251 if (status != RTEMS_SUCCESSFUL)
249 if (status != RTEMS_SUCCESSFUL)
252 {
250 {
253 PRINTF1("in PRC0 *** ERR get_message_queue_id_prc0 %d\n", status)
251 PRINTF1("in PRC0 *** ERR get_message_queue_id_prc0 %d\n", status)
254 }
252 }
255
253
256 BOOT_PRINTF1("in PRC0 *** lfrRequestedMode = %d\n", (int) lfrRequestedMode)
254 BOOT_PRINTF1("in PRC0 *** lfrRequestedMode = %d\n", (int) lfrRequestedMode)
257
255
258 while(1){
256 while(1){
259 status = rtems_message_queue_receive( queue_id_q_p0, incomingData, &size, //************************************
257 status = rtems_message_queue_receive( queue_id_q_p0, incomingData, &size, //************************************
260 RTEMS_WAIT, RTEMS_NO_TIMEOUT ); // wait for a message coming from AVF0
258 RTEMS_WAIT, RTEMS_NO_TIMEOUT ); // wait for a message coming from AVF0
261
259
262 incomingMsg = (asm_msg*) incomingData;
260 incomingMsg = (asm_msg*) incomingData;
263
261
264 localTime = getTimeAsUnsignedLongLongInt( );
265
266 //****************
262 //****************
267 //****************
263 //****************
268 // BURST SBM1 SBM2
264 // BURST SBM1 SBM2
269 //****************
265 //****************
270 //****************
266 //****************
271 if ( (incomingMsg->event & RTEMS_EVENT_BURST_BP1_F0 ) || (incomingMsg->event & RTEMS_EVENT_SBM_BP1_F0 ) )
267 if ( (incomingMsg->event & RTEMS_EVENT_BURST_BP1_F0 ) || (incomingMsg->event & RTEMS_EVENT_SBM_BP1_F0 ) )
272 {
268 {
273 sid = getSID( incomingMsg->event );
269 sid = getSID( incomingMsg->event );
274 // 1) compress the matrix for Basic Parameters calculation
270 // 1) compress the matrix for Basic Parameters calculation
275 ASM_compress_reorganize_and_divide( incomingMsg->burst_sbm->matrix, compressed_sm_sbm_f0,
271 ASM_compress_reorganize_and_divide( incomingMsg->burst_sbm->matrix, compressed_sm_sbm_f0,
276 nb_sm_before_f0.burst_sbm_bp1,
272 nb_sm_before_f0.burst_sbm_bp1,
277 NB_BINS_COMPRESSED_SM_SBM_F0, NB_BINS_TO_AVERAGE_ASM_SBM_F0,
273 NB_BINS_COMPRESSED_SM_SBM_F0, NB_BINS_TO_AVERAGE_ASM_SBM_F0,
278 ASM_F0_INDICE_START);
274 ASM_F0_INDICE_START);
279 // 2) compute the BP1 set
275 // 2) compute the BP1 set
280 BP1_set( compressed_sm_sbm_f0, k_coeff_intercalib_f0_sbm, NB_BINS_COMPRESSED_SM_SBM_F0, packet_sbm_bp1.data );
276 BP1_set( compressed_sm_sbm_f0, k_coeff_intercalib_f0_sbm, NB_BINS_COMPRESSED_SM_SBM_F0, packet_sbm_bp1.data );
281 // 3) send the BP1 set
277 // 3) send the BP1 set
282 set_time( packet_sbm_bp1.time, (unsigned char *) &incomingMsg->coarseTimeSBM );
278 set_time( packet_sbm_bp1.time, (unsigned char *) &incomingMsg->coarseTimeSBM );
283 set_time( packet_sbm_bp1.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeSBM );
279 set_time( packet_sbm_bp1.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeSBM );
284 BP_send( (char *) &packet_sbm_bp1, queue_id,
280 BP_send( (char *) &packet_sbm_bp1, queue_id,
285 PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0 + PACKET_LENGTH_DELTA,
281 PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0 + PACKET_LENGTH_DELTA,
286 sid);
282 sid);
287 // 4) compute the BP2 set if needed
283 // 4) compute the BP2 set if needed
288 if ( (incomingMsg->event & RTEMS_EVENT_BURST_BP2_F0) || (incomingMsg->event & RTEMS_EVENT_SBM_BP2_F0) )
284 if ( (incomingMsg->event & RTEMS_EVENT_BURST_BP2_F0) || (incomingMsg->event & RTEMS_EVENT_SBM_BP2_F0) )
289 {
285 {
290 // 1) compute the BP2 set
286 // 1) compute the BP2 set
291 BP2_set( compressed_sm_sbm_f0, NB_BINS_COMPRESSED_SM_SBM_F0, packet_sbm_bp2.data );
287 BP2_set( compressed_sm_sbm_f0, NB_BINS_COMPRESSED_SM_SBM_F0, packet_sbm_bp2.data );
292 // 2) send the BP2 set
288 // 2) send the BP2 set
293 set_time( packet_sbm_bp2.time, (unsigned char *) &incomingMsg->coarseTimeSBM );
289 set_time( packet_sbm_bp2.time, (unsigned char *) &incomingMsg->coarseTimeSBM );
294 set_time( packet_sbm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeSBM );
290 set_time( packet_sbm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeSBM );
295 BP_send( (char *) &packet_sbm_bp2, queue_id,
291 BP_send( (char *) &packet_sbm_bp2, queue_id,
296 PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0 + PACKET_LENGTH_DELTA,
292 PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0 + PACKET_LENGTH_DELTA,
297 sid);
293 sid);
298 }
294 }
299 }
295 }
300
296
301 //*****
297 //*****
302 //*****
298 //*****
303 // NORM
299 // NORM
304 //*****
300 //*****
305 //*****
301 //*****
306 if (incomingMsg->event & RTEMS_EVENT_NORM_BP1_F0)
302 if (incomingMsg->event & RTEMS_EVENT_NORM_BP1_F0)
307 {
303 {
308 // 1) compress the matrix for Basic Parameters calculation
304 // 1) compress the matrix for Basic Parameters calculation
309 ASM_compress_reorganize_and_divide( incomingMsg->norm->matrix, compressed_sm_norm_f0,
305 ASM_compress_reorganize_and_divide( incomingMsg->norm->matrix, compressed_sm_norm_f0,
310 nb_sm_before_f0.norm_bp1,
306 nb_sm_before_f0.norm_bp1,
311 NB_BINS_COMPRESSED_SM_F0, NB_BINS_TO_AVERAGE_ASM_F0,
307 NB_BINS_COMPRESSED_SM_F0, NB_BINS_TO_AVERAGE_ASM_F0,
312 ASM_F0_INDICE_START );
308 ASM_F0_INDICE_START );
313 // 2) compute the BP1 set
309 // 2) compute the BP1 set
314 BP1_set( compressed_sm_norm_f0, k_coeff_intercalib_f0_norm, NB_BINS_COMPRESSED_SM_F0, packet_norm_bp1.data );
310 BP1_set( compressed_sm_norm_f0, k_coeff_intercalib_f0_norm, NB_BINS_COMPRESSED_SM_F0, packet_norm_bp1.data );
315 // 3) send the BP1 set
311 // 3) send the BP1 set
316 set_time( packet_norm_bp1.header.time, (unsigned char *) &incomingMsg->coarseTimeNORM );
312 set_time( packet_norm_bp1.header.time, (unsigned char *) &incomingMsg->coarseTimeNORM );
317 set_time( packet_norm_bp1.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM );
313 set_time( packet_norm_bp1.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM );
318 BP_send( (char *) &packet_norm_bp1, queue_id,
314 BP_send( (char *) &packet_norm_bp1, queue_id,
319 PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0 + PACKET_LENGTH_DELTA,
315 PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0 + PACKET_LENGTH_DELTA,
320 SID_NORM_BP1_F0 );
316 SID_NORM_BP1_F0 );
321 if (incomingMsg->event & RTEMS_EVENT_NORM_BP2_F0)
317 if (incomingMsg->event & RTEMS_EVENT_NORM_BP2_F0)
322 {
318 {
323 // 1) compute the BP2 set using the same ASM as the one used for BP1
319 // 1) compute the BP2 set using the same ASM as the one used for BP1
324 BP2_set( compressed_sm_norm_f0, NB_BINS_COMPRESSED_SM_F0, packet_norm_bp2.data );
320 BP2_set( compressed_sm_norm_f0, NB_BINS_COMPRESSED_SM_F0, packet_norm_bp2.data );
325 // 2) send the BP2 set
321 // 2) send the BP2 set
326 set_time( packet_norm_bp2.time, (unsigned char *) &incomingMsg->coarseTimeNORM );
322 set_time( packet_norm_bp2.time, (unsigned char *) &incomingMsg->coarseTimeNORM );
327 set_time( packet_norm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM );
323 set_time( packet_norm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM );
328 BP_send( (char *) &packet_norm_bp2, queue_id,
324 BP_send( (char *) &packet_norm_bp2, queue_id,
329 PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0 + PACKET_LENGTH_DELTA,
325 PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0 + PACKET_LENGTH_DELTA,
330 SID_NORM_BP2_F0);
326 SID_NORM_BP2_F0);
331
332 // < TMP DATA>
333 #define INDEX_COMPRESSED 1
334 unsigned int signif;
335 float significand;
336 unsigned int nbitexp = 6;
337 unsigned int nbitsig = 16 - nbitexp; // number of bits for the significand
338 unsigned int rangesig = (1 << nbitsig)-1; // == 2^nbitsig - 1
339 int expmax = 32;
340 int expmin = expmax - ((int) (1 << nbitexp)) + 1;
341 int exponent;
342 float auto_a0;
343 exponent = ( (int) ( (packet_norm_bp2.data[INDEX_COMPRESSED * NB_BYTES_PER_BP2] & 0xfc) >> 2) ) + expmin; // [1111 1100]
344 printf("exponent = %x, computed with exp = %x, expmin = %d\n",
345 exponent,
346 (packet_norm_bp2.data[INDEX_COMPRESSED * NB_BYTES_PER_BP2] & 0xfc) >> 2,
347 expmin);
348 signif = ( (packet_norm_bp2.data[INDEX_COMPRESSED * NB_BYTES_PER_BP2] & 0x3) << 8 ) + packet_norm_bp2.data[INDEX_COMPRESSED * NB_BYTES_PER_BP2+1];
349 significand = ( ( (float) signif ) / ( (float) rangesig) + 1) / 2;
350 auto_a0 = significand * pow(2,exponent);
351 printf("(BP2) [%d] compressed = %f *** AUTO A0 = %x, %x, exponent = %x, significand = %f ===> %f\n",
352 INDEX_COMPRESSED,
353 compressed_sm_norm_f0[INDEX_COMPRESSED * NB_VALUES_PER_SM],
354 packet_norm_bp2.data[ INDEX_COMPRESSED * NB_BYTES_PER_BP2],
355 packet_norm_bp2.data[ INDEX_COMPRESSED * NB_BYTES_PER_BP2 + 1],
356 exponent, significand, auto_a0 );
357 // printf("(BP2) 0 = %f, 1 = %f, 2 = %f, 3 = %f, 4 = %f, 5 = %f, 6 = %f, 7 = %f, 8 = %f, 9 = %f, 10 = %f,\n",
358 // compressed_sm_norm_f0[0 * NB_VALUES_PER_SM],
359 // compressed_sm_norm_f0[1 * NB_VALUES_PER_SM],
360 // compressed_sm_norm_f0[2 * NB_VALUES_PER_SM],
361 // compressed_sm_norm_f0[3 * NB_VALUES_PER_SM],
362 // compressed_sm_norm_f0[4 * NB_VALUES_PER_SM],
363 // compressed_sm_norm_f0[5 * NB_VALUES_PER_SM],
364 // compressed_sm_norm_f0[6 * NB_VALUES_PER_SM],
365 // compressed_sm_norm_f0[7 * NB_VALUES_PER_SM],
366 // compressed_sm_norm_f0[8 * NB_VALUES_PER_SM],
367 // compressed_sm_norm_f0[9 * NB_VALUES_PER_SM],
368 // compressed_sm_norm_f0[10 * NB_VALUES_PER_SM]);
369 // </TMP DATA>
370
371 }
327 }
372 }
328 }
373
329
374 if (incomingMsg->event & RTEMS_EVENT_NORM_ASM_F0)
330 if (incomingMsg->event & RTEMS_EVENT_NORM_ASM_F0)
375 {
331 {
376 // 1) reorganize the ASM and divide
332 // 1) reorganize the ASM and divide
377 ASM_reorganize_and_divide( incomingMsg->norm->matrix,
333 ASM_reorganize_and_divide( incomingMsg->norm->matrix,
378 asm_f0_reorganized,
334 asm_f0_reorganized,
379 nb_sm_before_f0.norm_bp1 );
335 nb_sm_before_f0.norm_bp1 );
380 // 2) convert the float array in a char array
336 // 2) convert the float array in a char array
381 ASM_convert( asm_f0_reorganized, (char*) current_ring_node_to_send_asm_f0->buffer_address );
337 ASM_convert( asm_f0_reorganized, (char*) current_ring_node_to_send_asm_f0->buffer_address );
382 current_ring_node_to_send_asm_f0->coarseTime = incomingMsg->coarseTimeNORM;
338 current_ring_node_to_send_asm_f0->coarseTime = incomingMsg->coarseTimeNORM;
383 current_ring_node_to_send_asm_f0->fineTime = incomingMsg->fineTimeNORM;
339 current_ring_node_to_send_asm_f0->fineTime = incomingMsg->fineTimeNORM;
384 current_ring_node_to_send_asm_f0->sid = SID_NORM_ASM_F0;
340 current_ring_node_to_send_asm_f0->sid = SID_NORM_ASM_F0;
385
341
386 // < TMP DATA>
387 #define INDEX_TO_LOOK_AT 31
388 float b11;
389 unsigned char *b11_charPtr;
390 b11_charPtr = (unsigned char*) &b11;
391 b11_charPtr[0] = ((unsigned char *) current_ring_node_to_send_asm_f0->buffer_address)[(INDEX_TO_LOOK_AT * NB_VALUES_PER_SM) * 2];
392 b11_charPtr[1] = ((unsigned char *) current_ring_node_to_send_asm_f0->buffer_address)[(INDEX_TO_LOOK_AT * NB_VALUES_PER_SM) * 2 +1];
393 b11_charPtr[2] = 0x00;
394 b11_charPtr[3] = 0x00;
395 printf("(ASM) initial = %f, reorganized and divided = %f, converted = %f\n",
396 incomingMsg->norm->matrix[INDEX_TO_LOOK_AT], // 32 * 96 = 3072 Hz
397 asm_f0_reorganized[ INDEX_TO_LOOK_AT * NB_VALUES_PER_SM ],
398 b11);
399 // </TMP DATA>
400
401 // 3) send the spectral matrix packets
342 // 3) send the spectral matrix packets
402 status = rtems_message_queue_send( queue_id, &current_ring_node_to_send_asm_f0, sizeof( ring_node* ) );
343 status = rtems_message_queue_send( queue_id, &current_ring_node_to_send_asm_f0, sizeof( ring_node* ) );
403 // change asm ring node
344 // change asm ring node
404 current_ring_node_to_send_asm_f0 = current_ring_node_to_send_asm_f0->next;
345 current_ring_node_to_send_asm_f0 = current_ring_node_to_send_asm_f0->next;
405 }
346 }
406
407 }
347 }
408 }
348 }
409
349
410 //**********
350 //**********
411 // FUNCTIONS
351 // FUNCTIONS
412
352
413 void reset_nb_sm_f0( unsigned char lfrMode )
353 void reset_nb_sm_f0( unsigned char lfrMode )
414 {
354 {
415 nb_sm_before_f0.norm_bp1 = parameter_dump_packet.sy_lfr_n_bp_p0 * 96;
355 nb_sm_before_f0.norm_bp1 = parameter_dump_packet.sy_lfr_n_bp_p0 * 96;
416 nb_sm_before_f0.norm_bp2 = parameter_dump_packet.sy_lfr_n_bp_p1 * 96;
356 nb_sm_before_f0.norm_bp2 = parameter_dump_packet.sy_lfr_n_bp_p1 * 96;
417 nb_sm_before_f0.norm_asm = (parameter_dump_packet.sy_lfr_n_asm_p[0] * 256 + parameter_dump_packet.sy_lfr_n_asm_p[1]) * 96;
357 nb_sm_before_f0.norm_asm = (parameter_dump_packet.sy_lfr_n_asm_p[0] * 256 + parameter_dump_packet.sy_lfr_n_asm_p[1]) * 96;
418 nb_sm_before_f0.sbm1_bp1 = parameter_dump_packet.sy_lfr_s1_bp_p0 * 24; // 0.25 s per digit
358 nb_sm_before_f0.sbm1_bp1 = parameter_dump_packet.sy_lfr_s1_bp_p0 * 24; // 0.25 s per digit
419 nb_sm_before_f0.sbm1_bp2 = parameter_dump_packet.sy_lfr_s1_bp_p1 * 96;
359 nb_sm_before_f0.sbm1_bp2 = parameter_dump_packet.sy_lfr_s1_bp_p1 * 96;
420 nb_sm_before_f0.sbm2_bp1 = parameter_dump_packet.sy_lfr_s2_bp_p0 * 96;
360 nb_sm_before_f0.sbm2_bp1 = parameter_dump_packet.sy_lfr_s2_bp_p0 * 96;
421 nb_sm_before_f0.sbm2_bp2 = parameter_dump_packet.sy_lfr_s2_bp_p1 * 96;
361 nb_sm_before_f0.sbm2_bp2 = parameter_dump_packet.sy_lfr_s2_bp_p1 * 96;
422 nb_sm_before_f0.burst_bp1 = parameter_dump_packet.sy_lfr_b_bp_p0 * 96;
362 nb_sm_before_f0.burst_bp1 = parameter_dump_packet.sy_lfr_b_bp_p0 * 96;
423 nb_sm_before_f0.burst_bp2 = parameter_dump_packet.sy_lfr_b_bp_p1 * 96;
363 nb_sm_before_f0.burst_bp2 = parameter_dump_packet.sy_lfr_b_bp_p1 * 96;
424
364
425 if (lfrMode == LFR_MODE_SBM1)
365 if (lfrMode == LFR_MODE_SBM1)
426 {
366 {
427 nb_sm_before_f0.burst_sbm_bp1 = nb_sm_before_f0.sbm1_bp1;
367 nb_sm_before_f0.burst_sbm_bp1 = nb_sm_before_f0.sbm1_bp1;
428 nb_sm_before_f0.burst_sbm_bp2 = nb_sm_before_f0.sbm1_bp2;
368 nb_sm_before_f0.burst_sbm_bp2 = nb_sm_before_f0.sbm1_bp2;
429 }
369 }
430 else if (lfrMode == LFR_MODE_SBM2)
370 else if (lfrMode == LFR_MODE_SBM2)
431 {
371 {
432 nb_sm_before_f0.burst_sbm_bp1 = nb_sm_before_f0.sbm2_bp1;
372 nb_sm_before_f0.burst_sbm_bp1 = nb_sm_before_f0.sbm2_bp1;
433 nb_sm_before_f0.burst_sbm_bp2 = nb_sm_before_f0.sbm2_bp2;
373 nb_sm_before_f0.burst_sbm_bp2 = nb_sm_before_f0.sbm2_bp2;
434 }
374 }
435 else if (lfrMode == LFR_MODE_BURST)
375 else if (lfrMode == LFR_MODE_BURST)
436 {
376 {
437 nb_sm_before_f0.burst_sbm_bp1 = nb_sm_before_f0.burst_bp1;
377 nb_sm_before_f0.burst_sbm_bp1 = nb_sm_before_f0.burst_bp1;
438 nb_sm_before_f0.burst_sbm_bp2 = nb_sm_before_f0.burst_bp2;
378 nb_sm_before_f0.burst_sbm_bp2 = nb_sm_before_f0.burst_bp2;
439 }
379 }
440 else
380 else
441 {
381 {
442 nb_sm_before_f0.burst_sbm_bp1 = nb_sm_before_f0.burst_bp1;
382 nb_sm_before_f0.burst_sbm_bp1 = nb_sm_before_f0.burst_bp1;
443 nb_sm_before_f0.burst_sbm_bp2 = nb_sm_before_f0.burst_bp2;
383 nb_sm_before_f0.burst_sbm_bp2 = nb_sm_before_f0.burst_bp2;
444 }
384 }
445 }
385 }
446
386
447 void init_k_coefficients_f0( void )
387 void init_k_coefficients_f0( void )
448 {
388 {
449 init_k_coefficients( k_coeff_intercalib_f0_norm, NB_BINS_COMPRESSED_SM_F0 );
389 init_k_coefficients( k_coeff_intercalib_f0_norm, NB_BINS_COMPRESSED_SM_F0 );
450 init_k_coefficients( k_coeff_intercalib_f0_sbm, NB_BINS_COMPRESSED_SM_SBM_F0);
390 init_k_coefficients( k_coeff_intercalib_f0_sbm, NB_BINS_COMPRESSED_SM_SBM_F0);
451 }
391 }
452
453 void test_TCH( void )
454 {
455 #define NB_BINS_COMPRESSED_MATRIX_TCH 1
456
457 unsigned char LFR_BP1_f0[NB_BINS_COMPRESSED_MATRIX_TCH*NB_BYTES_BP1];
458 unsigned char LFR_BP2_f0[NB_BINS_COMPRESSED_MATRIX_TCH*NB_BYTES_BP2];
459 float k_coefficients[NB_BINS_COMPRESSED_MATRIX_TCH * NB_K_COEFF_PER_BIN];
460
461 float compressed_spectral_matrix_TCH[ NB_BINS_COMPRESSED_MATRIX_TCH * NB_VALUES_PER_SPECTRAL_MATRIX ] = {
462 1.02217712e+06,
463 -8.58216250e+04,
464 -3.22199043e+04,
465 1.01597820e+05,
466 8.10333875e+05,
467 1.19030141e+05,
468 -8.69636688e+05,
469 5.01504031e+05,
470 -1.01948547e+05,
471 1.35475020e+04,
472 -3.67825469e+04,
473 -1.10950273e+05,
474 2.10715000e+04,
475 4.49727383e+04,
476 -4.37282031e+04,
477 3.83337695e+03,
478 1.05317175e+06,
479 -4.04155312e+05,
480 -1.32987891e+05,
481 1.49277250e+05,
482 -4.39122625e+05,
483 9.46006250e+05,
484 2.64386625e+05,
485 3.71843125e+05,
486 3.39770000e+05
487 };
488
489 init_k_coefficients( k_coefficients, NB_BINS_COMPRESSED_MATRIX_TCH );
490
491 printf("\n");
492
493 BP1_set(compressed_spectral_matrix_TCH, k_coefficients, NB_BINS_COMPRESSED_MATRIX_TCH, LFR_BP1_f0);
494
495 printf("\n");
496
497 BP2_set(compressed_spectral_matrix_TCH, NB_BINS_COMPRESSED_MATRIX_TCH, LFR_BP2_f0);
498 }
Show file before | Show file after | Hide comments
@@ -1,532 +1,538
1 /** Functions related to data processing.
1 /** Functions related to data processing.
2 *
2 *
3 * @file
3 * @file
4 * @author P. LEROY
4 * @author P. LEROY
5 *
5 *
6 * These function are related to data processing, i.e. spectral matrices averaging and basic parameters computation.
6 * These function are related to data processing, i.e. spectral matrices averaging and basic parameters computation.
7 *
7 *
8 */
8 */
9
9
10 #include "fsw_processing.h"
10 #include "fsw_processing.h"
11 #include "fsw_processing_globals.c"
11 #include "fsw_processing_globals.c"
12
12
13 unsigned int nb_sm_f0;
13 unsigned int nb_sm_f0;
14 unsigned int nb_sm_f0_aux_f1;
14 unsigned int nb_sm_f0_aux_f1;
15 unsigned int nb_sm_f1;
15 unsigned int nb_sm_f1;
16 unsigned int nb_sm_f0_aux_f2;
16 unsigned int nb_sm_f0_aux_f2;
17
17
18 //************************
18 //************************
19 // spectral matrices rings
19 // spectral matrices rings
20 ring_node sm_ring_f0[ NB_RING_NODES_SM_F0 ];
20 ring_node sm_ring_f0[ NB_RING_NODES_SM_F0 ];
21 ring_node sm_ring_f1[ NB_RING_NODES_SM_F1 ];
21 ring_node sm_ring_f1[ NB_RING_NODES_SM_F1 ];
22 ring_node sm_ring_f2[ NB_RING_NODES_SM_F2 ];
22 ring_node sm_ring_f2[ NB_RING_NODES_SM_F2 ];
23 ring_node *current_ring_node_sm_f0;
23 ring_node *current_ring_node_sm_f0;
24 ring_node *current_ring_node_sm_f1;
24 ring_node *current_ring_node_sm_f1;
25 ring_node *current_ring_node_sm_f2;
25 ring_node *current_ring_node_sm_f2;
26 ring_node *ring_node_for_averaging_sm_f0;
26 ring_node *ring_node_for_averaging_sm_f0;
27 ring_node *ring_node_for_averaging_sm_f1;
27 ring_node *ring_node_for_averaging_sm_f1;
28 ring_node *ring_node_for_averaging_sm_f2;
28 ring_node *ring_node_for_averaging_sm_f2;
29
29
30 //
30 //
31 ring_node * getRingNodeForAveraging( unsigned char frequencyChannel)
31 ring_node * getRingNodeForAveraging( unsigned char frequencyChannel)
32 {
32 {
33 ring_node *node;
33 ring_node *node;
34
34
35 node = NULL;
35 node = NULL;
36 switch ( frequencyChannel ) {
36 switch ( frequencyChannel ) {
37 case 0:
37 case 0:
38 node = ring_node_for_averaging_sm_f0;
38 node = ring_node_for_averaging_sm_f0;
39 break;
39 break;
40 case 1:
40 case 1:
41 node = ring_node_for_averaging_sm_f1;
41 node = ring_node_for_averaging_sm_f1;
42 break;
42 break;
43 case 2:
43 case 2:
44 node = ring_node_for_averaging_sm_f2;
44 node = ring_node_for_averaging_sm_f2;
45 break;
45 break;
46 default:
46 default:
47 break;
47 break;
48 }
48 }
49
49
50 return node;
50 return node;
51 }
51 }
52
52
53 //***********************************************************
53 //***********************************************************
54 // Interrupt Service Routine for spectral matrices processing
54 // Interrupt Service Routine for spectral matrices processing
55
55
56 void spectral_matrices_isr_f0( void )
56 void spectral_matrices_isr_f0( void )
57 {
57 {
58 unsigned char status;
58 unsigned char status;
59 rtems_status_code status_code;
59 rtems_status_code status_code;
60 ring_node *full_ring_node;
60
61
61 status = spectral_matrix_regs->status & 0x03; // [0011] get the status_ready_matrix_f0_x bits
62 status = spectral_matrix_regs->status & 0x03; // [0011] get the status_ready_matrix_f0_x bits
62
63
63 switch(status)
64 switch(status)
64 {
65 {
65 case 0:
66 case 0:
66 break;
67 break;
67 case 3:
68 case 3:
68 // UNEXPECTED VALUE
69 // UNEXPECTED VALUE
69 spectral_matrix_regs->status = 0x03; // [0011]
70 spectral_matrix_regs->status = 0x03; // [0011]
70 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_11 );
71 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_11 );
71 break;
72 break;
72 case 1:
73 case 1:
73 ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0->previous;
74 full_ring_node = current_ring_node_sm_f0->previous;
74 current_ring_node_sm_f0 = current_ring_node_sm_f0->next;
75 current_ring_node_sm_f0 = current_ring_node_sm_f0->next;
75 ring_node_for_averaging_sm_f0->coarseTime = spectral_matrix_regs->f0_0_coarse_time;
76 ring_node_for_averaging_sm_f0->fineTime = spectral_matrix_regs->f0_0_fine_time;
77 spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->buffer_address;
76 spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->buffer_address;
78 spectral_matrix_regs->status = 0x01; // [0000 0001]
79 // if there are enough ring nodes ready, wake up an AVFx task
77 // if there are enough ring nodes ready, wake up an AVFx task
80 nb_sm_f0 = nb_sm_f0 + 1;
78 nb_sm_f0 = nb_sm_f0 + 1;
81 if (nb_sm_f0 == NB_SM_BEFORE_AVF0)
79 if (nb_sm_f0 == NB_SM_BEFORE_AVF0)
82 {
80 {
81 ring_node_for_averaging_sm_f0 = full_ring_node;
82 ring_node_for_averaging_sm_f0->coarseTime = spectral_matrix_regs->f0_0_coarse_time;
83 ring_node_for_averaging_sm_f0->fineTime = spectral_matrix_regs->f0_0_fine_time;
83 if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
84 if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
84 {
85 {
85 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
86 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
86 }
87 }
87 nb_sm_f0 = 0;
88 nb_sm_f0 = 0;
88 }
89 }
90 spectral_matrix_regs->status = 0x01; // [0000 0001]
89 break;
91 break;
90 case 2:
92 case 2:
91 ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0->previous;
93 full_ring_node = current_ring_node_sm_f0->previous;
92 current_ring_node_sm_f0 = current_ring_node_sm_f0->next;
94 current_ring_node_sm_f0 = current_ring_node_sm_f0->next;
93 ring_node_for_averaging_sm_f0->coarseTime = spectral_matrix_regs->f0_1_coarse_time;
95 spectral_matrix_regs->f0_1_address = current_ring_node_sm_f0->buffer_address;
94 ring_node_for_averaging_sm_f0->fineTime = spectral_matrix_regs->f0_1_fine_time;
95 spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->buffer_address;
96 spectral_matrix_regs->status = 0x02; // [0000 0010]
97 // if there are enough ring nodes ready, wake up an AVFx task
96 // if there are enough ring nodes ready, wake up an AVFx task
98 nb_sm_f0 = nb_sm_f0 + 1;
97 nb_sm_f0 = nb_sm_f0 + 1;
99 if (nb_sm_f0 == NB_SM_BEFORE_AVF0)
98 if (nb_sm_f0 == NB_SM_BEFORE_AVF0)
100 {
99 {
100 ring_node_for_averaging_sm_f0 = full_ring_node;
101 ring_node_for_averaging_sm_f0->coarseTime = spectral_matrix_regs->f0_1_coarse_time;
102 ring_node_for_averaging_sm_f0->fineTime = spectral_matrix_regs->f0_1_fine_time;
101 if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
103 if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
102 {
104 {
103 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
105 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
104 }
106 }
105 nb_sm_f0 = 0;
107 nb_sm_f0 = 0;
106 }
108 }
109 spectral_matrix_regs->status = 0x02; // [0000 0010]
107 break;
110 break;
108 }
111 }
109 }
112 }
110
113
111 void spectral_matrices_isr_f1( void )
114 void spectral_matrices_isr_f1( void )
112 {
115 {
113 rtems_status_code status_code;
116 rtems_status_code status_code;
114 unsigned char status;
117 unsigned char status;
118 ring_node *full_ring_node;
115
119
116 status = (spectral_matrix_regs->status & 0x0c) >> 2; // [1100] get the status_ready_matrix_f0_x bits
120 status = (spectral_matrix_regs->status & 0x0c) >> 2; // [1100] get the status_ready_matrix_f0_x bits
117
121
118 switch(status)
122 switch(status)
119 {
123 {
120 case 0:
124 case 0:
121 break;
125 break;
122 case 3:
126 case 3:
123 // UNEXPECTED VALUE
127 // UNEXPECTED VALUE
124 spectral_matrix_regs->status = 0xc0; // [1100]
128 spectral_matrix_regs->status = 0xc0; // [1100]
125 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_11 );
129 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_11 );
126 break;
130 break;
127 case 1:
131 case 1:
128 ring_node_for_averaging_sm_f1 = current_ring_node_sm_f1->previous;
132 full_ring_node = current_ring_node_sm_f1->previous;
129 current_ring_node_sm_f1 = current_ring_node_sm_f1->next;
133 current_ring_node_sm_f1 = current_ring_node_sm_f1->next;
130 ring_node_for_averaging_sm_f1->coarseTime = spectral_matrix_regs->f1_0_coarse_time;
131 ring_node_for_averaging_sm_f1->fineTime = spectral_matrix_regs->f1_0_fine_time;
132 spectral_matrix_regs->f1_0_address = current_ring_node_sm_f1->buffer_address;
134 spectral_matrix_regs->f1_0_address = current_ring_node_sm_f1->buffer_address;
133 spectral_matrix_regs->status = 0x04; // [0000 0100]
134 // if there are enough ring nodes ready, wake up an AVFx task
135 // if there are enough ring nodes ready, wake up an AVFx task
135 nb_sm_f1 = nb_sm_f1 + 1;
136 nb_sm_f1 = nb_sm_f1 + 1;
136 if (nb_sm_f1 == NB_SM_BEFORE_AVF1)
137 if (nb_sm_f1 == NB_SM_BEFORE_AVF1)
137 {
138 {
139 ring_node_for_averaging_sm_f1 = full_ring_node;
140 ring_node_for_averaging_sm_f1->coarseTime = spectral_matrix_regs->f1_0_coarse_time;
141 ring_node_for_averaging_sm_f1->fineTime = spectral_matrix_regs->f1_0_fine_time;
138 if (rtems_event_send( Task_id[TASKID_AVF1], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
142 if (rtems_event_send( Task_id[TASKID_AVF1], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
139 {
143 {
140 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
144 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
141 }
145 }
142 nb_sm_f1 = 0;
146 nb_sm_f1 = 0;
143 }
147 }
148 spectral_matrix_regs->status = 0x04; // [0000 0100]
144 break;
149 break;
145 case 2:
150 case 2:
146 ring_node_for_averaging_sm_f1 = current_ring_node_sm_f1->previous;
151 full_ring_node = current_ring_node_sm_f1->previous;
147 current_ring_node_sm_f1 = current_ring_node_sm_f1->next;
152 current_ring_node_sm_f1 = current_ring_node_sm_f1->next;
148 ring_node_for_averaging_sm_f1->coarseTime = spectral_matrix_regs->f1_1_coarse_time;
149 ring_node_for_averaging_sm_f1->fineTime = spectral_matrix_regs->f1_1_fine_time;
150 spectral_matrix_regs->f1_1_address = current_ring_node_sm_f1->buffer_address;
153 spectral_matrix_regs->f1_1_address = current_ring_node_sm_f1->buffer_address;
151 spectral_matrix_regs->status = 0x08; // [1000 0000]
152 // if there are enough ring nodes ready, wake up an AVFx task
154 // if there are enough ring nodes ready, wake up an AVFx task
153 nb_sm_f1 = nb_sm_f1 + 1;
155 nb_sm_f1 = nb_sm_f1 + 1;
154 if (nb_sm_f1 == NB_SM_BEFORE_AVF1)
156 if (nb_sm_f1 == NB_SM_BEFORE_AVF1)
155 {
157 {
158 ring_node_for_averaging_sm_f1 = full_ring_node;
159 ring_node_for_averaging_sm_f1->coarseTime = spectral_matrix_regs->f1_1_coarse_time;
160 ring_node_for_averaging_sm_f1->fineTime = spectral_matrix_regs->f1_1_fine_time;
156 if (rtems_event_send( Task_id[TASKID_AVF1], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
161 if (rtems_event_send( Task_id[TASKID_AVF1], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
157 {
162 {
158 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
163 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
159 }
164 }
160 nb_sm_f1 = 0;
165 nb_sm_f1 = 0;
161 }
166 }
167 spectral_matrix_regs->status = 0x08; // [1000 0000]
162 break;
168 break;
163 }
169 }
164 }
170 }
165
171
166 void spectral_matrices_isr_f2( void )
172 void spectral_matrices_isr_f2( void )
167 {
173 {
168 unsigned char status;
174 unsigned char status;
169 rtems_status_code status_code;
175 rtems_status_code status_code;
170
176
171 status = (spectral_matrix_regs->status & 0x30) >> 4; // [0011 0000] get the status_ready_matrix_f0_x bits
177 status = (spectral_matrix_regs->status & 0x30) >> 4; // [0011 0000] get the status_ready_matrix_f0_x bits
172
178
173 switch(status)
179 switch(status)
174 {
180 {
175 case 0:
181 case 0:
176 break;
182 break;
177 case 3:
183 case 3:
178 // UNEXPECTED VALUE
184 // UNEXPECTED VALUE
179 spectral_matrix_regs->status = 0x30; // [0011 0000]
185 spectral_matrix_regs->status = 0x30; // [0011 0000]
180 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_11 );
186 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_11 );
181 break;
187 break;
182 case 1:
188 case 1:
183 ring_node_for_averaging_sm_f2 = current_ring_node_sm_f2->previous;
189 ring_node_for_averaging_sm_f2 = current_ring_node_sm_f2->previous;
184 current_ring_node_sm_f2 = current_ring_node_sm_f2->next;
190 current_ring_node_sm_f2 = current_ring_node_sm_f2->next;
185 ring_node_for_averaging_sm_f2->coarseTime = spectral_matrix_regs->f2_0_coarse_time;
191 ring_node_for_averaging_sm_f2->coarseTime = spectral_matrix_regs->f2_0_coarse_time;
186 ring_node_for_averaging_sm_f2->fineTime = spectral_matrix_regs->f2_0_fine_time;
192 ring_node_for_averaging_sm_f2->fineTime = spectral_matrix_regs->f2_0_fine_time;
187 spectral_matrix_regs->f2_0_address = current_ring_node_sm_f2->buffer_address;
193 spectral_matrix_regs->f2_0_address = current_ring_node_sm_f2->buffer_address;
188 spectral_matrix_regs->status = 0x10; // [0001 0000]
194 spectral_matrix_regs->status = 0x10; // [0001 0000]
189 if (rtems_event_send( Task_id[TASKID_AVF2], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
195 if (rtems_event_send( Task_id[TASKID_AVF2], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
190 {
196 {
191 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
197 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
192 }
198 }
193 break;
199 break;
194 case 2:
200 case 2:
195 ring_node_for_averaging_sm_f2 = current_ring_node_sm_f2->previous;
201 ring_node_for_averaging_sm_f2 = current_ring_node_sm_f2->previous;
196 current_ring_node_sm_f2 = current_ring_node_sm_f2->next;
202 current_ring_node_sm_f2 = current_ring_node_sm_f2->next;
197 ring_node_for_averaging_sm_f2->coarseTime = spectral_matrix_regs->f2_1_coarse_time;
203 ring_node_for_averaging_sm_f2->coarseTime = spectral_matrix_regs->f2_1_coarse_time;
198 ring_node_for_averaging_sm_f2->fineTime = spectral_matrix_regs->f2_1_fine_time;
204 ring_node_for_averaging_sm_f2->fineTime = spectral_matrix_regs->f2_1_fine_time;
199 spectral_matrix_regs->f2_1_address = current_ring_node_sm_f2->buffer_address;
205 spectral_matrix_regs->f2_1_address = current_ring_node_sm_f2->buffer_address;
200 spectral_matrix_regs->status = 0x20; // [0010 0000]
206 spectral_matrix_regs->status = 0x20; // [0010 0000]
201 if (rtems_event_send( Task_id[TASKID_AVF2], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
207 if (rtems_event_send( Task_id[TASKID_AVF2], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
202 {
208 {
203 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
209 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
204 }
210 }
205 break;
211 break;
206 }
212 }
207 }
213 }
208
214
209 void spectral_matrix_isr_error_handler( void )
215 void spectral_matrix_isr_error_handler( void )
210 {
216 {
211 rtems_status_code status_code;
217 rtems_status_code status_code;
212
218
213 if (spectral_matrix_regs->status & 0x7c0) // [0111 1100 0000]
219 if (spectral_matrix_regs->status & 0x7c0) // [0111 1100 0000]
214 {
220 {
215 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 );
221 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 );
216 }
222 }
217
223
218 spectral_matrix_regs->status = spectral_matrix_regs->status & 0x7c0;
224 spectral_matrix_regs->status = spectral_matrix_regs->status & 0x7c0;
219 }
225 }
220
226
221 rtems_isr spectral_matrices_isr( rtems_vector_number vector )
227 rtems_isr spectral_matrices_isr( rtems_vector_number vector )
222 {
228 {
223 // STATUS REGISTER
229 // STATUS REGISTER
224 // input_fifo_write(2) *** input_fifo_write(1) *** input_fifo_write(0)
230 // input_fifo_write(2) *** input_fifo_write(1) *** input_fifo_write(0)
225 // 10 9 8
231 // 10 9 8
226 // buffer_full ** bad_component_err ** f2_1 ** f2_0 ** f1_1 ** f1_0 ** f0_1 ** f0_0
232 // buffer_full ** bad_component_err ** f2_1 ** f2_0 ** f1_1 ** f1_0 ** f0_1 ** f0_0
227 // 7 6 5 4 3 2 1 0
233 // 7 6 5 4 3 2 1 0
228
234
229 spectral_matrices_isr_f0();
235 spectral_matrices_isr_f0();
230
236
231 spectral_matrices_isr_f1();
237 spectral_matrices_isr_f1();
232
238
233 spectral_matrices_isr_f2();
239 spectral_matrices_isr_f2();
234
240
235 spectral_matrix_isr_error_handler();
241 spectral_matrix_isr_error_handler();
236 }
242 }
237
243
238 rtems_isr spectral_matrices_isr_simu( rtems_vector_number vector )
244 rtems_isr spectral_matrices_isr_simu( rtems_vector_number vector )
239 {
245 {
240 rtems_status_code status_code;
246 rtems_status_code status_code;
241
247
242 //***
248 //***
243 // F0
249 // F0
244 nb_sm_f0 = nb_sm_f0 + 1;
250 nb_sm_f0 = nb_sm_f0 + 1;
245 if (nb_sm_f0 == NB_SM_BEFORE_AVF0 )
251 if (nb_sm_f0 == NB_SM_BEFORE_AVF0 )
246 {
252 {
247 ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0;
253 ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0;
248 if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
254 if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
249 {
255 {
250 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
256 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
251 }
257 }
252 nb_sm_f0 = 0;
258 nb_sm_f0 = 0;
253 }
259 }
254
260
255 //***
261 //***
256 // F1
262 // F1
257 nb_sm_f0_aux_f1 = nb_sm_f0_aux_f1 + 1;
263 nb_sm_f0_aux_f1 = nb_sm_f0_aux_f1 + 1;
258 if (nb_sm_f0_aux_f1 == 6)
264 if (nb_sm_f0_aux_f1 == 6)
259 {
265 {
260 nb_sm_f0_aux_f1 = 0;
266 nb_sm_f0_aux_f1 = 0;
261 nb_sm_f1 = nb_sm_f1 + 1;
267 nb_sm_f1 = nb_sm_f1 + 1;
262 }
268 }
263 if (nb_sm_f1 == NB_SM_BEFORE_AVF1 )
269 if (nb_sm_f1 == NB_SM_BEFORE_AVF1 )
264 {
270 {
265 ring_node_for_averaging_sm_f1 = current_ring_node_sm_f1;
271 ring_node_for_averaging_sm_f1 = current_ring_node_sm_f1;
266 if (rtems_event_send( Task_id[TASKID_AVF1], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
272 if (rtems_event_send( Task_id[TASKID_AVF1], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
267 {
273 {
268 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
274 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
269 }
275 }
270 nb_sm_f1 = 0;
276 nb_sm_f1 = 0;
271 }
277 }
272
278
273 //***
279 //***
274 // F2
280 // F2
275 nb_sm_f0_aux_f2 = nb_sm_f0_aux_f2 + 1;
281 nb_sm_f0_aux_f2 = nb_sm_f0_aux_f2 + 1;
276 if (nb_sm_f0_aux_f2 == 96)
282 if (nb_sm_f0_aux_f2 == 96)
277 {
283 {
278 nb_sm_f0_aux_f2 = 0;
284 nb_sm_f0_aux_f2 = 0;
279 ring_node_for_averaging_sm_f2 = current_ring_node_sm_f2;
285 ring_node_for_averaging_sm_f2 = current_ring_node_sm_f2;
280 if (rtems_event_send( Task_id[TASKID_AVF2], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
286 if (rtems_event_send( Task_id[TASKID_AVF2], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
281 {
287 {
282 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
288 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
283 }
289 }
284 }
290 }
285 }
291 }
286
292
287 //******************
293 //******************
288 // Spectral Matrices
294 // Spectral Matrices
289
295
290 void reset_nb_sm( void )
296 void reset_nb_sm( void )
291 {
297 {
292 nb_sm_f0 = 0;
298 nb_sm_f0 = 0;
293 nb_sm_f0_aux_f1 = 0;
299 nb_sm_f0_aux_f1 = 0;
294 nb_sm_f0_aux_f2 = 0;
300 nb_sm_f0_aux_f2 = 0;
295
301
296 nb_sm_f1 = 0;
302 nb_sm_f1 = 0;
297 }
303 }
298
304
299 void SM_init_rings( void )
305 void SM_init_rings( void )
300 {
306 {
301 init_ring( sm_ring_f0, NB_RING_NODES_SM_F0, sm_f0, TOTAL_SIZE_SM );
307 init_ring( sm_ring_f0, NB_RING_NODES_SM_F0, sm_f0, TOTAL_SIZE_SM );
302 init_ring( sm_ring_f1, NB_RING_NODES_SM_F1, sm_f1, TOTAL_SIZE_SM );
308 init_ring( sm_ring_f1, NB_RING_NODES_SM_F1, sm_f1, TOTAL_SIZE_SM );
303 init_ring( sm_ring_f2, NB_RING_NODES_SM_F2, sm_f2, TOTAL_SIZE_SM );
309 init_ring( sm_ring_f2, NB_RING_NODES_SM_F2, sm_f2, TOTAL_SIZE_SM );
304
310
305 DEBUG_PRINTF1("sm_ring_f0 @%x\n", (unsigned int) sm_ring_f0)
311 DEBUG_PRINTF1("sm_ring_f0 @%x\n", (unsigned int) sm_ring_f0)
306 DEBUG_PRINTF1("sm_ring_f1 @%x\n", (unsigned int) sm_ring_f1)
312 DEBUG_PRINTF1("sm_ring_f1 @%x\n", (unsigned int) sm_ring_f1)
307 DEBUG_PRINTF1("sm_ring_f2 @%x\n", (unsigned int) sm_ring_f2)
313 DEBUG_PRINTF1("sm_ring_f2 @%x\n", (unsigned int) sm_ring_f2)
308 DEBUG_PRINTF1("sm_f0 @%x\n", (unsigned int) sm_f0)
314 DEBUG_PRINTF1("sm_f0 @%x\n", (unsigned int) sm_f0)
309 DEBUG_PRINTF1("sm_f1 @%x\n", (unsigned int) sm_f1)
315 DEBUG_PRINTF1("sm_f1 @%x\n", (unsigned int) sm_f1)
310 DEBUG_PRINTF1("sm_f2 @%x\n", (unsigned int) sm_f2)
316 DEBUG_PRINTF1("sm_f2 @%x\n", (unsigned int) sm_f2)
311 }
317 }
312
318
313 void ASM_generic_init_ring( ring_node_asm *ring, unsigned char nbNodes )
319 void ASM_generic_init_ring( ring_node_asm *ring, unsigned char nbNodes )
314 {
320 {
315 unsigned char i;
321 unsigned char i;
316
322
317 ring[ nbNodes - 1 ].next
323 ring[ nbNodes - 1 ].next
318 = (ring_node_asm*) &ring[ 0 ];
324 = (ring_node_asm*) &ring[ 0 ];
319
325
320 for(i=0; i<nbNodes-1; i++)
326 for(i=0; i<nbNodes-1; i++)
321 {
327 {
322 ring[ i ].next = (ring_node_asm*) &ring[ i + 1 ];
328 ring[ i ].next = (ring_node_asm*) &ring[ i + 1 ];
323 }
329 }
324 }
330 }
325
331
326 void SM_reset_current_ring_nodes( void )
332 void SM_reset_current_ring_nodes( void )
327 {
333 {
328 current_ring_node_sm_f0 = sm_ring_f0[0].next;
334 current_ring_node_sm_f0 = sm_ring_f0[0].next;
329 current_ring_node_sm_f1 = sm_ring_f1[0].next;
335 current_ring_node_sm_f1 = sm_ring_f1[0].next;
330 current_ring_node_sm_f2 = sm_ring_f2[0].next;
336 current_ring_node_sm_f2 = sm_ring_f2[0].next;
331
337
332 ring_node_for_averaging_sm_f0 = sm_ring_f0;
338 ring_node_for_averaging_sm_f0 = NULL;
333 ring_node_for_averaging_sm_f1 = sm_ring_f1;
339 ring_node_for_averaging_sm_f1 = NULL;
334 ring_node_for_averaging_sm_f2 = sm_ring_f2;
340 ring_node_for_averaging_sm_f2 = NULL;
335 }
341 }
336
342
337 //*****************
343 //*****************
338 // Basic Parameters
344 // Basic Parameters
339
345
340 void BP_init_header( bp_packet *header,
346 void BP_init_header( bp_packet *header,
341 unsigned int apid, unsigned char sid,
347 unsigned int apid, unsigned char sid,
342 unsigned int packetLength, unsigned char blkNr )
348 unsigned int packetLength, unsigned char blkNr )
343 {
349 {
344 header->targetLogicalAddress = CCSDS_DESTINATION_ID;
350 header->targetLogicalAddress = CCSDS_DESTINATION_ID;
345 header->protocolIdentifier = CCSDS_PROTOCOLE_ID;
351 header->protocolIdentifier = CCSDS_PROTOCOLE_ID;
346 header->reserved = 0x00;
352 header->reserved = 0x00;
347 header->userApplication = CCSDS_USER_APP;
353 header->userApplication = CCSDS_USER_APP;
348 header->packetID[0] = (unsigned char) (apid >> 8);
354 header->packetID[0] = (unsigned char) (apid >> 8);
349 header->packetID[1] = (unsigned char) (apid);
355 header->packetID[1] = (unsigned char) (apid);
350 header->packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
356 header->packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
351 header->packetSequenceControl[1] = 0x00;
357 header->packetSequenceControl[1] = 0x00;
352 header->packetLength[0] = (unsigned char) (packetLength >> 8);
358 header->packetLength[0] = (unsigned char) (packetLength >> 8);
353 header->packetLength[1] = (unsigned char) (packetLength);
359 header->packetLength[1] = (unsigned char) (packetLength);
354 // DATA FIELD HEADER
360 // DATA FIELD HEADER
355 header->spare1_pusVersion_spare2 = 0x10;
361 header->spare1_pusVersion_spare2 = 0x10;
356 header->serviceType = TM_TYPE_LFR_SCIENCE; // service type
362 header->serviceType = TM_TYPE_LFR_SCIENCE; // service type
357 header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype
363 header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype
358 header->destinationID = TM_DESTINATION_ID_GROUND;
364 header->destinationID = TM_DESTINATION_ID_GROUND;
359 header->time[0] = 0x00;
365 header->time[0] = 0x00;
360 header->time[1] = 0x00;
366 header->time[1] = 0x00;
361 header->time[2] = 0x00;
367 header->time[2] = 0x00;
362 header->time[3] = 0x00;
368 header->time[3] = 0x00;
363 header->time[4] = 0x00;
369 header->time[4] = 0x00;
364 header->time[5] = 0x00;
370 header->time[5] = 0x00;
365 // AUXILIARY DATA HEADER
371 // AUXILIARY DATA HEADER
366 header->sid = sid;
372 header->sid = sid;
367 header->biaStatusInfo = 0x00;
373 header->biaStatusInfo = 0x00;
368 header->acquisitionTime[0] = 0x00;
374 header->acquisitionTime[0] = 0x00;
369 header->acquisitionTime[1] = 0x00;
375 header->acquisitionTime[1] = 0x00;
370 header->acquisitionTime[2] = 0x00;
376 header->acquisitionTime[2] = 0x00;
371 header->acquisitionTime[3] = 0x00;
377 header->acquisitionTime[3] = 0x00;
372 header->acquisitionTime[4] = 0x00;
378 header->acquisitionTime[4] = 0x00;
373 header->acquisitionTime[5] = 0x00;
379 header->acquisitionTime[5] = 0x00;
374 header->pa_lfr_bp_blk_nr[0] = 0x00; // BLK_NR MSB
380 header->pa_lfr_bp_blk_nr[0] = 0x00; // BLK_NR MSB
375 header->pa_lfr_bp_blk_nr[1] = blkNr; // BLK_NR LSB
381 header->pa_lfr_bp_blk_nr[1] = blkNr; // BLK_NR LSB
376 }
382 }
377
383
378 void BP_init_header_with_spare(Header_TM_LFR_SCIENCE_BP_with_spare_t *header,
384 void BP_init_header_with_spare(Header_TM_LFR_SCIENCE_BP_with_spare_t *header,
379 unsigned int apid, unsigned char sid,
385 unsigned int apid, unsigned char sid,
380 unsigned int packetLength , unsigned char blkNr)
386 unsigned int packetLength , unsigned char blkNr)
381 {
387 {
382 header->targetLogicalAddress = CCSDS_DESTINATION_ID;
388 header->targetLogicalAddress = CCSDS_DESTINATION_ID;
383 header->protocolIdentifier = CCSDS_PROTOCOLE_ID;
389 header->protocolIdentifier = CCSDS_PROTOCOLE_ID;
384 header->reserved = 0x00;
390 header->reserved = 0x00;
385 header->userApplication = CCSDS_USER_APP;
391 header->userApplication = CCSDS_USER_APP;
386 header->packetID[0] = (unsigned char) (apid >> 8);
392 header->packetID[0] = (unsigned char) (apid >> 8);
387 header->packetID[1] = (unsigned char) (apid);
393 header->packetID[1] = (unsigned char) (apid);
388 header->packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
394 header->packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
389 header->packetSequenceControl[1] = 0x00;
395 header->packetSequenceControl[1] = 0x00;
390 header->packetLength[0] = (unsigned char) (packetLength >> 8);
396 header->packetLength[0] = (unsigned char) (packetLength >> 8);
391 header->packetLength[1] = (unsigned char) (packetLength);
397 header->packetLength[1] = (unsigned char) (packetLength);
392 // DATA FIELD HEADER
398 // DATA FIELD HEADER
393 header->spare1_pusVersion_spare2 = 0x10;
399 header->spare1_pusVersion_spare2 = 0x10;
394 header->serviceType = TM_TYPE_LFR_SCIENCE; // service type
400 header->serviceType = TM_TYPE_LFR_SCIENCE; // service type
395 header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype
401 header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype
396 header->destinationID = TM_DESTINATION_ID_GROUND;
402 header->destinationID = TM_DESTINATION_ID_GROUND;
397 // AUXILIARY DATA HEADER
403 // AUXILIARY DATA HEADER
398 header->sid = sid;
404 header->sid = sid;
399 header->biaStatusInfo = 0x00;
405 header->biaStatusInfo = 0x00;
400 header->time[0] = 0x00;
406 header->time[0] = 0x00;
401 header->time[0] = 0x00;
407 header->time[0] = 0x00;
402 header->time[0] = 0x00;
408 header->time[0] = 0x00;
403 header->time[0] = 0x00;
409 header->time[0] = 0x00;
404 header->time[0] = 0x00;
410 header->time[0] = 0x00;
405 header->time[0] = 0x00;
411 header->time[0] = 0x00;
406 header->source_data_spare = 0x00;
412 header->source_data_spare = 0x00;
407 header->pa_lfr_bp_blk_nr[0] = 0x00; // BLK_NR MSB
413 header->pa_lfr_bp_blk_nr[0] = 0x00; // BLK_NR MSB
408 header->pa_lfr_bp_blk_nr[1] = blkNr; // BLK_NR LSB
414 header->pa_lfr_bp_blk_nr[1] = blkNr; // BLK_NR LSB
409 }
415 }
410
416
411 void BP_send(char *data, rtems_id queue_id, unsigned int nbBytesToSend, unsigned int sid )
417 void BP_send(char *data, rtems_id queue_id, unsigned int nbBytesToSend, unsigned int sid )
412 {
418 {
413 rtems_status_code status;
419 rtems_status_code status;
414
420
415 // SET THE SEQUENCE_CNT PARAMETER
421 // SET THE SEQUENCE_CNT PARAMETER
416 increment_seq_counter_source_id( (unsigned char*) &data[ PACKET_POS_SEQUENCE_CNT ], sid );
422 increment_seq_counter_source_id( (unsigned char*) &data[ PACKET_POS_SEQUENCE_CNT ], sid );
417 // SEND PACKET
423 // SEND PACKET
418 status = rtems_message_queue_send( queue_id, data, nbBytesToSend);
424 status = rtems_message_queue_send( queue_id, data, nbBytesToSend);
419 if (status != RTEMS_SUCCESSFUL)
425 if (status != RTEMS_SUCCESSFUL)
420 {
426 {
421 printf("ERR *** in BP_send *** ERR %d\n", (int) status);
427 printf("ERR *** in BP_send *** ERR %d\n", (int) status);
422 }
428 }
423 }
429 }
424
430
425 //******************
431 //******************
426 // general functions
432 // general functions
427
433
428 void reset_sm_status( void )
434 void reset_sm_status( void )
429 {
435 {
430 // error
436 // error
431 // 10 --------------- 9 ---------------- 8 ---------------- 7 ---------
437 // 10 --------------- 9 ---------------- 8 ---------------- 7 ---------
432 // input_fif0_write_2 input_fifo_write_1 input_fifo_write_0 buffer_full
438 // input_fif0_write_2 input_fifo_write_1 input_fifo_write_0 buffer_full
433 // ---------- 5 -- 4 -- 3 -- 2 -- 1 -- 0 --
439 // ---------- 5 -- 4 -- 3 -- 2 -- 1 -- 0 --
434 // ready bits f2_1 f2_0 f1_1 f1_1 f0_1 f0_0
440 // ready bits f2_1 f2_0 f1_1 f1_1 f0_1 f0_0
435
441
436 spectral_matrix_regs->status = 0x7ff; // [0111 1111 1111]
442 spectral_matrix_regs->status = 0x7ff; // [0111 1111 1111]
437 }
443 }
438
444
439 void reset_spectral_matrix_regs( void )
445 void reset_spectral_matrix_regs( void )
440 {
446 {
441 /** This function resets the spectral matrices module registers.
447 /** This function resets the spectral matrices module registers.
442 *
448 *
443 * The registers affected by this function are located at the following offset addresses:
449 * The registers affected by this function are located at the following offset addresses:
444 *
450 *
445 * - 0x00 config
451 * - 0x00 config
446 * - 0x04 status
452 * - 0x04 status
447 * - 0x08 matrixF0_Address0
453 * - 0x08 matrixF0_Address0
448 * - 0x10 matrixFO_Address1
454 * - 0x10 matrixFO_Address1
449 * - 0x14 matrixF1_Address
455 * - 0x14 matrixF1_Address
450 * - 0x18 matrixF2_Address
456 * - 0x18 matrixF2_Address
451 *
457 *
452 */
458 */
453
459
454 set_sm_irq_onError( 0 );
460 set_sm_irq_onError( 0 );
455
461
456 set_sm_irq_onNewMatrix( 0 );
462 set_sm_irq_onNewMatrix( 0 );
457
463
458 reset_sm_status();
464 reset_sm_status();
459
465
460 // F1
466 // F1
461 spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->previous->buffer_address;
467 spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->previous->buffer_address;
462 spectral_matrix_regs->f0_1_address = current_ring_node_sm_f0->buffer_address;
468 spectral_matrix_regs->f0_1_address = current_ring_node_sm_f0->buffer_address;
463 // F2
469 // F2
464 spectral_matrix_regs->f1_0_address = current_ring_node_sm_f1->previous->buffer_address;
470 spectral_matrix_regs->f1_0_address = current_ring_node_sm_f1->previous->buffer_address;
465 spectral_matrix_regs->f1_1_address = current_ring_node_sm_f1->buffer_address;
471 spectral_matrix_regs->f1_1_address = current_ring_node_sm_f1->buffer_address;
466 // F3
472 // F3
467 spectral_matrix_regs->f2_0_address = current_ring_node_sm_f2->previous->buffer_address;
473 spectral_matrix_regs->f2_0_address = current_ring_node_sm_f2->previous->buffer_address;
468 spectral_matrix_regs->f2_1_address = current_ring_node_sm_f2->buffer_address;
474 spectral_matrix_regs->f2_1_address = current_ring_node_sm_f2->buffer_address;
469
475
470 spectral_matrix_regs->matrix_length = 0xc8; // 25 * 128 / 16 = 200 = 0xc8
476 spectral_matrix_regs->matrix_length = 0xc8; // 25 * 128 / 16 = 200 = 0xc8
471 }
477 }
472
478
473 void set_time( unsigned char *time, unsigned char * timeInBuffer )
479 void set_time( unsigned char *time, unsigned char * timeInBuffer )
474 {
480 {
475 time[0] = timeInBuffer[0];
481 time[0] = timeInBuffer[0];
476 time[1] = timeInBuffer[1];
482 time[1] = timeInBuffer[1];
477 time[2] = timeInBuffer[2];
483 time[2] = timeInBuffer[2];
478 time[3] = timeInBuffer[3];
484 time[3] = timeInBuffer[3];
479 time[4] = timeInBuffer[6];
485 time[4] = timeInBuffer[6];
480 time[5] = timeInBuffer[7];
486 time[5] = timeInBuffer[7];
481 }
487 }
482
488
483 unsigned long long int get_acquisition_time( unsigned char *timePtr )
489 unsigned long long int get_acquisition_time( unsigned char *timePtr )
484 {
490 {
485 unsigned long long int acquisitionTimeAslong;
491 unsigned long long int acquisitionTimeAslong;
486 acquisitionTimeAslong = 0x00;
492 acquisitionTimeAslong = 0x00;
487 acquisitionTimeAslong = ( (unsigned long long int) (timePtr[0] & 0x7f) << 40 ) // [0111 1111] mask the synchronization bit
493 acquisitionTimeAslong = ( (unsigned long long int) (timePtr[0] & 0x7f) << 40 ) // [0111 1111] mask the synchronization bit
488 + ( (unsigned long long int) timePtr[1] << 32 )
494 + ( (unsigned long long int) timePtr[1] << 32 )
489 + ( (unsigned long long int) timePtr[2] << 24 )
495 + ( (unsigned long long int) timePtr[2] << 24 )
490 + ( (unsigned long long int) timePtr[3] << 16 )
496 + ( (unsigned long long int) timePtr[3] << 16 )
491 + ( (unsigned long long int) timePtr[6] << 8 )
497 + ( (unsigned long long int) timePtr[6] << 8 )
492 + ( (unsigned long long int) timePtr[7] );
498 + ( (unsigned long long int) timePtr[7] );
493 return acquisitionTimeAslong;
499 return acquisitionTimeAslong;
494 }
500 }
495
501
496 unsigned char getSID( rtems_event_set event )
502 unsigned char getSID( rtems_event_set event )
497 {
503 {
498 unsigned char sid;
504 unsigned char sid;
499
505
500 rtems_event_set eventSetBURST;
506 rtems_event_set eventSetBURST;
501 rtems_event_set eventSetSBM;
507 rtems_event_set eventSetSBM;
502
508
503 //******
509 //******
504 // BURST
510 // BURST
505 eventSetBURST = RTEMS_EVENT_BURST_BP1_F0
511 eventSetBURST = RTEMS_EVENT_BURST_BP1_F0
506 | RTEMS_EVENT_BURST_BP1_F1
512 | RTEMS_EVENT_BURST_BP1_F1
507 | RTEMS_EVENT_BURST_BP2_F0
513 | RTEMS_EVENT_BURST_BP2_F0
508 | RTEMS_EVENT_BURST_BP2_F1;
514 | RTEMS_EVENT_BURST_BP2_F1;
509
515
510 //****
516 //****
511 // SBM
517 // SBM
512 eventSetSBM = RTEMS_EVENT_SBM_BP1_F0
518 eventSetSBM = RTEMS_EVENT_SBM_BP1_F0
513 | RTEMS_EVENT_SBM_BP1_F1
519 | RTEMS_EVENT_SBM_BP1_F1
514 | RTEMS_EVENT_SBM_BP2_F0
520 | RTEMS_EVENT_SBM_BP2_F0
515 | RTEMS_EVENT_SBM_BP2_F1;
521 | RTEMS_EVENT_SBM_BP2_F1;
516
522
517 if (event & eventSetBURST)
523 if (event & eventSetBURST)
518 {
524 {
519 sid = SID_BURST_BP1_F0;
525 sid = SID_BURST_BP1_F0;
520 }
526 }
521 else if (event & eventSetSBM)
527 else if (event & eventSetSBM)
522 {
528 {
523 sid = SID_SBM1_BP1_F0;
529 sid = SID_SBM1_BP1_F0;
524 }
530 }
525 else
531 else
526 {
532 {
527 sid = 0;
533 sid = 0;
528 }
534 }
529
535
530 return sid;
536 return sid;
531 }
537 }
532
538
Show file before | Show file after | Hide comments
@@ -1,1402 +1,1402
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
32
33 bool extractSWF = false;
33 bool extractSWF = false;
34 bool swf_f0_ready = false;
34 bool swf_f0_ready = false;
35 bool swf_f1_ready = false;
35 bool swf_f1_ready = false;
36 bool swf_f2_ready = false;
36 bool swf_f2_ready = false;
37
37
38 int wf_snap_extracted[ (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK) ];
38 int wf_snap_extracted[ (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK) ];
39 ring_node ring_node_wf_snap_extracted;
39 ring_node ring_node_wf_snap_extracted;
40
40
41 //*********************
41 //*********************
42 // Interrupt SubRoutine
42 // Interrupt SubRoutine
43
43
44 ring_node * getRingNodeToSendCWF( unsigned char frequencyChannel)
44 ring_node * getRingNodeToSendCWF( unsigned char frequencyChannel)
45 {
45 {
46 ring_node *node;
46 ring_node *node;
47
47
48 node = NULL;
48 node = NULL;
49 switch ( frequencyChannel ) {
49 switch ( frequencyChannel ) {
50 case 1:
50 case 1:
51 node = ring_node_to_send_cwf_f1;
51 node = ring_node_to_send_cwf_f1;
52 break;
52 break;
53 case 2:
53 case 2:
54 node = ring_node_to_send_cwf_f2;
54 node = ring_node_to_send_cwf_f2;
55 break;
55 break;
56 case 3:
56 case 3:
57 node = ring_node_to_send_cwf_f3;
57 node = ring_node_to_send_cwf_f3;
58 break;
58 break;
59 default:
59 default:
60 break;
60 break;
61 }
61 }
62
62
63 return node;
63 return node;
64 }
64 }
65
65
66 ring_node * getRingNodeToSendSWF( unsigned char frequencyChannel)
66 ring_node * getRingNodeToSendSWF( unsigned char frequencyChannel)
67 {
67 {
68 ring_node *node;
68 ring_node *node;
69
69
70 node = NULL;
70 node = NULL;
71 switch ( frequencyChannel ) {
71 switch ( frequencyChannel ) {
72 case 0:
72 case 0:
73 node = ring_node_to_send_swf_f0;
73 node = ring_node_to_send_swf_f0;
74 break;
74 break;
75 case 1:
75 case 1:
76 node = ring_node_to_send_swf_f1;
76 node = ring_node_to_send_swf_f1;
77 break;
77 break;
78 case 2:
78 case 2:
79 node = ring_node_to_send_swf_f2;
79 node = ring_node_to_send_swf_f2;
80 break;
80 break;
81 default:
81 default:
82 break;
82 break;
83 }
83 }
84
84
85 return node;
85 return node;
86 }
86 }
87
87
88 void reset_extractSWF( void )
88 void reset_extractSWF( void )
89 {
89 {
90 extractSWF = false;
90 extractSWF = false;
91 swf_f0_ready = false;
91 swf_f0_ready = false;
92 swf_f1_ready = false;
92 swf_f1_ready = false;
93 swf_f2_ready = false;
93 swf_f2_ready = false;
94 }
94 }
95
95
96 inline void waveforms_isr_f3( void )
96 inline void waveforms_isr_f3( void )
97 {
97 {
98 rtems_status_code spare_status;
98 rtems_status_code spare_status;
99
99
100 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
100 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 || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )
101 || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )
102 { // in modes other than STANDBY and BURST, send the CWF_F3 data
102 { // in modes other than STANDBY and BURST, send the CWF_F3 data
103 //***
103 //***
104 // F3
104 // F3
105 if ( (waveform_picker_regs->status & 0xc0) != 0x00 ) { // [1100 0000] check the f3 full bits
105 if ( (waveform_picker_regs->status & 0xc0) != 0x00 ) { // [1100 0000] check the f3 full bits
106 ring_node_to_send_cwf_f3 = current_ring_node_f3->previous;
106 ring_node_to_send_cwf_f3 = current_ring_node_f3->previous;
107 current_ring_node_f3 = current_ring_node_f3->next;
107 current_ring_node_f3 = current_ring_node_f3->next;
108 if ((waveform_picker_regs->status & 0x40) == 0x40){ // [0100 0000] f3 buffer 0 is full
108 if ((waveform_picker_regs->status & 0x40) == 0x40){ // [0100 0000] f3 buffer 0 is full
109 ring_node_to_send_cwf_f3->coarseTime = waveform_picker_regs->f3_0_coarse_time;
109 ring_node_to_send_cwf_f3->coarseTime = waveform_picker_regs->f3_0_coarse_time;
110 ring_node_to_send_cwf_f3->fineTime = waveform_picker_regs->f3_0_fine_time;
110 ring_node_to_send_cwf_f3->fineTime = waveform_picker_regs->f3_0_fine_time;
111 waveform_picker_regs->addr_data_f3_0 = current_ring_node_f3->buffer_address;
111 waveform_picker_regs->addr_data_f3_0 = current_ring_node_f3->buffer_address;
112 waveform_picker_regs->status = waveform_picker_regs->status & 0x00008840; // [1000 1000 0100 0000]
112 waveform_picker_regs->status = waveform_picker_regs->status & 0x00008840; // [1000 1000 0100 0000]
113 }
113 }
114 else if ((waveform_picker_regs->status & 0x80) == 0x80){ // [1000 0000] f3 buffer 1 is full
114 else if ((waveform_picker_regs->status & 0x80) == 0x80){ // [1000 0000] f3 buffer 1 is full
115 ring_node_to_send_cwf_f3->coarseTime = waveform_picker_regs->f3_1_coarse_time;
115 ring_node_to_send_cwf_f3->coarseTime = waveform_picker_regs->f3_1_coarse_time;
116 ring_node_to_send_cwf_f3->fineTime = waveform_picker_regs->f3_1_fine_time;
116 ring_node_to_send_cwf_f3->fineTime = waveform_picker_regs->f3_1_fine_time;
117 waveform_picker_regs->addr_data_f3_1 = current_ring_node_f3->buffer_address;
117 waveform_picker_regs->addr_data_f3_1 = current_ring_node_f3->buffer_address;
118 waveform_picker_regs->status = waveform_picker_regs->status & 0x00008880; // [1000 1000 1000 0000]
118 waveform_picker_regs->status = waveform_picker_regs->status & 0x00008880; // [1000 1000 1000 0000]
119 }
119 }
120 if (rtems_event_send( Task_id[TASKID_CWF3], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
120 if (rtems_event_send( Task_id[TASKID_CWF3], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
121 spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );
121 spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );
122 }
122 }
123 rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2);
123 rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2);
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_ready_matrix_f0_x bits
207 status = (waveform_picker_regs->status & 0x30) >> 4; // [0011 0000] get the status_ready_matrix_f0_x bits
208
208
209 switch(status)
209 switch(status)
210 {
210 {
211 case 1:
211 case 1:
212 ring_node_to_send_cwf_f2 = current_ring_node_f2->previous;
212 ring_node_to_send_cwf_f2 = current_ring_node_f2->previous;
213 current_ring_node_f2 = current_ring_node_f2->next;
213 current_ring_node_f2 = current_ring_node_f2->next;
214 ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_0_coarse_time;
214 ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_0_coarse_time;
215 ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_0_fine_time;
215 ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_0_fine_time;
216 waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address;
216 waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address;
217 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]
217 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]
218 if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) {
218 if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) {
219 spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );
219 spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );
220 }
220 }
221 break;
221 break;
222 case 2:
222 case 2:
223 ring_node_to_send_cwf_f2 = current_ring_node_f2->previous;
223 ring_node_to_send_cwf_f2 = current_ring_node_f2->previous;
224 current_ring_node_f2 = current_ring_node_f2->next;
224 current_ring_node_f2 = current_ring_node_f2->next;
225 ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_1_coarse_time;
225 ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_1_coarse_time;
226 ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_1_fine_time;
226 ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_1_fine_time;
227 waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address;
227 waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address;
228 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]
228 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]
229 if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) {
229 if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) {
230 spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );
230 spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );
231 }
231 }
232 break;
232 break;
233 default:
233 default:
234 break;
234 break;
235 }
235 }
236 }
236 }
237
237
238 inline void waveforms_isr_sbm1( void )
238 inline void waveforms_isr_sbm1( void )
239 {
239 {
240 rtems_status_code status;
240 rtems_status_code status;
241
241
242 //***
242 //***
243 // F1
243 // F1
244 if ( (waveform_picker_regs->status & 0x0c) != 0x00 ) { // [0000 1100] check the f1 full bits
244 if ( (waveform_picker_regs->status & 0x0c) != 0x00 ) { // [0000 1100] check the f1 full bits
245 // (1) change the receiving buffer for the waveform picker
245 // (1) change the receiving buffer for the waveform picker
246 ring_node_to_send_cwf_f1 = current_ring_node_f1->previous;
246 ring_node_to_send_cwf_f1 = current_ring_node_f1->previous;
247 current_ring_node_f1 = current_ring_node_f1->next;
247 current_ring_node_f1 = current_ring_node_f1->next;
248 if ( (waveform_picker_regs->status & 0x04) == 0x04)
248 if ( (waveform_picker_regs->status & 0x04) == 0x04)
249 {
249 {
250 ring_node_to_send_cwf_f1->coarseTime = waveform_picker_regs->f1_0_coarse_time;
250 ring_node_to_send_cwf_f1->coarseTime = waveform_picker_regs->f1_0_coarse_time;
251 ring_node_to_send_cwf_f1->fineTime = waveform_picker_regs->f1_0_fine_time;
251 ring_node_to_send_cwf_f1->fineTime = waveform_picker_regs->f1_0_fine_time;
252 waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->buffer_address;
252 waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->buffer_address;
253 waveform_picker_regs->status = waveform_picker_regs->status & 0x00002204; // [0010 0010 0000 0100] f1 bits = 0
253 waveform_picker_regs->status = waveform_picker_regs->status & 0x00002204; // [0010 0010 0000 0100] f1 bits = 0
254 }
254 }
255 else if ( (waveform_picker_regs->status & 0x08) == 0x08)
255 else if ( (waveform_picker_regs->status & 0x08) == 0x08)
256 {
256 {
257 ring_node_to_send_cwf_f1->coarseTime = waveform_picker_regs->f1_1_coarse_time;
257 ring_node_to_send_cwf_f1->coarseTime = waveform_picker_regs->f1_1_coarse_time;
258 ring_node_to_send_cwf_f1->fineTime = waveform_picker_regs->f1_1_fine_time;
258 ring_node_to_send_cwf_f1->fineTime = waveform_picker_regs->f1_1_fine_time;
259 waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address;
259 waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address;
260 waveform_picker_regs->status = waveform_picker_regs->status & 0x00002208; // [0010 0010 0000 1000] f1 bits = 0
260 waveform_picker_regs->status = waveform_picker_regs->status & 0x00002208; // [0010 0010 0000 1000] f1 bits = 0
261 }
261 }
262 // (2) send an event for the the CWF1 task for transmission (and snapshot extraction if needed)
262 // (2) send an event for the the CWF1 task for transmission (and snapshot extraction if needed)
263 status = rtems_event_send( Task_id[TASKID_CWF1], RTEMS_EVENT_MODE_SBM1 );
263 status = rtems_event_send( Task_id[TASKID_CWF1], RTEMS_EVENT_MODE_SBM1 );
264 }
264 }
265
265
266 //***
266 //***
267 // F0
267 // F0
268 if ( (waveform_picker_regs->status & 0x03) != 0x00 ) { // [0000 0011] check the f0 full bits
268 if ( (waveform_picker_regs->status & 0x03) != 0x00 ) { // [0000 0011] check the f0 full bits
269 swf_f0_ready = true;
269 swf_f0_ready = true;
270 // change f0 buffer
270 // change f0 buffer
271 ring_node_to_send_swf_f0 = current_ring_node_f0->previous;
271 ring_node_to_send_swf_f0 = current_ring_node_f0->previous;
272 current_ring_node_f0 = current_ring_node_f0->next;
272 current_ring_node_f0 = current_ring_node_f0->next;
273 if ( (waveform_picker_regs->status & 0x01) == 0x01)
273 if ( (waveform_picker_regs->status & 0x01) == 0x01)
274 {
274 {
275
275
276 ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_0_coarse_time;
276 ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_0_coarse_time;
277 ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_0_fine_time;
277 ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_0_fine_time;
278 waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->buffer_address;
278 waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->buffer_address;
279 waveform_picker_regs->status = waveform_picker_regs->status & 0x00001101; // [0001 0001 0000 0001]
279 waveform_picker_regs->status = waveform_picker_regs->status & 0x00001101; // [0001 0001 0000 0001]
280 }
280 }
281 else if ( (waveform_picker_regs->status & 0x02) == 0x02)
281 else if ( (waveform_picker_regs->status & 0x02) == 0x02)
282 {
282 {
283 ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_1_coarse_time;
283 ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_1_coarse_time;
284 ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_1_fine_time;
284 ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_1_fine_time;
285 waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address;
285 waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address;
286 waveform_picker_regs->status = waveform_picker_regs->status & 0x00001102; // [0001 0001 0000 0010]
286 waveform_picker_regs->status = waveform_picker_regs->status & 0x00001102; // [0001 0001 0000 0010]
287 }
287 }
288 }
288 }
289
289
290 //***
290 //***
291 // F2
291 // F2
292 if ( (waveform_picker_regs->status & 0x30) != 0x00 ) { // [0011 0000] check the f2 full bits
292 if ( (waveform_picker_regs->status & 0x30) != 0x00 ) { // [0011 0000] check the f2 full bits
293 swf_f2_ready = true;
293 swf_f2_ready = true;
294 // change f2 buffer
294 // change f2 buffer
295 ring_node_to_send_swf_f2 = current_ring_node_f2->previous;
295 ring_node_to_send_swf_f2 = current_ring_node_f2->previous;
296 current_ring_node_f2 = current_ring_node_f2->next;
296 current_ring_node_f2 = current_ring_node_f2->next;
297 if ( (waveform_picker_regs->status & 0x10) == 0x10)
297 if ( (waveform_picker_regs->status & 0x10) == 0x10)
298 {
298 {
299 ring_node_to_send_swf_f2->coarseTime = waveform_picker_regs->f2_0_coarse_time;
299 ring_node_to_send_swf_f2->coarseTime = waveform_picker_regs->f2_0_coarse_time;
300 ring_node_to_send_swf_f2->fineTime = waveform_picker_regs->f2_0_fine_time;
300 ring_node_to_send_swf_f2->fineTime = waveform_picker_regs->f2_0_fine_time;
301 waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address;
301 waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address;
302 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]
302 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]
303 }
303 }
304 else if ( (waveform_picker_regs->status & 0x20) == 0x20)
304 else if ( (waveform_picker_regs->status & 0x20) == 0x20)
305 {
305 {
306 ring_node_to_send_swf_f2->coarseTime = waveform_picker_regs->f2_1_coarse_time;
306 ring_node_to_send_swf_f2->coarseTime = waveform_picker_regs->f2_1_coarse_time;
307 ring_node_to_send_swf_f2->fineTime = waveform_picker_regs->f2_1_fine_time;
307 ring_node_to_send_swf_f2->fineTime = waveform_picker_regs->f2_1_fine_time;
308 waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address;
308 waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address;
309 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]
309 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]
310 }
310 }
311 }
311 }
312 }
312 }
313
313
314 inline void waveforms_isr_sbm2( void )
314 inline void waveforms_isr_sbm2( void )
315 {
315 {
316 rtems_status_code status;
316 rtems_status_code status;
317
317
318 //***
318 //***
319 // F2
319 // F2
320 if ( (waveform_picker_regs->status & 0x30) != 0x00 ) { // [0011 0000] check the f2 full bit
320 if ( (waveform_picker_regs->status & 0x30) != 0x00 ) { // [0011 0000] check the f2 full bit
321 // (1) change the receiving buffer for the waveform picker
321 // (1) change the receiving buffer for the waveform picker
322 ring_node_to_send_cwf_f2 = current_ring_node_f2->previous;
322 ring_node_to_send_cwf_f2 = current_ring_node_f2->previous;
323 current_ring_node_f2 = current_ring_node_f2->next;
323 current_ring_node_f2 = current_ring_node_f2->next;
324 if ( (waveform_picker_regs->status & 0x10) == 0x10)
324 if ( (waveform_picker_regs->status & 0x10) == 0x10)
325 {
325 {
326 ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_0_coarse_time;
326 ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_0_coarse_time;
327 ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_0_fine_time;
327 ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_0_fine_time;
328 waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address;
328 waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address;
329 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]
329 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]
330 }
330 }
331 else if ( (waveform_picker_regs->status & 0x20) == 0x20)
331 else if ( (waveform_picker_regs->status & 0x20) == 0x20)
332 {
332 {
333 ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_1_coarse_time;
333 ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_1_coarse_time;
334 ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_1_fine_time;
334 ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_1_fine_time;
335 waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address;
335 waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address;
336 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]
336 waveform_picker_regs->status = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]
337 }
337 }
338 // (2) send an event for the waveforms transmission
338 // (2) send an event for the waveforms transmission
339 status = rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_SBM2 );
339 status = rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_SBM2 );
340 }
340 }
341
341
342 //***
342 //***
343 // F0
343 // F0
344 if ( (waveform_picker_regs->status & 0x03) != 0x00 ) { // [0000 0011] check the f0 full bit
344 if ( (waveform_picker_regs->status & 0x03) != 0x00 ) { // [0000 0011] check the f0 full bit
345 swf_f0_ready = true;
345 swf_f0_ready = true;
346 // change f0 buffer
346 // change f0 buffer
347 ring_node_to_send_swf_f0 = current_ring_node_f0->previous;
347 ring_node_to_send_swf_f0 = current_ring_node_f0->previous;
348 current_ring_node_f0 = current_ring_node_f0->next;
348 current_ring_node_f0 = current_ring_node_f0->next;
349 if ( (waveform_picker_regs->status & 0x01) == 0x01)
349 if ( (waveform_picker_regs->status & 0x01) == 0x01)
350 {
350 {
351
351
352 ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_0_coarse_time;
352 ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_0_coarse_time;
353 ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_0_fine_time;
353 ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_0_fine_time;
354 waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->buffer_address;
354 waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->buffer_address;
355 waveform_picker_regs->status = waveform_picker_regs->status & 0x00001101; // [0001 0001 0000 0001]
355 waveform_picker_regs->status = waveform_picker_regs->status & 0x00001101; // [0001 0001 0000 0001]
356 }
356 }
357 else if ( (waveform_picker_regs->status & 0x02) == 0x02)
357 else if ( (waveform_picker_regs->status & 0x02) == 0x02)
358 {
358 {
359 ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_1_coarse_time;
359 ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_1_coarse_time;
360 ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_1_fine_time;
360 ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_1_fine_time;
361 waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address;
361 waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address;
362 waveform_picker_regs->status = waveform_picker_regs->status & 0x00001102; // [0001 0001 0000 0010]
362 waveform_picker_regs->status = waveform_picker_regs->status & 0x00001102; // [0001 0001 0000 0010]
363 }
363 }
364 }
364 }
365
365
366 //***
366 //***
367 // F1
367 // F1
368 if ( (waveform_picker_regs->status & 0x0c) != 0x00 ) { // [0000 1100] check the f1 full bit
368 if ( (waveform_picker_regs->status & 0x0c) != 0x00 ) { // [0000 1100] check the f1 full bit
369 swf_f1_ready = true;
369 swf_f1_ready = true;
370 ring_node_to_send_swf_f1 = current_ring_node_f1->previous;
370 ring_node_to_send_swf_f1 = current_ring_node_f1->previous;
371 current_ring_node_f1 = current_ring_node_f1->next;
371 current_ring_node_f1 = current_ring_node_f1->next;
372 if ( (waveform_picker_regs->status & 0x04) == 0x04)
372 if ( (waveform_picker_regs->status & 0x04) == 0x04)
373 {
373 {
374 ring_node_to_send_swf_f1->coarseTime = waveform_picker_regs->f1_0_coarse_time;
374 ring_node_to_send_swf_f1->coarseTime = waveform_picker_regs->f1_0_coarse_time;
375 ring_node_to_send_swf_f1->fineTime = waveform_picker_regs->f1_0_fine_time;
375 ring_node_to_send_swf_f1->fineTime = waveform_picker_regs->f1_0_fine_time;
376 waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->buffer_address;
376 waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->buffer_address;
377 waveform_picker_regs->status = waveform_picker_regs->status & 0x00002204; // [0010 0010 0000 0100] f1 bits = 0
377 waveform_picker_regs->status = waveform_picker_regs->status & 0x00002204; // [0010 0010 0000 0100] f1 bits = 0
378 }
378 }
379 else if ( (waveform_picker_regs->status & 0x08) == 0x08)
379 else if ( (waveform_picker_regs->status & 0x08) == 0x08)
380 {
380 {
381 ring_node_to_send_swf_f1->coarseTime = waveform_picker_regs->f1_1_coarse_time;
381 ring_node_to_send_swf_f1->coarseTime = waveform_picker_regs->f1_1_coarse_time;
382 ring_node_to_send_swf_f1->fineTime = waveform_picker_regs->f1_1_fine_time;
382 ring_node_to_send_swf_f1->fineTime = waveform_picker_regs->f1_1_fine_time;
383 waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address;
383 waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address;
384 waveform_picker_regs->status = waveform_picker_regs->status & 0x00002208; // [0010 0010 0000 1000] f1 bits = 0
384 waveform_picker_regs->status = waveform_picker_regs->status & 0x00002208; // [0010 0010 0000 1000] f1 bits = 0
385 }
385 }
386 }
386 }
387 }
387 }
388
388
389 rtems_isr waveforms_isr( rtems_vector_number vector )
389 rtems_isr waveforms_isr( rtems_vector_number vector )
390 {
390 {
391 /** This is the interrupt sub routine called by the waveform picker core.
391 /** This is the interrupt sub routine called by the waveform picker core.
392 *
392 *
393 * This ISR launch different actions depending mainly on two pieces of information:
393 * This ISR launch different actions depending mainly on two pieces of information:
394 * 1. the values read in the registers of the waveform picker.
394 * 1. the values read in the registers of the waveform picker.
395 * 2. the current LFR mode.
395 * 2. the current LFR mode.
396 *
396 *
397 */
397 */
398
398
399 // STATUS
399 // STATUS
400 // new error error buffer full
400 // new error error buffer full
401 // 15 14 13 12 11 10 9 8
401 // 15 14 13 12 11 10 9 8
402 // f3 f2 f1 f0 f3 f2 f1 f0
402 // f3 f2 f1 f0 f3 f2 f1 f0
403 //
403 //
404 // ready buffer
404 // ready buffer
405 // 7 6 5 4 3 2 1 0
405 // 7 6 5 4 3 2 1 0
406 // f3_1 f3_0 f2_1 f2_0 f1_1 f1_0 f0_1 f0_0
406 // f3_1 f3_0 f2_1 f2_0 f1_1 f1_0 f0_1 f0_0
407
407
408 rtems_status_code spare_status;
408 rtems_status_code spare_status;
409
409
410 waveforms_isr_f3();
410 waveforms_isr_f3();
411
411
412 if ( (waveform_picker_regs->status & 0xff00) != 0x00) // [1111 1111 0000 0000] check the error bits
412 if ( (waveform_picker_regs->status & 0xff00) != 0x00) // [1111 1111 0000 0000] check the error bits
413 {
413 {
414 spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_10 );
414 spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_10 );
415 }
415 }
416
416
417 switch(lfrCurrentMode)
417 switch(lfrCurrentMode)
418 {
418 {
419 //********
419 //********
420 // STANDBY
420 // STANDBY
421 case(LFR_MODE_STANDBY):
421 case(LFR_MODE_STANDBY):
422 break;
422 break;
423
423
424 //******
424 //******
425 // NORMAL
425 // NORMAL
426 case(LFR_MODE_NORMAL):
426 case(LFR_MODE_NORMAL):
427 waveforms_isr_normal();
427 waveforms_isr_normal();
428 break;
428 break;
429
429
430 //******
430 //******
431 // BURST
431 // BURST
432 case(LFR_MODE_BURST):
432 case(LFR_MODE_BURST):
433 waveforms_isr_burst();
433 waveforms_isr_burst();
434 break;
434 break;
435
435
436 //*****
436 //*****
437 // SBM1
437 // SBM1
438 case(LFR_MODE_SBM1):
438 case(LFR_MODE_SBM1):
439 waveforms_isr_sbm1();
439 waveforms_isr_sbm1();
440 break;
440 break;
441
441
442 //*****
442 //*****
443 // SBM2
443 // SBM2
444 case(LFR_MODE_SBM2):
444 case(LFR_MODE_SBM2):
445 waveforms_isr_sbm2();
445 waveforms_isr_sbm2();
446 break;
446 break;
447
447
448 //********
448 //********
449 // DEFAULT
449 // DEFAULT
450 default:
450 default:
451 break;
451 break;
452 }
452 }
453 }
453 }
454
454
455 //************
455 //************
456 // RTEMS TASKS
456 // RTEMS TASKS
457
457
458 rtems_task wfrm_task(rtems_task_argument argument) //used with the waveform picker VHDL IP
458 rtems_task wfrm_task(rtems_task_argument argument) //used with the waveform picker VHDL IP
459 {
459 {
460 /** This RTEMS task is dedicated to the transmission of snapshots of the NORMAL mode.
460 /** This RTEMS task is dedicated to the transmission of snapshots of the NORMAL mode.
461 *
461 *
462 * @param unused is the starting argument of the RTEMS task
462 * @param unused is the starting argument of the RTEMS task
463 *
463 *
464 * The following data packets are sent by this task:
464 * The following data packets are sent by this task:
465 * - TM_LFR_SCIENCE_NORMAL_SWF_F0
465 * - TM_LFR_SCIENCE_NORMAL_SWF_F0
466 * - TM_LFR_SCIENCE_NORMAL_SWF_F1
466 * - TM_LFR_SCIENCE_NORMAL_SWF_F1
467 * - TM_LFR_SCIENCE_NORMAL_SWF_F2
467 * - TM_LFR_SCIENCE_NORMAL_SWF_F2
468 *
468 *
469 */
469 */
470
470
471 rtems_event_set event_out;
471 rtems_event_set event_out;
472 rtems_id queue_id;
472 rtems_id queue_id;
473 rtems_status_code status;
473 rtems_status_code status;
474 bool resynchronisationEngaged;
474 bool resynchronisationEngaged;
475 ring_node *ring_node_wf_snap_extracted_ptr;
475 ring_node *ring_node_wf_snap_extracted_ptr;
476
476
477 ring_node_wf_snap_extracted_ptr = (ring_node *) &ring_node_wf_snap_extracted;
477 ring_node_wf_snap_extracted_ptr = (ring_node *) &ring_node_wf_snap_extracted;
478
478
479 resynchronisationEngaged = false;
479 resynchronisationEngaged = false;
480
480
481 status = get_message_queue_id_send( &queue_id );
481 status = get_message_queue_id_send( &queue_id );
482 if (status != RTEMS_SUCCESSFUL)
482 if (status != RTEMS_SUCCESSFUL)
483 {
483 {
484 PRINTF1("in WFRM *** ERR get_message_queue_id_send %d\n", status)
484 PRINTF1("in WFRM *** ERR get_message_queue_id_send %d\n", status)
485 }
485 }
486
486
487 BOOT_PRINTF("in WFRM ***\n")
487 BOOT_PRINTF("in WFRM ***\n")
488
488
489 while(1){
489 while(1){
490 // wait for an RTEMS_EVENT
490 // wait for an RTEMS_EVENT
491 rtems_event_receive(RTEMS_EVENT_MODE_NORMAL | RTEMS_EVENT_MODE_SBM1
491 rtems_event_receive(RTEMS_EVENT_MODE_NORMAL | RTEMS_EVENT_MODE_SBM1
492 | RTEMS_EVENT_MODE_SBM2 | RTEMS_EVENT_MODE_SBM2_WFRM,
492 | RTEMS_EVENT_MODE_SBM2 | RTEMS_EVENT_MODE_SBM2_WFRM,
493 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
493 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
494 if(resynchronisationEngaged == false)
494 if(resynchronisationEngaged == false)
495 { // engage resynchronisation
495 { // engage resynchronisation
496 snapshot_resynchronization( (unsigned char *) &ring_node_to_send_swf_f0->coarseTime );
496 snapshot_resynchronization( (unsigned char *) &ring_node_to_send_swf_f0->coarseTime );
497 resynchronisationEngaged = true;
497 resynchronisationEngaged = true;
498 }
498 }
499 else
499 else
500 { // reset delta_snapshot to the nominal value
500 { // reset delta_snapshot to the nominal value
501 PRINTF("no resynchronisation, reset delta_snapshot to the nominal value\n")
501 PRINTF("no resynchronisation, reset delta_snapshot to the nominal value\n")
502 set_wfp_delta_snapshot();
502 set_wfp_delta_snapshot();
503 resynchronisationEngaged = false;
503 resynchronisationEngaged = false;
504 }
504 }
505 //
505 //
506
506
507 if (event_out == RTEMS_EVENT_MODE_NORMAL)
507 if (event_out == RTEMS_EVENT_MODE_NORMAL)
508 {
508 {
509 DEBUG_PRINTF("WFRM received RTEMS_EVENT_MODE_NORMAL\n")
509 DEBUG_PRINTF("WFRM received RTEMS_EVENT_MODE_NORMAL\n")
510 ring_node_to_send_swf_f0->sid = SID_NORM_SWF_F0;
510 ring_node_to_send_swf_f0->sid = SID_NORM_SWF_F0;
511 ring_node_to_send_swf_f1->sid = SID_NORM_SWF_F1;
511 ring_node_to_send_swf_f1->sid = SID_NORM_SWF_F1;
512 ring_node_to_send_swf_f2->sid = SID_NORM_SWF_F2;
512 ring_node_to_send_swf_f2->sid = SID_NORM_SWF_F2;
513 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f0, sizeof( ring_node* ) );
513 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f0, sizeof( ring_node* ) );
514 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f1, sizeof( ring_node* ) );
514 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f1, sizeof( ring_node* ) );
515 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f2, sizeof( ring_node* ) );
515 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f2, sizeof( ring_node* ) );
516 }
516 }
517 if (event_out == RTEMS_EVENT_MODE_SBM1)
517 if (event_out == RTEMS_EVENT_MODE_SBM1)
518 {
518 {
519 DEBUG_PRINTF("WFRM received RTEMS_EVENT_MODE_SBM1\n")
519 DEBUG_PRINTF("WFRM received RTEMS_EVENT_MODE_SBM1\n")
520 ring_node_to_send_swf_f0->sid = SID_NORM_SWF_F0;
520 ring_node_to_send_swf_f0->sid = SID_NORM_SWF_F0;
521 ring_node_wf_snap_extracted_ptr->sid = SID_NORM_SWF_F1;
521 ring_node_wf_snap_extracted_ptr->sid = SID_NORM_SWF_F1;
522 ring_node_to_send_swf_f2->sid = SID_NORM_SWF_F2;
522 ring_node_to_send_swf_f2->sid = SID_NORM_SWF_F2;
523 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f0, sizeof( ring_node* ) );
523 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f0, sizeof( ring_node* ) );
524 status = rtems_message_queue_send( queue_id, &ring_node_wf_snap_extracted_ptr, sizeof( ring_node* ) );
524 status = rtems_message_queue_send( queue_id, &ring_node_wf_snap_extracted_ptr, sizeof( ring_node* ) );
525 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f2, sizeof( ring_node* ) );
525 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f2, sizeof( ring_node* ) );
526 }
526 }
527 if (event_out == RTEMS_EVENT_MODE_SBM2)
527 if (event_out == RTEMS_EVENT_MODE_SBM2)
528 {
528 {
529 DEBUG_PRINTF("WFRM received RTEMS_EVENT_MODE_SBM2\n")
529 DEBUG_PRINTF("WFRM received RTEMS_EVENT_MODE_SBM2\n")
530 ring_node_to_send_swf_f0->sid = SID_NORM_SWF_F0;
530 ring_node_to_send_swf_f0->sid = SID_NORM_SWF_F0;
531 ring_node_to_send_swf_f1->sid = SID_NORM_SWF_F1;
531 ring_node_to_send_swf_f1->sid = SID_NORM_SWF_F1;
532 ring_node_wf_snap_extracted_ptr->sid = SID_NORM_SWF_F2;
532 ring_node_wf_snap_extracted_ptr->sid = SID_NORM_SWF_F2;
533 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f0, sizeof( ring_node* ) );
533 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f0, sizeof( ring_node* ) );
534 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f1, sizeof( ring_node* ) );
534 status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f1, sizeof( ring_node* ) );
535 status = rtems_message_queue_send( queue_id, &ring_node_wf_snap_extracted_ptr, sizeof( ring_node* ) );
535 status = rtems_message_queue_send( queue_id, &ring_node_wf_snap_extracted_ptr, sizeof( ring_node* ) );
536 }
536 }
537 }
537 }
538 }
538 }
539
539
540 rtems_task cwf3_task(rtems_task_argument argument) //used with the waveform picker VHDL IP
540 rtems_task cwf3_task(rtems_task_argument argument) //used with the waveform picker VHDL IP
541 {
541 {
542 /** This RTEMS task is dedicated to the transmission of continuous waveforms at f3.
542 /** This RTEMS task is dedicated to the transmission of continuous waveforms at f3.
543 *
543 *
544 * @param unused is the starting argument of the RTEMS task
544 * @param unused is the starting argument of the RTEMS task
545 *
545 *
546 * The following data packet is sent by this task:
546 * The following data packet is sent by this task:
547 * - TM_LFR_SCIENCE_NORMAL_CWF_F3
547 * - TM_LFR_SCIENCE_NORMAL_CWF_F3
548 *
548 *
549 */
549 */
550
550
551 rtems_event_set event_out;
551 rtems_event_set event_out;
552 rtems_id queue_id;
552 rtems_id queue_id;
553 rtems_status_code status;
553 rtems_status_code status;
554 ring_node ring_node_cwf3_light;
554 ring_node ring_node_cwf3_light;
555
555
556 status = get_message_queue_id_send( &queue_id );
556 status = get_message_queue_id_send( &queue_id );
557 if (status != RTEMS_SUCCESSFUL)
557 if (status != RTEMS_SUCCESSFUL)
558 {
558 {
559 PRINTF1("in CWF3 *** ERR get_message_queue_id_send %d\n", status)
559 PRINTF1("in CWF3 *** ERR get_message_queue_id_send %d\n", status)
560 }
560 }
561
561
562 ring_node_to_send_cwf_f3->sid = SID_NORM_CWF_LONG_F3;
562 ring_node_to_send_cwf_f3->sid = SID_NORM_CWF_LONG_F3;
563
563
564 // init the ring_node_cwf3_light structure
564 // init the ring_node_cwf3_light structure
565 ring_node_cwf3_light.buffer_address = (int) wf_cont_f3_light;
565 ring_node_cwf3_light.buffer_address = (int) wf_cont_f3_light;
566 ring_node_cwf3_light.coarseTime = 0x00;
566 ring_node_cwf3_light.coarseTime = 0x00;
567 ring_node_cwf3_light.fineTime = 0x00;
567 ring_node_cwf3_light.fineTime = 0x00;
568 ring_node_cwf3_light.next = NULL;
568 ring_node_cwf3_light.next = NULL;
569 ring_node_cwf3_light.previous = NULL;
569 ring_node_cwf3_light.previous = NULL;
570 ring_node_cwf3_light.sid = SID_NORM_CWF_F3;
570 ring_node_cwf3_light.sid = SID_NORM_CWF_F3;
571 ring_node_cwf3_light.status = 0x00;
571 ring_node_cwf3_light.status = 0x00;
572
572
573 BOOT_PRINTF("in CWF3 ***\n")
573 BOOT_PRINTF("in CWF3 ***\n")
574
574
575 while(1){
575 while(1){
576 // wait for an RTEMS_EVENT
576 // wait for an RTEMS_EVENT
577 rtems_event_receive( RTEMS_EVENT_0,
577 rtems_event_receive( RTEMS_EVENT_0,
578 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
578 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
579 if ( (lfrCurrentMode == LFR_MODE_NORMAL)
579 if ( (lfrCurrentMode == LFR_MODE_NORMAL)
580 || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode==LFR_MODE_SBM2) )
580 || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode==LFR_MODE_SBM2) )
581 {
581 {
582 if ( (parameter_dump_packet.sy_lfr_n_cwf_long_f3 & 0x01) == 0x01)
582 if ( (parameter_dump_packet.sy_lfr_n_cwf_long_f3 & 0x01) == 0x01)
583 {
583 {
584 PRINTF("send CWF_LONG_F3\n")
584 PRINTF("send CWF_LONG_F3\n")
585 ring_node_to_send_cwf_f3->sid = SID_NORM_CWF_LONG_F3;
585 ring_node_to_send_cwf_f3->sid = SID_NORM_CWF_LONG_F3;
586 status = rtems_message_queue_send( queue_id, &ring_node_to_send_cwf_f3, sizeof( ring_node* ) );
586 status = rtems_message_queue_send( queue_id, &ring_node_to_send_cwf_f3, sizeof( ring_node* ) );
587 }
587 }
588 else
588 else
589 {
589 {
590 PRINTF("send CWF_F3 (light)\n")
590 PRINTF("send CWF_F3 (light)\n")
591 send_waveform_CWF3_light( ring_node_to_send_cwf_f3, &ring_node_cwf3_light, queue_id );
591 send_waveform_CWF3_light( ring_node_to_send_cwf_f3, &ring_node_cwf3_light, queue_id );
592 }
592 }
593
593
594 }
594 }
595 else
595 else
596 {
596 {
597 PRINTF1("in CWF3 *** lfrCurrentMode is %d, no data will be sent\n", lfrCurrentMode)
597 PRINTF1("in CWF3 *** lfrCurrentMode is %d, no data will be sent\n", lfrCurrentMode)
598 }
598 }
599 }
599 }
600 }
600 }
601
601
602 rtems_task cwf2_task(rtems_task_argument argument) // ONLY USED IN BURST AND SBM2
602 rtems_task cwf2_task(rtems_task_argument argument) // ONLY USED IN BURST AND SBM2
603 {
603 {
604 /** This RTEMS task is dedicated to the transmission of continuous waveforms at f2.
604 /** This RTEMS task is dedicated to the transmission of continuous waveforms at f2.
605 *
605 *
606 * @param unused is the starting argument of the RTEMS task
606 * @param unused is the starting argument of the RTEMS task
607 *
607 *
608 * The following data packet is sent by this function:
608 * The following data packet is sent by this function:
609 * - TM_LFR_SCIENCE_BURST_CWF_F2
609 * - TM_LFR_SCIENCE_BURST_CWF_F2
610 * - TM_LFR_SCIENCE_SBM2_CWF_F2
610 * - TM_LFR_SCIENCE_SBM2_CWF_F2
611 *
611 *
612 */
612 */
613
613
614 rtems_event_set event_out;
614 rtems_event_set event_out;
615 rtems_id queue_id;
615 rtems_id queue_id;
616 rtems_status_code status;
616 rtems_status_code status;
617 ring_node *ring_node_to_send;
617 ring_node *ring_node_to_send;
618
618
619 status = get_message_queue_id_send( &queue_id );
619 status = get_message_queue_id_send( &queue_id );
620 if (status != RTEMS_SUCCESSFUL)
620 if (status != RTEMS_SUCCESSFUL)
621 {
621 {
622 PRINTF1("in CWF2 *** ERR get_message_queue_id_send %d\n", status)
622 PRINTF1("in CWF2 *** ERR get_message_queue_id_send %d\n", status)
623 }
623 }
624
624
625 BOOT_PRINTF("in CWF2 ***\n")
625 BOOT_PRINTF("in CWF2 ***\n")
626
626
627 while(1){
627 while(1){
628 // wait for an RTEMS_EVENT
628 // wait for an RTEMS_EVENT
629 rtems_event_receive( RTEMS_EVENT_MODE_BURST | RTEMS_EVENT_MODE_SBM2,
629 rtems_event_receive( RTEMS_EVENT_MODE_BURST | RTEMS_EVENT_MODE_SBM2,
630 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
630 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
631 ring_node_to_send = getRingNodeToSendCWF( 2 );
631 ring_node_to_send = getRingNodeToSendCWF( 2 );
632 printf("ring_node_to_send_cwf === coarse = %x, fine = %x\n", ring_node_to_send->coarseTime, ring_node_to_send->fineTime);
632 printf("ring_node_to_send_cwf === coarse = %x, fine = %x\n", ring_node_to_send->coarseTime, ring_node_to_send->fineTime);
633 printf("**0** %x . %x", waveform_ring_f2[0].coarseTime, waveform_ring_f2[0].fineTime);
633 printf("**0** %x . %x", waveform_ring_f2[0].coarseTime, waveform_ring_f2[0].fineTime);
634 printf(" **1** %x . %x", waveform_ring_f2[1].coarseTime, waveform_ring_f2[1].fineTime);
634 printf(" **1** %x . %x", waveform_ring_f2[1].coarseTime, waveform_ring_f2[1].fineTime);
635 printf(" **2** %x . %x", waveform_ring_f2[2].coarseTime, waveform_ring_f2[2].fineTime);
635 printf(" **2** %x . %x", waveform_ring_f2[2].coarseTime, waveform_ring_f2[2].fineTime);
636 printf(" **3** %x . %x", waveform_ring_f2[3].coarseTime, waveform_ring_f2[3].fineTime);
636 printf(" **3** %x . %x", waveform_ring_f2[3].coarseTime, waveform_ring_f2[3].fineTime);
637 printf(" **4** %x . %x\n", waveform_ring_f2[4].coarseTime, waveform_ring_f2[4].fineTime);
637 printf(" **4** %x . %x\n", waveform_ring_f2[4].coarseTime, waveform_ring_f2[4].fineTime);
638 if (event_out == RTEMS_EVENT_MODE_BURST)
638 if (event_out == RTEMS_EVENT_MODE_BURST)
639 {
639 {
640 ring_node_to_send->sid = SID_BURST_CWF_F2;
640 ring_node_to_send->sid = SID_BURST_CWF_F2;
641 status = rtems_message_queue_send( queue_id, &ring_node_to_send, sizeof( ring_node* ) );
641 status = rtems_message_queue_send( queue_id, &ring_node_to_send, sizeof( ring_node* ) );
642 }
642 }
643 if (event_out == RTEMS_EVENT_MODE_SBM2)
643 if (event_out == RTEMS_EVENT_MODE_SBM2)
644 {
644 {
645 ring_node_to_send->sid = SID_SBM2_CWF_F2;
645 ring_node_to_send->sid = SID_SBM2_CWF_F2;
646 status = rtems_message_queue_send( queue_id, &ring_node_to_send, sizeof( ring_node* ) );
646 status = rtems_message_queue_send( queue_id, &ring_node_to_send, sizeof( ring_node* ) );
647 // launch snapshot extraction if needed
647 // launch snapshot extraction if needed
648 if (extractSWF == true)
648 if (extractSWF == true)
649 {
649 {
650 ring_node_to_send_swf_f2 = ring_node_to_send;
650 ring_node_to_send_swf_f2 = ring_node_to_send;
651 // extract the snapshot
651 // extract the snapshot
652 build_snapshot_from_ring( ring_node_to_send_swf_f2, 2 );
652 build_snapshot_from_ring( ring_node_to_send_swf_f2, 2 );
653 // send the snapshot when built
653 // send the snapshot when built
654 status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_SBM2 );
654 status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_SBM2 );
655 extractSWF = false;
655 extractSWF = false;
656 }
656 }
657 if (swf_f0_ready && swf_f1_ready)
657 if (swf_f0_ready && swf_f1_ready)
658 {
658 {
659 extractSWF = true;
659 extractSWF = true;
660 swf_f0_ready = false;
660 swf_f0_ready = false;
661 swf_f1_ready = false;
661 swf_f1_ready = false;
662 }
662 }
663 }
663 }
664 }
664 }
665 }
665 }
666
666
667 rtems_task cwf1_task(rtems_task_argument argument) // ONLY USED IN SBM1
667 rtems_task cwf1_task(rtems_task_argument argument) // ONLY USED IN SBM1
668 {
668 {
669 /** This RTEMS task is dedicated to the transmission of continuous waveforms at f1.
669 /** This RTEMS task is dedicated to the transmission of continuous waveforms at f1.
670 *
670 *
671 * @param unused is the starting argument of the RTEMS task
671 * @param unused is the starting argument of the RTEMS task
672 *
672 *
673 * The following data packet is sent by this function:
673 * The following data packet is sent by this function:
674 * - TM_LFR_SCIENCE_SBM1_CWF_F1
674 * - TM_LFR_SCIENCE_SBM1_CWF_F1
675 *
675 *
676 */
676 */
677
677
678 rtems_event_set event_out;
678 rtems_event_set event_out;
679 rtems_id queue_id;
679 rtems_id queue_id;
680 rtems_status_code status;
680 rtems_status_code status;
681
681
682 ring_node * ring_node_to_send_cwf;
682 ring_node * ring_node_to_send_cwf;
683
683
684 status = get_message_queue_id_send( &queue_id );
684 status = get_message_queue_id_send( &queue_id );
685 if (status != RTEMS_SUCCESSFUL)
685 if (status != RTEMS_SUCCESSFUL)
686 {
686 {
687 PRINTF1("in CWF1 *** ERR get_message_queue_id_send %d\n", status)
687 PRINTF1("in CWF1 *** ERR get_message_queue_id_send %d\n", status)
688 }
688 }
689
689
690 BOOT_PRINTF("in CWF1 ***\n")
690 BOOT_PRINTF("in CWF1 ***\n")
691
691
692 while(1){
692 while(1){
693 // wait for an RTEMS_EVENT
693 // wait for an RTEMS_EVENT
694 rtems_event_receive( RTEMS_EVENT_MODE_SBM1,
694 rtems_event_receive( RTEMS_EVENT_MODE_SBM1,
695 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
695 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
696 ring_node_to_send_cwf = getRingNodeToSendCWF( 1 );
696 ring_node_to_send_cwf = getRingNodeToSendCWF( 1 );
697 printf("ring_node_to_send_cwf === coarse = %x, fine = %x\n", ring_node_to_send_cwf->coarseTime, ring_node_to_send_cwf->fineTime);
697 printf("ring_node_to_send_cwf === coarse = %x, fine = %x\n", ring_node_to_send_cwf->coarseTime, ring_node_to_send_cwf->fineTime);
698 printf("**0** %x . %x", waveform_ring_f1[0].coarseTime, waveform_ring_f1[0].fineTime);
698 printf("**0** %x . %x", waveform_ring_f1[0].coarseTime, waveform_ring_f1[0].fineTime);
699 printf(" **1** %x . %x", waveform_ring_f1[1].coarseTime, waveform_ring_f1[1].fineTime);
699 printf(" **1** %x . %x", waveform_ring_f1[1].coarseTime, waveform_ring_f1[1].fineTime);
700 printf(" **2** %x . %x", waveform_ring_f1[2].coarseTime, waveform_ring_f1[2].fineTime);
700 printf(" **2** %x . %x", waveform_ring_f1[2].coarseTime, waveform_ring_f1[2].fineTime);
701 printf(" **3** %x . %x", waveform_ring_f1[3].coarseTime, waveform_ring_f1[3].fineTime);
701 printf(" **3** %x . %x", waveform_ring_f1[3].coarseTime, waveform_ring_f1[3].fineTime);
702 printf(" **4** %x . %x\n\n", waveform_ring_f1[4].coarseTime, waveform_ring_f1[4].fineTime);
702 printf(" **4** %x . %x\n\n", waveform_ring_f1[4].coarseTime, waveform_ring_f1[4].fineTime);
703 ring_node_to_send_cwf_f1->sid = SID_SBM1_CWF_F1;
703 ring_node_to_send_cwf_f1->sid = SID_SBM1_CWF_F1;
704 status = rtems_message_queue_send( queue_id, &ring_node_to_send_cwf, sizeof( ring_node* ) );
704 status = rtems_message_queue_send( queue_id, &ring_node_to_send_cwf, sizeof( ring_node* ) );
705 // launch snapshot extraction if needed
705 // launch snapshot extraction if needed
706 if (extractSWF == true)
706 if (extractSWF == true)
707 {
707 {
708 ring_node_to_send_swf_f1 = ring_node_to_send_cwf;
708 ring_node_to_send_swf_f1 = ring_node_to_send_cwf;
709 // launch the snapshot extraction
709 // launch the snapshot extraction
710 status = rtems_event_send( Task_id[TASKID_SWBD], RTEMS_EVENT_MODE_SBM1 );
710 status = rtems_event_send( Task_id[TASKID_SWBD], RTEMS_EVENT_MODE_SBM1 );
711 extractSWF = false;
711 extractSWF = false;
712 }
712 }
713 if (swf_f0_ready == true)
713 if (swf_f0_ready == true)
714 {
714 {
715 extractSWF = true;
715 extractSWF = true;
716 swf_f0_ready = false; // this step shall be executed only one time
716 swf_f0_ready = false; // this step shall be executed only one time
717 }
717 }
718 if ((swf_f1_ready == true) && (swf_f2_ready == true)) // swf_f1 is ready after the extraction
718 if ((swf_f1_ready == true) && (swf_f2_ready == true)) // swf_f1 is ready after the extraction
719 {
719 {
720 status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_SBM1 );
720 status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_SBM1 );
721 swf_f1_ready = false;
721 swf_f1_ready = false;
722 swf_f2_ready = false;
722 swf_f2_ready = false;
723 }
723 }
724 }
724 }
725 }
725 }
726
726
727 rtems_task swbd_task(rtems_task_argument argument)
727 rtems_task swbd_task(rtems_task_argument argument)
728 {
728 {
729 /** This RTEMS task is dedicated to the building of snapshots from different continuous waveforms buffers.
729 /** This RTEMS task is dedicated to the building of snapshots from different continuous waveforms buffers.
730 *
730 *
731 * @param unused is the starting argument of the RTEMS task
731 * @param unused is the starting argument of the RTEMS task
732 *
732 *
733 */
733 */
734
734
735 rtems_event_set event_out;
735 rtems_event_set event_out;
736
736
737 BOOT_PRINTF("in SWBD ***\n")
737 BOOT_PRINTF("in SWBD ***\n")
738
738
739 while(1){
739 while(1){
740 // wait for an RTEMS_EVENT
740 // wait for an RTEMS_EVENT
741 rtems_event_receive( RTEMS_EVENT_MODE_SBM1 | RTEMS_EVENT_MODE_SBM2,
741 rtems_event_receive( RTEMS_EVENT_MODE_SBM1 | RTEMS_EVENT_MODE_SBM2,
742 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
742 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
743 if (event_out == RTEMS_EVENT_MODE_SBM1)
743 if (event_out == RTEMS_EVENT_MODE_SBM1)
744 {
744 {
745 build_snapshot_from_ring( ring_node_to_send_swf_f1, 1 );
745 build_snapshot_from_ring( ring_node_to_send_swf_f1, 1 );
746 swf_f1_ready = true; // the snapshot has been extracted and is ready to be sent
746 swf_f1_ready = true; // the snapshot has been extracted and is ready to be sent
747 }
747 }
748 else
748 else
749 {
749 {
750 PRINTF1("in SWBD *** unexpected rtems event received %x\n", (int) event_out)
750 PRINTF1("in SWBD *** unexpected rtems event received %x\n", (int) event_out)
751 }
751 }
752 }
752 }
753 }
753 }
754
754
755 //******************
755 //******************
756 // general functions
756 // general functions
757
757
758 void WFP_init_rings( void )
758 void WFP_init_rings( void )
759 {
759 {
760 // F0 RING
760 // F0 RING
761 init_ring( waveform_ring_f0, NB_RING_NODES_F0, wf_buffer_f0, WFRM_BUFFER );
761 init_ring( waveform_ring_f0, NB_RING_NODES_F0, wf_buffer_f0, WFRM_BUFFER );
762 // F1 RING
762 // F1 RING
763 init_ring( waveform_ring_f1, NB_RING_NODES_F1, wf_buffer_f1, WFRM_BUFFER );
763 init_ring( waveform_ring_f1, NB_RING_NODES_F1, wf_buffer_f1, WFRM_BUFFER );
764 // F2 RING
764 // F2 RING
765 init_ring( waveform_ring_f2, NB_RING_NODES_F2, wf_buffer_f2, WFRM_BUFFER );
765 init_ring( waveform_ring_f2, NB_RING_NODES_F2, wf_buffer_f2, WFRM_BUFFER );
766 // F3 RING
766 // F3 RING
767 init_ring( waveform_ring_f3, NB_RING_NODES_F3, wf_buffer_f3, WFRM_BUFFER );
767 init_ring( waveform_ring_f3, NB_RING_NODES_F3, wf_buffer_f3, WFRM_BUFFER );
768
768
769 ring_node_wf_snap_extracted.buffer_address = (int) wf_snap_extracted;
769 ring_node_wf_snap_extracted.buffer_address = (int) wf_snap_extracted;
770
770
771 DEBUG_PRINTF1("waveform_ring_f0 @%x\n", (unsigned int) waveform_ring_f0)
771 DEBUG_PRINTF1("waveform_ring_f0 @%x\n", (unsigned int) waveform_ring_f0)
772 DEBUG_PRINTF1("waveform_ring_f1 @%x\n", (unsigned int) waveform_ring_f1)
772 DEBUG_PRINTF1("waveform_ring_f1 @%x\n", (unsigned int) waveform_ring_f1)
773 DEBUG_PRINTF1("waveform_ring_f2 @%x\n", (unsigned int) waveform_ring_f2)
773 DEBUG_PRINTF1("waveform_ring_f2 @%x\n", (unsigned int) waveform_ring_f2)
774 DEBUG_PRINTF1("waveform_ring_f3 @%x\n", (unsigned int) waveform_ring_f3)
774 DEBUG_PRINTF1("waveform_ring_f3 @%x\n", (unsigned int) waveform_ring_f3)
775 DEBUG_PRINTF1("wf_buffer_f0 @%x\n", (unsigned int) wf_buffer_f0)
775 DEBUG_PRINTF1("wf_buffer_f0 @%x\n", (unsigned int) wf_buffer_f0)
776 DEBUG_PRINTF1("wf_buffer_f1 @%x\n", (unsigned int) wf_buffer_f1)
776 DEBUG_PRINTF1("wf_buffer_f1 @%x\n", (unsigned int) wf_buffer_f1)
777 DEBUG_PRINTF1("wf_buffer_f2 @%x\n", (unsigned int) wf_buffer_f2)
777 DEBUG_PRINTF1("wf_buffer_f2 @%x\n", (unsigned int) wf_buffer_f2)
778 DEBUG_PRINTF1("wf_buffer_f3 @%x\n", (unsigned int) wf_buffer_f3)
778 DEBUG_PRINTF1("wf_buffer_f3 @%x\n", (unsigned int) wf_buffer_f3)
779
779
780 }
780 }
781
781
782 void init_ring(ring_node ring[], unsigned char nbNodes, volatile int buffer[], unsigned int bufferSize )
782 void init_ring(ring_node ring[], unsigned char nbNodes, volatile int buffer[], unsigned int bufferSize )
783 {
783 {
784 unsigned char i;
784 unsigned char i;
785
785
786 //***************
786 //***************
787 // BUFFER ADDRESS
787 // BUFFER ADDRESS
788 for(i=0; i<nbNodes; i++)
788 for(i=0; i<nbNodes; i++)
789 {
789 {
790 ring[i].coarseTime = 0x00;
790 ring[i].coarseTime = 0x00;
791 ring[i].fineTime = 0x00;
791 ring[i].fineTime = 0x00;
792 ring[i].sid = 0x00;
792 ring[i].sid = 0x00;
793 ring[i].status = 0x00;
793 ring[i].status = 0x00;
794 ring[i].buffer_address = (int) &buffer[ i * bufferSize ];
794 ring[i].buffer_address = (int) &buffer[ i * bufferSize ];
795 }
795 }
796
796
797 //*****
797 //*****
798 // NEXT
798 // NEXT
799 ring[nbNodes-1].next = (ring_node*) &ring[ 0 ];
799 ring[ nbNodes - 1 ].next = (ring_node*) &ring[ 0 ];
800 for(i=0; i<nbNodes-1; i++)
800 for(i=0; i<nbNodes-1; i++)
801 {
801 {
802 ring[i].next = (ring_node*) &ring[ i + 1 ];
802 ring[i].next = (ring_node*) &ring[ i + 1 ];
803 }
803 }
804
804
805 //*********
805 //*********
806 // PREVIOUS
806 // PREVIOUS
807 ring[0].previous = (ring_node*) &ring[ nbNodes - 1 ];
807 ring[ 0 ].previous = (ring_node*) &ring[ nbNodes - 1 ];
808 for(i=1; i<nbNodes; i++)
808 for(i=1; i<nbNodes; i++)
809 {
809 {
810 ring[i].previous = (ring_node*) &ring[ i - 1 ];
810 ring[i].previous = (ring_node*) &ring[ i - 1 ];
811 }
811 }
812 }
812 }
813
813
814 void WFP_reset_current_ring_nodes( void )
814 void WFP_reset_current_ring_nodes( void )
815 {
815 {
816 current_ring_node_f0 = waveform_ring_f0[0].next;
816 current_ring_node_f0 = waveform_ring_f0[0].next;
817 current_ring_node_f1 = waveform_ring_f1[0].next;
817 current_ring_node_f1 = waveform_ring_f1[0].next;
818 current_ring_node_f2 = waveform_ring_f2[0].next;
818 current_ring_node_f2 = waveform_ring_f2[0].next;
819 current_ring_node_f3 = waveform_ring_f3[0].next;
819 current_ring_node_f3 = waveform_ring_f3[0].next;
820
820
821 ring_node_to_send_swf_f0 = waveform_ring_f0;
821 ring_node_to_send_swf_f0 = waveform_ring_f0;
822 ring_node_to_send_swf_f1 = waveform_ring_f1;
822 ring_node_to_send_swf_f1 = waveform_ring_f1;
823 ring_node_to_send_swf_f2 = waveform_ring_f2;
823 ring_node_to_send_swf_f2 = waveform_ring_f2;
824
824
825 ring_node_to_send_cwf_f1 = waveform_ring_f1;
825 ring_node_to_send_cwf_f1 = waveform_ring_f1;
826 ring_node_to_send_cwf_f2 = waveform_ring_f2;
826 ring_node_to_send_cwf_f2 = waveform_ring_f2;
827 ring_node_to_send_cwf_f3 = waveform_ring_f3;
827 ring_node_to_send_cwf_f3 = waveform_ring_f3;
828 }
828 }
829
829
830 int send_waveform_CWF3_light( ring_node *ring_node_to_send, ring_node *ring_node_cwf3_light, rtems_id queue_id )
830 int send_waveform_CWF3_light( ring_node *ring_node_to_send, ring_node *ring_node_cwf3_light, rtems_id queue_id )
831 {
831 {
832 /** This function sends CWF_F3 CCSDS packets without the b1, b2 and b3 data.
832 /** This function sends CWF_F3 CCSDS packets without the b1, b2 and b3 data.
833 *
833 *
834 * @param waveform points to the buffer containing the data that will be send.
834 * @param waveform points to the buffer containing the data that will be send.
835 * @param headerCWF points to a table of headers that have been prepared for the data transmission.
835 * @param headerCWF points to a table of headers that have been prepared for the data transmission.
836 * @param queue_id is the id of the rtems queue to which spw_ioctl_pkt_send structures will be send. The structures
836 * @param queue_id is the id of the rtems queue to which spw_ioctl_pkt_send structures will be send. The structures
837 * contain information to setup the transmission of the data packets.
837 * contain information to setup the transmission of the data packets.
838 *
838 *
839 * By default, CWF_F3 packet are send without the b1, b2 and b3 data. This function rebuilds a data buffer
839 * By default, CWF_F3 packet are send without the b1, b2 and b3 data. This function rebuilds a data buffer
840 * from the incoming data and sends it in 7 packets, 6 containing 340 blocks and 1 one containing 8 blocks.
840 * from the incoming data and sends it in 7 packets, 6 containing 340 blocks and 1 one containing 8 blocks.
841 *
841 *
842 */
842 */
843
843
844 unsigned int i;
844 unsigned int i;
845 int ret;
845 int ret;
846 rtems_status_code status;
846 rtems_status_code status;
847
847
848 char *sample;
848 char *sample;
849 int *dataPtr;
849 int *dataPtr;
850
850
851 ret = LFR_DEFAULT;
851 ret = LFR_DEFAULT;
852
852
853 dataPtr = (int*) ring_node_to_send->buffer_address;
853 dataPtr = (int*) ring_node_to_send->buffer_address;
854
854
855 ring_node_cwf3_light->coarseTime = ring_node_to_send->coarseTime;
855 ring_node_cwf3_light->coarseTime = ring_node_to_send->coarseTime;
856 ring_node_cwf3_light->fineTime = ring_node_to_send->fineTime;
856 ring_node_cwf3_light->fineTime = ring_node_to_send->fineTime;
857
857
858 //**********************
858 //**********************
859 // BUILD CWF3_light DATA
859 // BUILD CWF3_light DATA
860 for ( i=0; i< NB_SAMPLES_PER_SNAPSHOT; i++)
860 for ( i=0; i< NB_SAMPLES_PER_SNAPSHOT; i++)
861 {
861 {
862 sample = (char*) &dataPtr[ (i * NB_WORDS_SWF_BLK) ];
862 sample = (char*) &dataPtr[ (i * NB_WORDS_SWF_BLK) ];
863 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) ] = sample[ 0 ];
863 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) ] = sample[ 0 ];
864 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 1 ] = sample[ 1 ];
864 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 1 ] = sample[ 1 ];
865 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 2 ] = sample[ 2 ];
865 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 2 ] = sample[ 2 ];
866 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 3 ] = sample[ 3 ];
866 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 3 ] = sample[ 3 ];
867 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 4 ] = sample[ 4 ];
867 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 4 ] = sample[ 4 ];
868 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 5 ] = sample[ 5 ];
868 wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 5 ] = sample[ 5 ];
869 }
869 }
870
870
871 // SEND PACKET
871 // SEND PACKET
872 status = rtems_message_queue_send( queue_id, &ring_node_cwf3_light, sizeof( ring_node* ) );
872 status = rtems_message_queue_send( queue_id, &ring_node_cwf3_light, sizeof( ring_node* ) );
873 if (status != RTEMS_SUCCESSFUL) {
873 if (status != RTEMS_SUCCESSFUL) {
874 printf("%d-%d, ERR %d\n", SID_NORM_CWF_F3, i, (int) status);
874 printf("%d-%d, ERR %d\n", SID_NORM_CWF_F3, i, (int) status);
875 ret = LFR_DEFAULT;
875 ret = LFR_DEFAULT;
876 }
876 }
877
877
878 return ret;
878 return ret;
879 }
879 }
880
880
881 void compute_acquisition_time( unsigned int coarseTime, unsigned int fineTime,
881 void compute_acquisition_time( unsigned int coarseTime, unsigned int fineTime,
882 unsigned int sid, unsigned char pa_lfr_pkt_nr, unsigned char * acquisitionTime )
882 unsigned int sid, unsigned char pa_lfr_pkt_nr, unsigned char * acquisitionTime )
883 {
883 {
884 unsigned long long int acquisitionTimeAsLong;
884 unsigned long long int acquisitionTimeAsLong;
885 unsigned char localAcquisitionTime[6];
885 unsigned char localAcquisitionTime[6];
886 double deltaT;
886 double deltaT;
887
887
888 deltaT = 0.;
888 deltaT = 0.;
889
889
890 localAcquisitionTime[0] = (unsigned char) ( coarseTime >> 24 );
890 localAcquisitionTime[0] = (unsigned char) ( coarseTime >> 24 );
891 localAcquisitionTime[1] = (unsigned char) ( coarseTime >> 16 );
891 localAcquisitionTime[1] = (unsigned char) ( coarseTime >> 16 );
892 localAcquisitionTime[2] = (unsigned char) ( coarseTime >> 8 );
892 localAcquisitionTime[2] = (unsigned char) ( coarseTime >> 8 );
893 localAcquisitionTime[3] = (unsigned char) ( coarseTime );
893 localAcquisitionTime[3] = (unsigned char) ( coarseTime );
894 localAcquisitionTime[4] = (unsigned char) ( fineTime >> 8 );
894 localAcquisitionTime[4] = (unsigned char) ( fineTime >> 8 );
895 localAcquisitionTime[5] = (unsigned char) ( fineTime );
895 localAcquisitionTime[5] = (unsigned char) ( fineTime );
896
896
897 acquisitionTimeAsLong = ( (unsigned long long int) localAcquisitionTime[0] << 40 )
897 acquisitionTimeAsLong = ( (unsigned long long int) localAcquisitionTime[0] << 40 )
898 + ( (unsigned long long int) localAcquisitionTime[1] << 32 )
898 + ( (unsigned long long int) localAcquisitionTime[1] << 32 )
899 + ( (unsigned long long int) localAcquisitionTime[2] << 24 )
899 + ( (unsigned long long int) localAcquisitionTime[2] << 24 )
900 + ( (unsigned long long int) localAcquisitionTime[3] << 16 )
900 + ( (unsigned long long int) localAcquisitionTime[3] << 16 )
901 + ( (unsigned long long int) localAcquisitionTime[4] << 8 )
901 + ( (unsigned long long int) localAcquisitionTime[4] << 8 )
902 + ( (unsigned long long int) localAcquisitionTime[5] );
902 + ( (unsigned long long int) localAcquisitionTime[5] );
903
903
904 switch( sid )
904 switch( sid )
905 {
905 {
906 case SID_NORM_SWF_F0:
906 case SID_NORM_SWF_F0:
907 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 24576. ;
907 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 24576. ;
908 break;
908 break;
909
909
910 case SID_NORM_SWF_F1:
910 case SID_NORM_SWF_F1:
911 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 4096. ;
911 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 4096. ;
912 break;
912 break;
913
913
914 case SID_NORM_SWF_F2:
914 case SID_NORM_SWF_F2:
915 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 256. ;
915 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 256. ;
916 break;
916 break;
917
917
918 case SID_SBM1_CWF_F1:
918 case SID_SBM1_CWF_F1:
919 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 4096. ;
919 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 4096. ;
920 break;
920 break;
921
921
922 case SID_SBM2_CWF_F2:
922 case SID_SBM2_CWF_F2:
923 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 256. ;
923 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 256. ;
924 break;
924 break;
925
925
926 case SID_BURST_CWF_F2:
926 case SID_BURST_CWF_F2:
927 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 256. ;
927 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 256. ;
928 break;
928 break;
929
929
930 case SID_NORM_CWF_F3:
930 case SID_NORM_CWF_F3:
931 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF_SHORT_F3 * 65536. / 16. ;
931 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF_SHORT_F3 * 65536. / 16. ;
932 break;
932 break;
933
933
934 case SID_NORM_CWF_LONG_F3:
934 case SID_NORM_CWF_LONG_F3:
935 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 16. ;
935 deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 16. ;
936 break;
936 break;
937
937
938 default:
938 default:
939 PRINTF1("in compute_acquisition_time *** ERR unexpected sid %d\n", sid)
939 PRINTF1("in compute_acquisition_time *** ERR unexpected sid %d\n", sid)
940 deltaT = 0.;
940 deltaT = 0.;
941 break;
941 break;
942 }
942 }
943
943
944 acquisitionTimeAsLong = acquisitionTimeAsLong + (unsigned long long int) deltaT;
944 acquisitionTimeAsLong = acquisitionTimeAsLong + (unsigned long long int) deltaT;
945 //
945 //
946 acquisitionTime[0] = (unsigned char) (acquisitionTimeAsLong >> 40);
946 acquisitionTime[0] = (unsigned char) (acquisitionTimeAsLong >> 40);
947 acquisitionTime[1] = (unsigned char) (acquisitionTimeAsLong >> 32);
947 acquisitionTime[1] = (unsigned char) (acquisitionTimeAsLong >> 32);
948 acquisitionTime[2] = (unsigned char) (acquisitionTimeAsLong >> 24);
948 acquisitionTime[2] = (unsigned char) (acquisitionTimeAsLong >> 24);
949 acquisitionTime[3] = (unsigned char) (acquisitionTimeAsLong >> 16);
949 acquisitionTime[3] = (unsigned char) (acquisitionTimeAsLong >> 16);
950 acquisitionTime[4] = (unsigned char) (acquisitionTimeAsLong >> 8 );
950 acquisitionTime[4] = (unsigned char) (acquisitionTimeAsLong >> 8 );
951 acquisitionTime[5] = (unsigned char) (acquisitionTimeAsLong );
951 acquisitionTime[5] = (unsigned char) (acquisitionTimeAsLong );
952
952
953 }
953 }
954
954
955 void build_snapshot_from_ring( ring_node *ring_node_to_send, unsigned char frequencyChannel )
955 void build_snapshot_from_ring( ring_node *ring_node_to_send, unsigned char frequencyChannel )
956 {
956 {
957 unsigned int i;
957 unsigned int i;
958 unsigned long long int centerTime_asLong;
958 unsigned long long int centerTime_asLong;
959 unsigned long long int acquisitionTimeF0_asLong;
959 unsigned long long int acquisitionTimeF0_asLong;
960 unsigned long long int acquisitionTime_asLong;
960 unsigned long long int acquisitionTime_asLong;
961 unsigned long long int bufferAcquisitionTime_asLong;
961 unsigned long long int bufferAcquisitionTime_asLong;
962 unsigned char *ptr1;
962 unsigned char *ptr1;
963 unsigned char *ptr2;
963 unsigned char *ptr2;
964 unsigned char *timeCharPtr;
964 unsigned char *timeCharPtr;
965 unsigned char nb_ring_nodes;
965 unsigned char nb_ring_nodes;
966 unsigned long long int frequency_asLong;
966 unsigned long long int frequency_asLong;
967 unsigned long long int nbTicksPerSample_asLong;
967 unsigned long long int nbTicksPerSample_asLong;
968 unsigned long long int nbSamplesPart1_asLong;
968 unsigned long long int nbSamplesPart1_asLong;
969 unsigned long long int sampleOffset_asLong;
969 unsigned long long int sampleOffset_asLong;
970
970
971 unsigned int deltaT_F0;
971 unsigned int deltaT_F0;
972 unsigned int deltaT_F1;
972 unsigned int deltaT_F1;
973 unsigned long long int deltaT_F2;
973 unsigned long long int deltaT_F2;
974
974
975 deltaT_F0 = 2731; // (2048. / 24576. / 2.) * 65536. = 2730.667;
975 deltaT_F0 = 2731; // (2048. / 24576. / 2.) * 65536. = 2730.667;
976 deltaT_F1 = 16384; // (2048. / 4096. / 2.) * 65536. = 16384;
976 deltaT_F1 = 16384; // (2048. / 4096. / 2.) * 65536. = 16384;
977 deltaT_F2 = 262144; // (2048. / 256. / 2.) * 65536. = 262144;
977 deltaT_F2 = 262144; // (2048. / 256. / 2.) * 65536. = 262144;
978 sampleOffset_asLong = 0x00;
978 sampleOffset_asLong = 0x00;
979
979
980 // (1) get the f0 acquisition time
980 // (1) get the f0 acquisition time
981 acquisitionTimeF0_asLong = get_acquisition_time( (unsigned char *) &ring_node_to_send->coarseTime );
981 acquisitionTimeF0_asLong = get_acquisition_time( (unsigned char *) &ring_node_to_send->coarseTime );
982
982
983 // (2) compute the central reference time
983 // (2) compute the central reference time
984 centerTime_asLong = acquisitionTimeF0_asLong + deltaT_F0;
984 centerTime_asLong = acquisitionTimeF0_asLong + deltaT_F0;
985
985
986 // (3) compute the acquisition time of the current snapshot
986 // (3) compute the acquisition time of the current snapshot
987 switch(frequencyChannel)
987 switch(frequencyChannel)
988 {
988 {
989 case 1: // 1 is for F1 = 4096 Hz
989 case 1: // 1 is for F1 = 4096 Hz
990 acquisitionTime_asLong = centerTime_asLong - deltaT_F1;
990 acquisitionTime_asLong = centerTime_asLong - deltaT_F1;
991 nb_ring_nodes = NB_RING_NODES_F1;
991 nb_ring_nodes = NB_RING_NODES_F1;
992 frequency_asLong = 4096;
992 frequency_asLong = 4096;
993 nbTicksPerSample_asLong = 16; // 65536 / 4096;
993 nbTicksPerSample_asLong = 16; // 65536 / 4096;
994 break;
994 break;
995 case 2: // 2 is for F2 = 256 Hz
995 case 2: // 2 is for F2 = 256 Hz
996 acquisitionTime_asLong = centerTime_asLong - deltaT_F2;
996 acquisitionTime_asLong = centerTime_asLong - deltaT_F2;
997 nb_ring_nodes = NB_RING_NODES_F2;
997 nb_ring_nodes = NB_RING_NODES_F2;
998 frequency_asLong = 256;
998 frequency_asLong = 256;
999 nbTicksPerSample_asLong = 256; // 65536 / 256;
999 nbTicksPerSample_asLong = 256; // 65536 / 256;
1000 break;
1000 break;
1001 default:
1001 default:
1002 acquisitionTime_asLong = centerTime_asLong;
1002 acquisitionTime_asLong = centerTime_asLong;
1003 frequency_asLong = 256;
1003 frequency_asLong = 256;
1004 nbTicksPerSample_asLong = 256;
1004 nbTicksPerSample_asLong = 256;
1005 break;
1005 break;
1006 }
1006 }
1007
1007
1008 //****************************************************************************
1008 //****************************************************************************
1009 // (4) search the ring_node with the acquisition time <= acquisitionTime_asLong
1009 // (4) search the ring_node with the acquisition time <= acquisitionTime_asLong
1010 for (i=0; i<nb_ring_nodes; i++)
1010 for (i=0; i<nb_ring_nodes; i++)
1011 {
1011 {
1012 PRINTF1("%d ... ", i)
1012 PRINTF1("%d ... ", i)
1013 bufferAcquisitionTime_asLong = get_acquisition_time( (unsigned char *) ring_node_to_send->coarseTime );
1013 bufferAcquisitionTime_asLong = get_acquisition_time( (unsigned char *) ring_node_to_send->coarseTime );
1014 if (bufferAcquisitionTime_asLong <= acquisitionTime_asLong)
1014 if (bufferAcquisitionTime_asLong <= acquisitionTime_asLong)
1015 {
1015 {
1016 PRINTF1("buffer found with acquisition time = %llx\n", bufferAcquisitionTime_asLong)
1016 PRINTF1("buffer found with acquisition time = %llx\n", bufferAcquisitionTime_asLong)
1017 break;
1017 break;
1018 }
1018 }
1019 ring_node_to_send = ring_node_to_send->previous;
1019 ring_node_to_send = ring_node_to_send->previous;
1020 }
1020 }
1021
1021
1022 // (5) compute the number of samples to take in the current buffer
1022 // (5) compute the number of samples to take in the current buffer
1023 sampleOffset_asLong = ((acquisitionTime_asLong - bufferAcquisitionTime_asLong) * frequency_asLong ) >> 16;
1023 sampleOffset_asLong = ((acquisitionTime_asLong - bufferAcquisitionTime_asLong) * frequency_asLong ) >> 16;
1024 nbSamplesPart1_asLong = NB_SAMPLES_PER_SNAPSHOT - sampleOffset_asLong;
1024 nbSamplesPart1_asLong = NB_SAMPLES_PER_SNAPSHOT - sampleOffset_asLong;
1025 PRINTF2("sampleOffset_asLong = %llx, nbSamplesPart1_asLong = %llx\n", sampleOffset_asLong, nbSamplesPart1_asLong)
1025 PRINTF2("sampleOffset_asLong = %llx, nbSamplesPart1_asLong = %llx\n", sampleOffset_asLong, nbSamplesPart1_asLong)
1026
1026
1027 // (6) compute the final acquisition time
1027 // (6) compute the final acquisition time
1028 acquisitionTime_asLong = bufferAcquisitionTime_asLong +
1028 acquisitionTime_asLong = bufferAcquisitionTime_asLong +
1029 sampleOffset_asLong * nbTicksPerSample_asLong;
1029 sampleOffset_asLong * nbTicksPerSample_asLong;
1030
1030
1031 // (7) copy the acquisition time at the beginning of the extrated snapshot
1031 // (7) copy the acquisition time at the beginning of the extrated snapshot
1032 ptr1 = (unsigned char*) &acquisitionTime_asLong;
1032 ptr1 = (unsigned char*) &acquisitionTime_asLong;
1033 // fine time
1033 // fine time
1034 ptr2 = (unsigned char*) &ring_node_wf_snap_extracted.fineTime;
1034 ptr2 = (unsigned char*) &ring_node_wf_snap_extracted.fineTime;
1035 ptr2[2] = ptr1[ 4 + 2 ];
1035 ptr2[2] = ptr1[ 4 + 2 ];
1036 ptr2[3] = ptr1[ 5 + 2 ];
1036 ptr2[3] = ptr1[ 5 + 2 ];
1037 // coarse time
1037 // coarse time
1038 ptr2 = (unsigned char*) &ring_node_wf_snap_extracted.coarseTime;
1038 ptr2 = (unsigned char*) &ring_node_wf_snap_extracted.coarseTime;
1039 ptr2[0] = ptr1[ 0 + 2 ];
1039 ptr2[0] = ptr1[ 0 + 2 ];
1040 ptr2[1] = ptr1[ 1 + 2 ];
1040 ptr2[1] = ptr1[ 1 + 2 ];
1041 ptr2[2] = ptr1[ 2 + 2 ];
1041 ptr2[2] = ptr1[ 2 + 2 ];
1042 ptr2[3] = ptr1[ 3 + 2 ];
1042 ptr2[3] = ptr1[ 3 + 2 ];
1043
1043
1044 // re set the synchronization bit
1044 // re set the synchronization bit
1045 timeCharPtr = (unsigned char*) &ring_node_to_send->coarseTime;
1045 timeCharPtr = (unsigned char*) &ring_node_to_send->coarseTime;
1046 ptr2[0] = ptr2[0] | (timeCharPtr[0] & 0x80); // [1000 0000]
1046 ptr2[0] = ptr2[0] | (timeCharPtr[0] & 0x80); // [1000 0000]
1047
1047
1048 if ( (nbSamplesPart1_asLong >= NB_SAMPLES_PER_SNAPSHOT) | (nbSamplesPart1_asLong < 0) )
1048 if ( (nbSamplesPart1_asLong >= NB_SAMPLES_PER_SNAPSHOT) | (nbSamplesPart1_asLong < 0) )
1049 {
1049 {
1050 nbSamplesPart1_asLong = 0;
1050 nbSamplesPart1_asLong = 0;
1051 }
1051 }
1052 // copy the part 1 of the snapshot in the extracted buffer
1052 // copy the part 1 of the snapshot in the extracted buffer
1053 for ( i = 0; i < (nbSamplesPart1_asLong * NB_WORDS_SWF_BLK); i++ )
1053 for ( i = 0; i < (nbSamplesPart1_asLong * NB_WORDS_SWF_BLK); i++ )
1054 {
1054 {
1055 wf_snap_extracted[i] =
1055 wf_snap_extracted[i] =
1056 ((int*) ring_node_to_send->buffer_address)[ i + (sampleOffset_asLong * NB_WORDS_SWF_BLK) ];
1056 ((int*) ring_node_to_send->buffer_address)[ i + (sampleOffset_asLong * NB_WORDS_SWF_BLK) ];
1057 }
1057 }
1058 // copy the part 2 of the snapshot in the extracted buffer
1058 // copy the part 2 of the snapshot in the extracted buffer
1059 ring_node_to_send = ring_node_to_send->next;
1059 ring_node_to_send = ring_node_to_send->next;
1060 for ( i = (nbSamplesPart1_asLong * NB_WORDS_SWF_BLK); i < (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK); i++ )
1060 for ( i = (nbSamplesPart1_asLong * NB_WORDS_SWF_BLK); i < (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK); i++ )
1061 {
1061 {
1062 wf_snap_extracted[i] =
1062 wf_snap_extracted[i] =
1063 ((int*) ring_node_to_send->buffer_address)[ (i-(nbSamplesPart1_asLong * NB_WORDS_SWF_BLK)) ];
1063 ((int*) ring_node_to_send->buffer_address)[ (i-(nbSamplesPart1_asLong * NB_WORDS_SWF_BLK)) ];
1064 }
1064 }
1065 }
1065 }
1066
1066
1067 void snapshot_resynchronization( unsigned char *timePtr )
1067 void snapshot_resynchronization( unsigned char *timePtr )
1068 {
1068 {
1069 unsigned long long int acquisitionTime;
1069 unsigned long long int acquisitionTime;
1070 unsigned long long int centerTime;
1070 unsigned long long int centerTime;
1071 unsigned long long int previousTick;
1071 unsigned long long int previousTick;
1072 unsigned long long int nextTick;
1072 unsigned long long int nextTick;
1073 unsigned long long int deltaPreviousTick;
1073 unsigned long long int deltaPreviousTick;
1074 unsigned long long int deltaNextTick;
1074 unsigned long long int deltaNextTick;
1075 unsigned int deltaTickInF2;
1075 unsigned int deltaTickInF2;
1076 double deltaPrevious;
1076 double deltaPrevious;
1077 double deltaNext;
1077 double deltaNext;
1078
1078
1079 acquisitionTime = get_acquisition_time( timePtr );
1079 acquisitionTime = get_acquisition_time( timePtr );
1080
1080
1081 // compute center time
1081 // compute center time
1082 centerTime = acquisitionTime + 2731; // (2048. / 24576. / 2.) * 65536. = 2730.667;
1082 centerTime = acquisitionTime + 2731; // (2048. / 24576. / 2.) * 65536. = 2730.667;
1083 previousTick = centerTime - (centerTime & 0xffff);
1083 previousTick = centerTime - (centerTime & 0xffff);
1084 nextTick = previousTick + 65536;
1084 nextTick = previousTick + 65536;
1085
1085
1086 deltaPreviousTick = centerTime - previousTick;
1086 deltaPreviousTick = centerTime - previousTick;
1087 deltaNextTick = nextTick - centerTime;
1087 deltaNextTick = nextTick - centerTime;
1088
1088
1089 deltaPrevious = ((double) deltaPreviousTick) / 65536. * 1000.;
1089 deltaPrevious = ((double) deltaPreviousTick) / 65536. * 1000.;
1090 deltaNext = ((double) deltaNextTick) / 65536. * 1000.;
1090 deltaNext = ((double) deltaNextTick) / 65536. * 1000.;
1091
1091
1092 printf("delta previous = %f ms, delta next = %f ms\n", deltaPrevious, deltaNext);
1092 printf("delta previous = %f ms, delta next = %f ms\n", deltaPrevious, deltaNext);
1093 printf("delta previous = %llu, delta next = %llu\n", deltaPreviousTick, deltaNextTick);
1093 printf("delta previous = %llu, delta next = %llu\n", deltaPreviousTick, deltaNextTick);
1094
1094
1095 // which tick is the closest
1095 // which tick is the closest
1096 if (deltaPreviousTick > deltaNextTick)
1096 if (deltaPreviousTick > deltaNextTick)
1097 {
1097 {
1098 deltaTickInF2 = floor( (deltaNext * 256. / 1000.) ); // the division by 2 is important here
1098 deltaTickInF2 = floor( (deltaNext * 256. / 1000.) ); // the division by 2 is important here
1099 waveform_picker_regs->delta_snapshot = waveform_picker_regs->delta_snapshot + deltaTickInF2;
1099 waveform_picker_regs->delta_snapshot = waveform_picker_regs->delta_snapshot + deltaTickInF2;
1100 printf("correction of = + %u\n", deltaTickInF2);
1100 printf("correction of = + %u\n", deltaTickInF2);
1101 }
1101 }
1102 else
1102 else
1103 {
1103 {
1104 deltaTickInF2 = floor( (deltaPrevious * 256. / 1000.) ); // the division by 2 is important here
1104 deltaTickInF2 = floor( (deltaPrevious * 256. / 1000.) ); // the division by 2 is important here
1105 waveform_picker_regs->delta_snapshot = waveform_picker_regs->delta_snapshot - deltaTickInF2;
1105 waveform_picker_regs->delta_snapshot = waveform_picker_regs->delta_snapshot - deltaTickInF2;
1106 printf("correction of = - %u\n", deltaTickInF2);
1106 printf("correction of = - %u\n", deltaTickInF2);
1107 }
1107 }
1108 }
1108 }
1109
1109
1110 //**************
1110 //**************
1111 // wfp registers
1111 // wfp registers
1112 void reset_wfp_burst_enable( void )
1112 void reset_wfp_burst_enable( void )
1113 {
1113 {
1114 /** This function resets the waveform picker burst_enable register.
1114 /** This function resets the waveform picker burst_enable register.
1115 *
1115 *
1116 * The burst bits [f2 f1 f0] and the enable bits [f3 f2 f1 f0] are set to 0.
1116 * The burst bits [f2 f1 f0] and the enable bits [f3 f2 f1 f0] are set to 0.
1117 *
1117 *
1118 */
1118 */
1119
1119
1120 // [1000 000] burst f2, f1, f0 enable f3, f2, f1, f0
1120 // [1000 000] burst f2, f1, f0 enable f3, f2, f1, f0
1121 waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable & 0x80;
1121 waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable & 0x80;
1122 }
1122 }
1123
1123
1124 void reset_wfp_status( void )
1124 void reset_wfp_status( void )
1125 {
1125 {
1126 /** This function resets the waveform picker status register.
1126 /** This function resets the waveform picker status register.
1127 *
1127 *
1128 * All status bits are set to 0 [new_err full_err full].
1128 * All status bits are set to 0 [new_err full_err full].
1129 *
1129 *
1130 */
1130 */
1131
1131
1132 waveform_picker_regs->status = 0xffff;
1132 waveform_picker_regs->status = 0xffff;
1133 }
1133 }
1134
1134
1135 void reset_wfp_buffer_addresses( void )
1135 void reset_wfp_buffer_addresses( void )
1136 {
1136 {
1137 // F0
1137 // F0
1138 waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->previous->buffer_address; // 0x08
1138 waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->previous->buffer_address; // 0x08
1139 waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address; // 0x0c
1139 waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address; // 0x0c
1140 // F1
1140 // F1
1141 waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->previous->buffer_address; // 0x10
1141 waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->previous->buffer_address; // 0x10
1142 waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address; // 0x14
1142 waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address; // 0x14
1143 // F2
1143 // F2
1144 waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->previous->buffer_address; // 0x18
1144 waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->previous->buffer_address; // 0x18
1145 waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address; // 0x1c
1145 waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address; // 0x1c
1146 // F3
1146 // F3
1147 waveform_picker_regs->addr_data_f3_0 = current_ring_node_f3->previous->buffer_address; // 0x20
1147 waveform_picker_regs->addr_data_f3_0 = current_ring_node_f3->previous->buffer_address; // 0x20
1148 waveform_picker_regs->addr_data_f3_1 = current_ring_node_f3->buffer_address; // 0x24
1148 waveform_picker_regs->addr_data_f3_1 = current_ring_node_f3->buffer_address; // 0x24
1149 }
1149 }
1150
1150
1151 void reset_waveform_picker_regs( void )
1151 void reset_waveform_picker_regs( void )
1152 {
1152 {
1153 /** This function resets the waveform picker module registers.
1153 /** This function resets the waveform picker module registers.
1154 *
1154 *
1155 * The registers affected by this function are located at the following offset addresses:
1155 * The registers affected by this function are located at the following offset addresses:
1156 * - 0x00 data_shaping
1156 * - 0x00 data_shaping
1157 * - 0x04 run_burst_enable
1157 * - 0x04 run_burst_enable
1158 * - 0x08 addr_data_f0
1158 * - 0x08 addr_data_f0
1159 * - 0x0C addr_data_f1
1159 * - 0x0C addr_data_f1
1160 * - 0x10 addr_data_f2
1160 * - 0x10 addr_data_f2
1161 * - 0x14 addr_data_f3
1161 * - 0x14 addr_data_f3
1162 * - 0x18 status
1162 * - 0x18 status
1163 * - 0x1C delta_snapshot
1163 * - 0x1C delta_snapshot
1164 * - 0x20 delta_f0
1164 * - 0x20 delta_f0
1165 * - 0x24 delta_f0_2
1165 * - 0x24 delta_f0_2
1166 * - 0x28 delta_f1
1166 * - 0x28 delta_f1
1167 * - 0x2c delta_f2
1167 * - 0x2c delta_f2
1168 * - 0x30 nb_data_by_buffer
1168 * - 0x30 nb_data_by_buffer
1169 * - 0x34 nb_snapshot_param
1169 * - 0x34 nb_snapshot_param
1170 * - 0x38 start_date
1170 * - 0x38 start_date
1171 * - 0x3c nb_word_in_buffer
1171 * - 0x3c nb_word_in_buffer
1172 *
1172 *
1173 */
1173 */
1174
1174
1175 set_wfp_data_shaping(); // 0x00 *** R1 R0 SP1 SP0 BW
1175 set_wfp_data_shaping(); // 0x00 *** R1 R0 SP1 SP0 BW
1176
1176
1177 reset_wfp_burst_enable(); // 0x04 *** [run *** burst f2, f1, f0 *** enable f3, f2, f1, f0 ]
1177 reset_wfp_burst_enable(); // 0x04 *** [run *** burst f2, f1, f0 *** enable f3, f2, f1, f0 ]
1178
1178
1179 reset_wfp_buffer_addresses();
1179 reset_wfp_buffer_addresses();
1180
1180
1181 reset_wfp_status(); // 0x18
1181 reset_wfp_status(); // 0x18
1182
1182
1183 set_wfp_delta_snapshot(); // 0x1c *** 300 s => 0x12bff
1183 set_wfp_delta_snapshot(); // 0x1c *** 300 s => 0x12bff
1184
1184
1185 set_wfp_delta_f0_f0_2(); // 0x20, 0x24
1185 set_wfp_delta_f0_f0_2(); // 0x20, 0x24
1186
1186
1187 set_wfp_delta_f1(); // 0x28
1187 set_wfp_delta_f1(); // 0x28
1188
1188
1189 set_wfp_delta_f2(); // 0x2c
1189 set_wfp_delta_f2(); // 0x2c
1190
1190
1191 DEBUG_PRINTF1("delta_snapshot %x\n", waveform_picker_regs->delta_snapshot)
1191 DEBUG_PRINTF1("delta_snapshot %x\n", waveform_picker_regs->delta_snapshot)
1192 DEBUG_PRINTF1("delta_f0 %x\n", waveform_picker_regs->delta_f0)
1192 DEBUG_PRINTF1("delta_f0 %x\n", waveform_picker_regs->delta_f0)
1193 DEBUG_PRINTF1("delta_f0_2 %x\n", waveform_picker_regs->delta_f0_2)
1193 DEBUG_PRINTF1("delta_f0_2 %x\n", waveform_picker_regs->delta_f0_2)
1194 DEBUG_PRINTF1("delta_f1 %x\n", waveform_picker_regs->delta_f1)
1194 DEBUG_PRINTF1("delta_f1 %x\n", waveform_picker_regs->delta_f1)
1195 DEBUG_PRINTF1("delta_f2 %x\n", waveform_picker_regs->delta_f2)
1195 DEBUG_PRINTF1("delta_f2 %x\n", waveform_picker_regs->delta_f2)
1196 // 2688 = 8 * 336
1196 // 2688 = 8 * 336
1197 waveform_picker_regs->nb_data_by_buffer = 0xa7f; // 0x30 *** 2688 - 1 => nb samples -1
1197 waveform_picker_regs->nb_data_by_buffer = 0xa7f; // 0x30 *** 2688 - 1 => nb samples -1
1198 waveform_picker_regs->snapshot_param = 0xa80; // 0x34 *** 2688 => nb samples
1198 waveform_picker_regs->snapshot_param = 0xa80; // 0x34 *** 2688 => nb samples
1199 waveform_picker_regs->start_date = 0x7fffffff; // 0x38
1199 waveform_picker_regs->start_date = 0x7fffffff; // 0x38
1200 //
1200 //
1201 // coarse time and fine time registers are not initialized, they are volatile
1201 // coarse time and fine time registers are not initialized, they are volatile
1202 //
1202 //
1203 waveform_picker_regs->buffer_length = 0x1f8;// buffer length in burst = 3 * 2688 / 16 = 504 = 0x1f8
1203 waveform_picker_regs->buffer_length = 0x1f8;// buffer length in burst = 3 * 2688 / 16 = 504 = 0x1f8
1204 }
1204 }
1205
1205
1206 void set_wfp_data_shaping( void )
1206 void set_wfp_data_shaping( void )
1207 {
1207 {
1208 /** This function sets the data_shaping register of the waveform picker module.
1208 /** This function sets the data_shaping register of the waveform picker module.
1209 *
1209 *
1210 * The value is read from one field of the parameter_dump_packet structure:\n
1210 * The value is read from one field of the parameter_dump_packet structure:\n
1211 * bw_sp0_sp1_r0_r1
1211 * bw_sp0_sp1_r0_r1
1212 *
1212 *
1213 */
1213 */
1214
1214
1215 unsigned char data_shaping;
1215 unsigned char data_shaping;
1216
1216
1217 // get the parameters for the data shaping [BW SP0 SP1 R0 R1] in sy_lfr_common1 and configure the register
1217 // get the parameters for the data shaping [BW SP0 SP1 R0 R1] in sy_lfr_common1 and configure the register
1218 // waveform picker : [R1 R0 SP1 SP0 BW]
1218 // waveform picker : [R1 R0 SP1 SP0 BW]
1219
1219
1220 data_shaping = parameter_dump_packet.bw_sp0_sp1_r0_r1;
1220 data_shaping = parameter_dump_packet.bw_sp0_sp1_r0_r1;
1221
1221
1222 waveform_picker_regs->data_shaping =
1222 waveform_picker_regs->data_shaping =
1223 ( (data_shaping & 0x10) >> 4 ) // BW
1223 ( (data_shaping & 0x10) >> 4 ) // BW
1224 + ( (data_shaping & 0x08) >> 2 ) // SP0
1224 + ( (data_shaping & 0x08) >> 2 ) // SP0
1225 + ( (data_shaping & 0x04) ) // SP1
1225 + ( (data_shaping & 0x04) ) // SP1
1226 + ( (data_shaping & 0x02) << 2 ) // R0
1226 + ( (data_shaping & 0x02) << 2 ) // R0
1227 + ( (data_shaping & 0x01) << 4 ); // R1
1227 + ( (data_shaping & 0x01) << 4 ); // R1
1228 }
1228 }
1229
1229
1230 void set_wfp_burst_enable_register( unsigned char mode )
1230 void set_wfp_burst_enable_register( unsigned char mode )
1231 {
1231 {
1232 /** This function sets the waveform picker burst_enable register depending on the mode.
1232 /** This function sets the waveform picker burst_enable register depending on the mode.
1233 *
1233 *
1234 * @param mode is the LFR mode to launch.
1234 * @param mode is the LFR mode to launch.
1235 *
1235 *
1236 * The burst bits shall be before the enable bits.
1236 * The burst bits shall be before the enable bits.
1237 *
1237 *
1238 */
1238 */
1239
1239
1240 // [0000 0000] burst f2, f1, f0 enable f3 f2 f1 f0
1240 // [0000 0000] burst f2, f1, f0 enable f3 f2 f1 f0
1241 // the burst bits shall be set first, before the enable bits
1241 // the burst bits shall be set first, before the enable bits
1242 switch(mode) {
1242 switch(mode) {
1243 case(LFR_MODE_NORMAL):
1243 case(LFR_MODE_NORMAL):
1244 waveform_picker_regs->run_burst_enable = 0x00; // [0000 0000] no burst enable
1244 waveform_picker_regs->run_burst_enable = 0x00; // [0000 0000] no burst enable
1245 waveform_picker_regs->run_burst_enable = 0x0f; // [0000 1111] enable f3 f2 f1 f0
1245 waveform_picker_regs->run_burst_enable = 0x0f; // [0000 1111] enable f3 f2 f1 f0
1246 break;
1246 break;
1247 case(LFR_MODE_BURST):
1247 case(LFR_MODE_BURST):
1248 waveform_picker_regs->run_burst_enable = 0x40; // [0100 0000] f2 burst enabled
1248 waveform_picker_regs->run_burst_enable = 0x40; // [0100 0000] f2 burst enabled
1249 // waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x04; // [0100] enable f2
1249 // waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x04; // [0100] enable f2
1250 waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x0c; // [1100] enable f3 AND f2
1250 waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x0c; // [1100] enable f3 AND f2
1251 break;
1251 break;
1252 case(LFR_MODE_SBM1):
1252 case(LFR_MODE_SBM1):
1253 waveform_picker_regs->run_burst_enable = 0x20; // [0010 0000] f1 burst enabled
1253 waveform_picker_regs->run_burst_enable = 0x20; // [0010 0000] f1 burst enabled
1254 waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x0f; // [1111] enable f3 f2 f1 f0
1254 waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x0f; // [1111] enable f3 f2 f1 f0
1255 break;
1255 break;
1256 case(LFR_MODE_SBM2):
1256 case(LFR_MODE_SBM2):
1257 waveform_picker_regs->run_burst_enable = 0x40; // [0100 0000] f2 burst enabled
1257 waveform_picker_regs->run_burst_enable = 0x40; // [0100 0000] f2 burst enabled
1258 waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x0f; // [1111] enable f3 f2 f1 f0
1258 waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x0f; // [1111] enable f3 f2 f1 f0
1259 break;
1259 break;
1260 default:
1260 default:
1261 waveform_picker_regs->run_burst_enable = 0x00; // [0000 0000] no burst enabled, no waveform enabled
1261 waveform_picker_regs->run_burst_enable = 0x00; // [0000 0000] no burst enabled, no waveform enabled
1262 break;
1262 break;
1263 }
1263 }
1264 }
1264 }
1265
1265
1266 void set_wfp_delta_snapshot( void )
1266 void set_wfp_delta_snapshot( void )
1267 {
1267 {
1268 /** This function sets the delta_snapshot register of the waveform picker module.
1268 /** This function sets the delta_snapshot register of the waveform picker module.
1269 *
1269 *
1270 * The value is read from two (unsigned char) of the parameter_dump_packet structure:
1270 * The value is read from two (unsigned char) of the parameter_dump_packet structure:
1271 * - sy_lfr_n_swf_p[0]
1271 * - sy_lfr_n_swf_p[0]
1272 * - sy_lfr_n_swf_p[1]
1272 * - sy_lfr_n_swf_p[1]
1273 *
1273 *
1274 */
1274 */
1275
1275
1276 unsigned int delta_snapshot;
1276 unsigned int delta_snapshot;
1277 unsigned int delta_snapshot_in_T2;
1277 unsigned int delta_snapshot_in_T2;
1278
1278
1279 delta_snapshot = parameter_dump_packet.sy_lfr_n_swf_p[0]*256
1279 delta_snapshot = parameter_dump_packet.sy_lfr_n_swf_p[0]*256
1280 + parameter_dump_packet.sy_lfr_n_swf_p[1];
1280 + parameter_dump_packet.sy_lfr_n_swf_p[1];
1281
1281
1282 delta_snapshot_in_T2 = delta_snapshot * 256;
1282 delta_snapshot_in_T2 = delta_snapshot * 256;
1283 waveform_picker_regs->delta_snapshot = delta_snapshot_in_T2 - 1; // max 4 bytes
1283 waveform_picker_regs->delta_snapshot = delta_snapshot_in_T2 - 1; // max 4 bytes
1284 }
1284 }
1285
1285
1286 void set_wfp_delta_f0_f0_2( void )
1286 void set_wfp_delta_f0_f0_2( void )
1287 {
1287 {
1288 unsigned int delta_snapshot;
1288 unsigned int delta_snapshot;
1289 unsigned int nb_samples_per_snapshot;
1289 unsigned int nb_samples_per_snapshot;
1290 float delta_f0_in_float;
1290 float delta_f0_in_float;
1291
1291
1292 delta_snapshot = waveform_picker_regs->delta_snapshot;
1292 delta_snapshot = waveform_picker_regs->delta_snapshot;
1293 nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];
1293 nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];
1294 delta_f0_in_float =nb_samples_per_snapshot / 2. * ( 1. / 256. - 1. / 24576.) * 256.;
1294 delta_f0_in_float =nb_samples_per_snapshot / 2. * ( 1. / 256. - 1. / 24576.) * 256.;
1295
1295
1296 waveform_picker_regs->delta_f0 = delta_snapshot - floor( delta_f0_in_float );
1296 waveform_picker_regs->delta_f0 = delta_snapshot - floor( delta_f0_in_float );
1297 waveform_picker_regs->delta_f0_2 = 0x7; // max 7 bits
1297 waveform_picker_regs->delta_f0_2 = 0x7; // max 7 bits
1298 }
1298 }
1299
1299
1300 void set_wfp_delta_f1( void )
1300 void set_wfp_delta_f1( void )
1301 {
1301 {
1302 unsigned int delta_snapshot;
1302 unsigned int delta_snapshot;
1303 unsigned int nb_samples_per_snapshot;
1303 unsigned int nb_samples_per_snapshot;
1304 float delta_f1_in_float;
1304 float delta_f1_in_float;
1305
1305
1306 delta_snapshot = waveform_picker_regs->delta_snapshot;
1306 delta_snapshot = waveform_picker_regs->delta_snapshot;
1307 nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];
1307 nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];
1308 delta_f1_in_float = nb_samples_per_snapshot / 2. * ( 1. / 256. - 1. / 4096.) * 256.;
1308 delta_f1_in_float = nb_samples_per_snapshot / 2. * ( 1. / 256. - 1. / 4096.) * 256.;
1309
1309
1310 waveform_picker_regs->delta_f1 = delta_snapshot - floor( delta_f1_in_float );
1310 waveform_picker_regs->delta_f1 = delta_snapshot - floor( delta_f1_in_float );
1311 }
1311 }
1312
1312
1313 void set_wfp_delta_f2()
1313 void set_wfp_delta_f2()
1314 {
1314 {
1315 unsigned int delta_snapshot;
1315 unsigned int delta_snapshot;
1316 unsigned int nb_samples_per_snapshot;
1316 unsigned int nb_samples_per_snapshot;
1317
1317
1318 delta_snapshot = waveform_picker_regs->delta_snapshot;
1318 delta_snapshot = waveform_picker_regs->delta_snapshot;
1319 nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];
1319 nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];
1320
1320
1321 waveform_picker_regs->delta_f2 = delta_snapshot - nb_samples_per_snapshot / 2;
1321 waveform_picker_regs->delta_f2 = delta_snapshot - nb_samples_per_snapshot / 2;
1322 }
1322 }
1323
1323
1324 //*****************
1324 //*****************
1325 // local parameters
1325 // local parameters
1326
1326
1327 void increment_seq_counter_source_id( unsigned char *packet_sequence_control, unsigned int sid )
1327 void increment_seq_counter_source_id( unsigned char *packet_sequence_control, unsigned int sid )
1328 {
1328 {
1329 /** This function increments the parameter "sequence_cnt" depending on the sid passed in argument.
1329 /** This function increments the parameter "sequence_cnt" depending on the sid passed in argument.
1330 *
1330 *
1331 * @param packet_sequence_control is a pointer toward the parameter sequence_cnt to update.
1331 * @param packet_sequence_control is a pointer toward the parameter sequence_cnt to update.
1332 * @param sid is the source identifier of the packet being updated.
1332 * @param sid is the source identifier of the packet being updated.
1333 *
1333 *
1334 * REQ-LFR-SRS-5240 / SSS-CP-FS-590
1334 * REQ-LFR-SRS-5240 / SSS-CP-FS-590
1335 * The sequence counters shall wrap around from 2^14 to zero.
1335 * The sequence counters shall wrap around from 2^14 to zero.
1336 * The sequence counter shall start at zero at startup.
1336 * The sequence counter shall start at zero at startup.
1337 *
1337 *
1338 * REQ-LFR-SRS-5239 / SSS-CP-FS-580
1338 * REQ-LFR-SRS-5239 / SSS-CP-FS-580
1339 * All TM_LFR_SCIENCE_ packets are sent to ground, i.e. destination id = 0
1339 * All TM_LFR_SCIENCE_ packets are sent to ground, i.e. destination id = 0
1340 *
1340 *
1341 */
1341 */
1342
1342
1343 unsigned short *sequence_cnt;
1343 unsigned short *sequence_cnt;
1344 unsigned short segmentation_grouping_flag;
1344 unsigned short segmentation_grouping_flag;
1345 unsigned short new_packet_sequence_control;
1345 unsigned short new_packet_sequence_control;
1346 rtems_mode initial_mode_set;
1346 rtems_mode initial_mode_set;
1347 rtems_mode current_mode_set;
1347 rtems_mode current_mode_set;
1348 rtems_status_code status;
1348 rtems_status_code status;
1349
1349
1350 //******************************************
1350 //******************************************
1351 // CHANGE THE MODE OF THE CALLING RTEMS TASK
1351 // CHANGE THE MODE OF THE CALLING RTEMS TASK
1352 status = rtems_task_mode( RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &initial_mode_set );
1352 status = rtems_task_mode( RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &initial_mode_set );
1353
1353
1354 if ( (sid == SID_NORM_SWF_F0) || (sid == SID_NORM_SWF_F1) || (sid == SID_NORM_SWF_F2)
1354 if ( (sid == SID_NORM_SWF_F0) || (sid == SID_NORM_SWF_F1) || (sid == SID_NORM_SWF_F2)
1355 || (sid == SID_NORM_CWF_F3) || (sid == SID_NORM_CWF_LONG_F3)
1355 || (sid == SID_NORM_CWF_F3) || (sid == SID_NORM_CWF_LONG_F3)
1356 || (sid == SID_BURST_CWF_F2)
1356 || (sid == SID_BURST_CWF_F2)
1357 || (sid == SID_NORM_ASM_F0) || (sid == SID_NORM_ASM_F1) || (sid == SID_NORM_ASM_F2)
1357 || (sid == SID_NORM_ASM_F0) || (sid == SID_NORM_ASM_F1) || (sid == SID_NORM_ASM_F2)
1358 || (sid == SID_NORM_BP1_F0) || (sid == SID_NORM_BP1_F1) || (sid == SID_NORM_BP1_F2)
1358 || (sid == SID_NORM_BP1_F0) || (sid == SID_NORM_BP1_F1) || (sid == SID_NORM_BP1_F2)
1359 || (sid == SID_NORM_BP2_F0) || (sid == SID_NORM_BP2_F1) || (sid == SID_NORM_BP2_F2)
1359 || (sid == SID_NORM_BP2_F0) || (sid == SID_NORM_BP2_F1) || (sid == SID_NORM_BP2_F2)
1360 || (sid == SID_BURST_BP1_F0) || (sid == SID_BURST_BP2_F0)
1360 || (sid == SID_BURST_BP1_F0) || (sid == SID_BURST_BP2_F0)
1361 || (sid == SID_BURST_BP1_F1) || (sid == SID_BURST_BP2_F1) )
1361 || (sid == SID_BURST_BP1_F1) || (sid == SID_BURST_BP2_F1) )
1362 {
1362 {
1363 sequence_cnt = (unsigned short *) &sequenceCounters_SCIENCE_NORMAL_BURST;
1363 sequence_cnt = (unsigned short *) &sequenceCounters_SCIENCE_NORMAL_BURST;
1364 }
1364 }
1365 else if ( (sid ==SID_SBM1_CWF_F1) || (sid ==SID_SBM2_CWF_F2)
1365 else if ( (sid ==SID_SBM1_CWF_F1) || (sid ==SID_SBM2_CWF_F2)
1366 || (sid == SID_SBM1_BP1_F0) || (sid == SID_SBM1_BP2_F0)
1366 || (sid == SID_SBM1_BP1_F0) || (sid == SID_SBM1_BP2_F0)
1367 || (sid == SID_SBM2_BP1_F0) || (sid == SID_SBM2_BP2_F0)
1367 || (sid == SID_SBM2_BP1_F0) || (sid == SID_SBM2_BP2_F0)
1368 || (sid == SID_SBM2_BP1_F1) || (sid == SID_SBM2_BP2_F1) )
1368 || (sid == SID_SBM2_BP1_F1) || (sid == SID_SBM2_BP2_F1) )
1369 {
1369 {
1370 sequence_cnt = (unsigned short *) &sequenceCounters_SCIENCE_SBM1_SBM2;
1370 sequence_cnt = (unsigned short *) &sequenceCounters_SCIENCE_SBM1_SBM2;
1371 }
1371 }
1372 else
1372 else
1373 {
1373 {
1374 sequence_cnt = (unsigned short *) NULL;
1374 sequence_cnt = (unsigned short *) NULL;
1375 PRINTF1("in increment_seq_counter_source_id *** ERR apid_destid %d not known\n", sid)
1375 PRINTF1("in increment_seq_counter_source_id *** ERR apid_destid %d not known\n", sid)
1376 }
1376 }
1377
1377
1378 if (sequence_cnt != NULL)
1378 if (sequence_cnt != NULL)
1379 {
1379 {
1380 segmentation_grouping_flag = TM_PACKET_SEQ_CTRL_STANDALONE << 8;
1380 segmentation_grouping_flag = TM_PACKET_SEQ_CTRL_STANDALONE << 8;
1381 *sequence_cnt = (*sequence_cnt) & 0x3fff;
1381 *sequence_cnt = (*sequence_cnt) & 0x3fff;
1382
1382
1383 new_packet_sequence_control = segmentation_grouping_flag | (*sequence_cnt) ;
1383 new_packet_sequence_control = segmentation_grouping_flag | (*sequence_cnt) ;
1384
1384
1385 packet_sequence_control[0] = (unsigned char) (new_packet_sequence_control >> 8);
1385 packet_sequence_control[0] = (unsigned char) (new_packet_sequence_control >> 8);
1386 packet_sequence_control[1] = (unsigned char) (new_packet_sequence_control );
1386 packet_sequence_control[1] = (unsigned char) (new_packet_sequence_control );
1387
1387
1388 // increment the sequence counter
1388 // increment the sequence counter
1389 if ( *sequence_cnt < SEQ_CNT_MAX)
1389 if ( *sequence_cnt < SEQ_CNT_MAX)
1390 {
1390 {
1391 *sequence_cnt = *sequence_cnt + 1;
1391 *sequence_cnt = *sequence_cnt + 1;
1392 }
1392 }
1393 else
1393 else
1394 {
1394 {
1395 *sequence_cnt = 0;
1395 *sequence_cnt = 0;
1396 }
1396 }
1397 }
1397 }
1398
1398
1399 //***********************************
1399 //***********************************
1400 // RESET THE MODE OF THE CALLING TASK
1400 // RESET THE MODE OF THE CALLING TASK
1401 status = rtems_task_mode( initial_mode_set, RTEMS_PREEMPT_MASK, &current_mode_set );
1401 status = rtems_task_mode( initial_mode_set, RTEMS_PREEMPT_MASK, &current_mode_set );
1402 }
1402 }
General Comments 0
You need to be logged in to leave comments. Login now