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

Fork of HG_REPOSITORIES/LPP/INSTRUMENTATION/SOLO_LFR/DEV_PLE

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

Bug 906 calibration signal
paul -
r332:86c97c298d6e R3_plus draft
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,111 +1,115
1 1 #ifndef TC_HANDLER_H_INCLUDED
2 2 #define TC_HANDLER_H_INCLUDED
3 3
4 4 #include <rtems.h>
5 5 #include <leon.h>
6 6
7 7 #include "tc_load_dump_parameters.h"
8 8 #include "tc_acceptance.h"
9 9 #include "tm_lfr_tc_exe.h"
10 10 #include "wf_handler.h"
11 11 #include "fsw_processing.h"
12 12
13 13 #include "lfr_cpu_usage_report.h"
14 14
15 15 #define MAX_DELTA_COARSE_TIME 3
16 16 #define NB_SCIENCE_TASKS 10
17 17 #define NB_ASM_TASKS 6
18 18 #define STATUS_0 0
19 19 #define STATUS_1 1
20 20 #define STATUS_2 2
21 21 #define STATUS_3 3
22 22 #define STATUS_4 4
23 23 #define STATUS_5 5
24 24 #define STATUS_6 6
25 25 #define STATUS_7 7
26 26 #define STATUS_8 8
27 27 #define STATUS_9 9
28 28
29 #define CAL_F0 625
30 #define CAL_F1 10000
29 #define CAL_F0 625.
30 #define CAL_F1 10000.
31 #define CAL_W0 (2. * pi * CAL_F0)
32 #define CAL_W1 (2. * pi * CAL_F1)
33 #define CAL_A0 1.
34 #define CAL_A1 2.
31 35 #define CAL_FS 160256.410
32 36 #define CAL_SCALE_FACTOR (0.250 / 0.000654) // 191, 500 mVpp, 2 sinus waves => 500 mVpp each, amplitude = 250 mV
33 37 #define CAL_NB_PTS 256
34 38 #define CAL_DATA_MASK 0xfff
35 39 #define CAL_F_DIVISOR 38 // 25 MHz => 160 256 (39 - 1)
36 40 // INTERLEAVED MODE
37 41 #define CAL_FS_INTER 240384.615
38 42 #define CAL_NB_PTS_INTER 384
39 43 #define CAL_DATA_MASK_INTER 0x3f
40 44 #define CAL_DATA_SHIFT_INTER 12
41 45 #define BYTES_FOR_2_SAMPLES 3 // one need 3 bytes = 24 bits to store 3 samples of 12 bits in interleaved mode
42 46 #define STEPS_FOR_STORAGE_INTER 128
43 47 #define CAL_F_DIVISOR_INTER 26 // 25 MHz => 240 384
44 48
45 49 extern unsigned int lastValidEnterModeTime;
46 50 extern unsigned char oneTcLfrUpdateTimeReceived;
47 51
48 52 //****
49 53 // ISR
50 54 rtems_isr commutation_isr1( rtems_vector_number vector );
51 55 rtems_isr commutation_isr2( rtems_vector_number vector );
52 56
53 57 //***********
54 58 // RTEMS TASK
55 59 rtems_task actn_task( rtems_task_argument unused );
56 60
57 61 //***********
58 62 // TC ACTIONS
59 63 int action_reset( ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time );
60 64 int action_enter_mode(ccsdsTelecommandPacket_t *TC, rtems_id queue_id);
61 65 int action_update_info( ccsdsTelecommandPacket_t *TC, rtems_id queue_id );
62 66 int action_enable_calibration( ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time );
63 67 int action_disable_calibration( ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time );
64 68 int action_update_time( ccsdsTelecommandPacket_t *TC);
65 69
66 70 // mode transition
67 71 int check_mode_value( unsigned char requestedMode );
68 72 int check_mode_transition( unsigned char requestedMode );
69 73 void update_last_valid_transition_date( unsigned int transitionCoarseTime );
70 74 int check_transition_date( unsigned int transitionCoarseTime );
71 75 int stop_spectral_matrices( void );
72 76 int stop_current_mode( void );
73 77 int enter_mode_standby(void );
74 78 int enter_mode_normal( unsigned int transitionCoarseTime );
75 79 int enter_mode_burst( unsigned int transitionCoarseTime );
76 80 int enter_mode_sbm1( unsigned int transitionCoarseTime );
77 81 int enter_mode_sbm2( unsigned int transitionCoarseTime );
78 82 int restart_science_tasks( unsigned char lfrRequestedMode );
79 83 int restart_asm_tasks(unsigned char lfrRequestedMode );
80 84 int suspend_science_tasks(void);
81 85 int suspend_asm_tasks( void );
82 86 void launch_waveform_picker( unsigned char mode , unsigned int transitionCoarseTime );
83 87 void launch_spectral_matrix( void );
84 88 void set_sm_irq_onNewMatrix( unsigned char value );
85 89 void set_sm_irq_onError( unsigned char value );
86 90
87 91 // other functions
88 92 void updateLFRCurrentMode(unsigned char requestedMode);
89 93 void set_lfr_soft_reset( unsigned char value );
90 94 void reset_lfr( void );
91 95 // CALIBRATION
92 96 void setCalibrationPrescaler( unsigned int prescaler );
93 97 void setCalibrationDivisor( unsigned int divisionFactor );
94 98 void setCalibrationData( void );
95 99 void setCalibrationReload( bool state);
96 100 void setCalibrationEnable( bool state );
97 101 void setCalibrationInterleaved( bool state );
98 102 void setCalibration( bool state );
99 103 void configureCalibration( bool interleaved );
100 104 //
101 105 void update_last_TC_exe( ccsdsTelecommandPacket_t *TC , unsigned char *time );
102 106 void update_last_TC_rej(ccsdsTelecommandPacket_t *TC , unsigned char *time );
103 107 void close_action( ccsdsTelecommandPacket_t *TC, int result, rtems_id queue_id );
104 108
105 109 extern rtems_status_code get_message_queue_id_send( rtems_id *queue_id );
106 110 extern rtems_status_code get_message_queue_id_recv( rtems_id *queue_id );
107 111
108 112 #endif // TC_HANDLER_H_INCLUDED
109 113
110 114
111 115
Show file before | Show file after | Hide comments
@@ -1,107 +1,107
1 1 cmake_minimum_required (VERSION 2.6)
2 2 project (fsw)
3 3
4 4 include(sparc-rtems)
5 5 include(cppcheck)
6 6
7 7 include_directories("../header"
8 8 "../header/lfr_common_headers"
9 9 "../header/processing"
10 10 "../LFR_basic-parameters"
11 11 "../src")
12 12
13 13 set(SOURCES wf_handler.c
14 14 tc_handler.c
15 15 fsw_misc.c
16 16 fsw_init.c
17 17 fsw_globals.c
18 18 fsw_spacewire.c
19 19 tc_load_dump_parameters.c
20 20 tm_lfr_tc_exe.c
21 21 tc_acceptance.c
22 22 processing/fsw_processing.c
23 23 processing/avf0_prc0.c
24 24 processing/avf1_prc1.c
25 25 processing/avf2_prc2.c
26 26 lfr_cpu_usage_report.c
27 27 ${LFR_BP_SRC}
28 28 ../header/wf_handler.h
29 29 ../header/tc_handler.h
30 30 ../header/grlib_regs.h
31 31 ../header/fsw_misc.h
32 32 ../header/fsw_init.h
33 33 ../header/fsw_spacewire.h
34 34 ../header/tc_load_dump_parameters.h
35 35 ../header/tm_lfr_tc_exe.h
36 36 ../header/tc_acceptance.h
37 37 ../header/processing/fsw_processing.h
38 38 ../header/processing/avf0_prc0.h
39 39 ../header/processing/avf1_prc1.h
40 40 ../header/processing/avf2_prc2.h
41 41 ../header/fsw_params_wf_handler.h
42 42 ../header/lfr_cpu_usage_report.h
43 43 ../header/lfr_common_headers/ccsds_types.h
44 44 ../header/lfr_common_headers/fsw_params.h
45 45 ../header/lfr_common_headers/fsw_params_nb_bytes.h
46 46 ../header/lfr_common_headers/fsw_params_processing.h
47 47 ../header/lfr_common_headers/tm_byte_positions.h
48 48 ../LFR_basic-parameters/basic_parameters.h
49 49 ../LFR_basic-parameters/basic_parameters_params.h
50 50 ../header/GscMemoryLPP.hpp
51 51 )
52 52
53 53
54 54 option(FSW_verbose "Enable verbose LFR" OFF)
55 55 option(FSW_boot_messages "Enable LFR boot messages" OFF)
56 56 option(FSW_debug_messages "Enable LFR debug messages" OFF)
57 57 option(FSW_cpu_usage_report "Enable LFR cpu usage report" OFF)
58 58 option(FSW_stack_report "Enable LFR stack report" OFF)
59 59 option(FSW_vhdl_dev "?" OFF)
60 60 option(FSW_lpp_dpu_destid "Set to debug at LPP" ON)
61 61 option(FSW_debug_watchdog "Enable debug watchdog" OFF)
62 62 option(FSW_debug_tch "?" OFF)
63 63
64 64 set(SW_VERSION_N1 "3" CACHE STRING "Choose N1 FSW Version." FORCE)
65 65 set(SW_VERSION_N2 "1" CACHE STRING "Choose N2 FSW Version." FORCE)
66 66 set(SW_VERSION_N3 "0" CACHE STRING "Choose N3 FSW Version." FORCE)
67 set(SW_VERSION_N4 "5" CACHE STRING "Choose N4 FSW Version." FORCE)
67 set(SW_VERSION_N4 "6" CACHE STRING "Choose N4 FSW Version." FORCE)
68 68
69 69 if(FSW_verbose)
70 70 add_definitions(-DPRINT_MESSAGES_ON_CONSOLE)
71 71 endif()
72 72 if(FSW_boot_messages)
73 73 add_definitions(-DBOOT_MESSAGES)
74 74 endif()
75 75 if(FSW_debug_messages)
76 76 add_definitions(-DDEBUG_MESSAGES)
77 77 endif()
78 78 if(FSW_cpu_usage_report)
79 79 add_definitions(-DPRINT_TASK_STATISTICS)
80 80 endif()
81 81 if(FSW_stack_report)
82 82 add_definitions(-DPRINT_STACK_REPORT)
83 83 endif()
84 84 if(FSW_vhdl_dev)
85 85 add_definitions(-DVHDL_DEV)
86 86 endif()
87 87 if(FSW_lpp_dpu_destid)
88 88 add_definitions(-DLPP_DPU_DESTID)
89 89 endif()
90 90 if(FSW_debug_watchdog)
91 91 add_definitions(-DDEBUG_WATCHDOG)
92 92 endif()
93 93 if(FSW_debug_tch)
94 94 add_definitions(-DDEBUG_TCH)
95 95 endif()
96 96
97 97 add_definitions(-DMSB_FIRST_TCH)
98 98
99 99 add_definitions(-DSWVERSION=-1-0)
100 100 add_definitions(-DSW_VERSION_N1=${SW_VERSION_N1})
101 101 add_definitions(-DSW_VERSION_N2=${SW_VERSION_N2})
102 102 add_definitions(-DSW_VERSION_N3=${SW_VERSION_N3})
103 103 add_definitions(-DSW_VERSION_N4=${SW_VERSION_N4})
104 104
105 105 add_executable(fsw ${SOURCES})
106 106 add_test_cppcheck(fsw STYLE UNUSED_FUNCTIONS POSSIBLE_ERROR MISSING_INCLUDE)
107 107
Show file before | Show file after | Hide comments
@@ -1,1669 +1,1668
1 1 /** Functions and tasks related to TeleCommand handling.
2 2 *
3 3 * @file
4 4 * @author P. LEROY
5 5 *
6 6 * A group of functions to handle TeleCommands:\n
7 7 * action launching\n
8 8 * TC parsing\n
9 9 * ...
10 10 *
11 11 */
12 12
13 13 #include "tc_handler.h"
14 14 #include "math.h"
15 15
16 16 //***********
17 17 // RTEMS TASK
18 18
19 19 rtems_task actn_task( rtems_task_argument unused )
20 20 {
21 21 /** This RTEMS task is responsible for launching actions upton the reception of valid TeleCommands.
22 22 *
23 23 * @param unused is the starting argument of the RTEMS task
24 24 *
25 25 * The ACTN task waits for data coming from an RTEMS msesage queue. When data arrives, it launches specific actions depending
26 26 * on the incoming TeleCommand.
27 27 *
28 28 */
29 29
30 30 int result;
31 31 rtems_status_code status; // RTEMS status code
32 32 ccsdsTelecommandPacket_t __attribute__((aligned(4))) TC; // TC sent to the ACTN task
33 33 size_t size; // size of the incoming TC packet
34 34 unsigned char subtype; // subtype of the current TC packet
35 35 unsigned char time[BYTES_PER_TIME];
36 36 rtems_id queue_rcv_id;
37 37 rtems_id queue_snd_id;
38 38
39 39 memset(&TC, 0, sizeof(ccsdsTelecommandPacket_t));
40 40 size = 0;
41 41 queue_rcv_id = RTEMS_ID_NONE;
42 42 queue_snd_id = RTEMS_ID_NONE;
43 43
44 44 status = get_message_queue_id_recv( &queue_rcv_id );
45 45 if (status != RTEMS_SUCCESSFUL)
46 46 {
47 47 PRINTF1("in ACTN *** ERR get_message_queue_id_recv %d\n", status)
48 48 }
49 49
50 50 status = get_message_queue_id_send( &queue_snd_id );
51 51 if (status != RTEMS_SUCCESSFUL)
52 52 {
53 53 PRINTF1("in ACTN *** ERR get_message_queue_id_send %d\n", status)
54 54 }
55 55
56 56 result = LFR_SUCCESSFUL;
57 57 subtype = 0; // subtype of the current TC packet
58 58
59 59 BOOT_PRINTF("in ACTN *** \n");
60 60
61 61 while(1)
62 62 {
63 63 status = rtems_message_queue_receive( queue_rcv_id, (char*) &TC, &size,
64 64 RTEMS_WAIT, RTEMS_NO_TIMEOUT);
65 65 getTime( time ); // set time to the current time
66 66 if (status!=RTEMS_SUCCESSFUL)
67 67 {
68 68 PRINTF1("ERR *** in task ACTN *** error receiving a message, code %d \n", status)
69 69 }
70 70 else
71 71 {
72 72 subtype = TC.serviceSubType;
73 73 switch(subtype)
74 74 {
75 75 case TC_SUBTYPE_RESET:
76 76 result = action_reset( &TC, queue_snd_id, time );
77 77 close_action( &TC, result, queue_snd_id );
78 78 break;
79 79 case TC_SUBTYPE_LOAD_COMM:
80 80 result = action_load_common_par( &TC );
81 81 close_action( &TC, result, queue_snd_id );
82 82 break;
83 83 case TC_SUBTYPE_LOAD_NORM:
84 84 result = action_load_normal_par( &TC, queue_snd_id, time );
85 85 close_action( &TC, result, queue_snd_id );
86 86 break;
87 87 case TC_SUBTYPE_LOAD_BURST:
88 88 result = action_load_burst_par( &TC, queue_snd_id, time );
89 89 close_action( &TC, result, queue_snd_id );
90 90 break;
91 91 case TC_SUBTYPE_LOAD_SBM1:
92 92 result = action_load_sbm1_par( &TC, queue_snd_id, time );
93 93 close_action( &TC, result, queue_snd_id );
94 94 break;
95 95 case TC_SUBTYPE_LOAD_SBM2:
96 96 result = action_load_sbm2_par( &TC, queue_snd_id, time );
97 97 close_action( &TC, result, queue_snd_id );
98 98 break;
99 99 case TC_SUBTYPE_DUMP:
100 100 result = action_dump_par( &TC, queue_snd_id );
101 101 close_action( &TC, result, queue_snd_id );
102 102 break;
103 103 case TC_SUBTYPE_ENTER:
104 104 result = action_enter_mode( &TC, queue_snd_id );
105 105 close_action( &TC, result, queue_snd_id );
106 106 break;
107 107 case TC_SUBTYPE_UPDT_INFO:
108 108 result = action_update_info( &TC, queue_snd_id );
109 109 close_action( &TC, result, queue_snd_id );
110 110 break;
111 111 case TC_SUBTYPE_EN_CAL:
112 112 result = action_enable_calibration( &TC, queue_snd_id, time );
113 113 close_action( &TC, result, queue_snd_id );
114 114 break;
115 115 case TC_SUBTYPE_DIS_CAL:
116 116 result = action_disable_calibration( &TC, queue_snd_id, time );
117 117 close_action( &TC, result, queue_snd_id );
118 118 break;
119 119 case TC_SUBTYPE_LOAD_K:
120 120 result = action_load_kcoefficients( &TC, queue_snd_id, time );
121 121 close_action( &TC, result, queue_snd_id );
122 122 break;
123 123 case TC_SUBTYPE_DUMP_K:
124 124 result = action_dump_kcoefficients( &TC, queue_snd_id, time );
125 125 close_action( &TC, result, queue_snd_id );
126 126 break;
127 127 case TC_SUBTYPE_LOAD_FBINS:
128 128 result = action_load_fbins_mask( &TC, queue_snd_id, time );
129 129 close_action( &TC, result, queue_snd_id );
130 130 break;
131 131 case TC_SUBTYPE_LOAD_FILTER_PAR:
132 132 result = action_load_filter_par( &TC, queue_snd_id, time );
133 133 close_action( &TC, result, queue_snd_id );
134 134 break;
135 135 case TC_SUBTYPE_UPDT_TIME:
136 136 result = action_update_time( &TC );
137 137 close_action( &TC, result, queue_snd_id );
138 138 break;
139 139 default:
140 140 break;
141 141 }
142 142 }
143 143 }
144 144 }
145 145
146 146 //***********
147 147 // TC ACTIONS
148 148
149 149 int action_reset(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
150 150 {
151 151 /** This function executes specific actions when a TC_LFR_RESET TeleCommand has been received.
152 152 *
153 153 * @param TC points to the TeleCommand packet that is being processed
154 154 * @param queue_id is the id of the queue which handles TM transmission by the SpaceWire driver
155 155 *
156 156 */
157 157
158 158 PRINTF("this is the end!!!\n");
159 159 exit(0);
160 160
161 161 send_tm_lfr_tc_exe_not_implemented( TC, queue_id, time );
162 162
163 163 return LFR_DEFAULT;
164 164 }
165 165
166 166 int action_enter_mode(ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
167 167 {
168 168 /** This function executes specific actions when a TC_LFR_ENTER_MODE TeleCommand has been received.
169 169 *
170 170 * @param TC points to the TeleCommand packet that is being processed
171 171 * @param queue_id is the id of the queue which handles TM transmission by the SpaceWire driver
172 172 *
173 173 */
174 174
175 175 rtems_status_code status;
176 176 unsigned char requestedMode;
177 unsigned int *transitionCoarseTime_ptr;
178 177 unsigned int transitionCoarseTime;
179 178 unsigned char * bytePosPtr;
180 179
181 180 printf("(0)\n");
182 181 bytePosPtr = (unsigned char *) &TC->packetID;
183 182 printf("(1)\n");
184 183 requestedMode = bytePosPtr[ BYTE_POS_CP_MODE_LFR_SET ];
185 184 printf("(2)\n");
186 copyInt32ByChar( &transitionCoarseTime, &bytePosPtr[ BYTE_POS_CP_LFR_ENTER_MODE_TIME ] );
185 copyInt32ByChar( (char*) &transitionCoarseTime, &bytePosPtr[ BYTE_POS_CP_LFR_ENTER_MODE_TIME ] );
187 186 printf("(3)\n");
188 187 transitionCoarseTime = transitionCoarseTime & COARSE_TIME_MASK;
189 188 printf("(4)\n");
190 189 status = check_mode_value( requestedMode );
191 190 printf("(5)\n");
192 191
193 192 if ( status != LFR_SUCCESSFUL ) // the mode value is inconsistent
194 193 {
195 194 send_tm_lfr_tc_exe_inconsistent( TC, queue_id, BYTE_POS_CP_MODE_LFR_SET, requestedMode );
196 195 }
197 196
198 197 else // the mode value is valid, check the transition
199 198 {
200 199 status = check_mode_transition(requestedMode);
201 200 if (status != LFR_SUCCESSFUL)
202 201 {
203 202 PRINTF("ERR *** in action_enter_mode *** check_mode_transition\n")
204 203 send_tm_lfr_tc_exe_not_executable( TC, queue_id );
205 204 }
206 205 }
207 206
208 207 if ( status == LFR_SUCCESSFUL ) // the transition is valid, check the date
209 208 {
210 209 status = check_transition_date( transitionCoarseTime );
211 210 if (status != LFR_SUCCESSFUL)
212 211 {
213 212 PRINTF("ERR *** in action_enter_mode *** check_transition_date\n");
214 213 send_tm_lfr_tc_exe_not_executable(TC, queue_id );
215 214 }
216 215 }
217 216
218 217 if ( status == LFR_SUCCESSFUL ) // the date is valid, enter the mode
219 218 {
220 219 PRINTF1("OK *** in action_enter_mode *** enter mode %d\n", requestedMode);
221 220
222 221 switch(requestedMode)
223 222 {
224 223 case LFR_MODE_STANDBY:
225 224 status = enter_mode_standby();
226 225 break;
227 226 case LFR_MODE_NORMAL:
228 227 status = enter_mode_normal( transitionCoarseTime );
229 228 break;
230 229 case LFR_MODE_BURST:
231 230 status = enter_mode_burst( transitionCoarseTime );
232 231 break;
233 232 case LFR_MODE_SBM1:
234 233 status = enter_mode_sbm1( transitionCoarseTime );
235 234 break;
236 235 case LFR_MODE_SBM2:
237 236 status = enter_mode_sbm2( transitionCoarseTime );
238 237 break;
239 238 default:
240 239 break;
241 240 }
242 241
243 242 if (status != RTEMS_SUCCESSFUL)
244 243 {
245 244 status = LFR_EXE_ERROR;
246 245 }
247 246 }
248 247
249 248 return status;
250 249 }
251 250
252 251 int action_update_info(ccsdsTelecommandPacket_t *TC, rtems_id queue_id)
253 252 {
254 253 /** This function executes specific actions when a TC_LFR_UPDATE_INFO TeleCommand has been received.
255 254 *
256 255 * @param TC points to the TeleCommand packet that is being processed
257 256 * @param queue_id is the id of the queue which handles TM transmission by the SpaceWire driver
258 257 *
259 258 * @return LFR directive status code:
260 259 * - LFR_DEFAULT
261 260 * - LFR_SUCCESSFUL
262 261 *
263 262 */
264 263
265 264 unsigned int val;
266 265 int result;
267 266 unsigned int status;
268 267 unsigned char mode;
269 268 unsigned char * bytePosPtr;
270 269
271 270 bytePosPtr = (unsigned char *) &TC->packetID;
272 271
273 272 // check LFR mode
274 273 mode = (bytePosPtr[ BYTE_POS_UPDATE_INFO_PARAMETERS_SET5 ] & BITS_LFR_MODE) >> SHIFT_LFR_MODE;
275 274 status = check_update_info_hk_lfr_mode( mode );
276 275 if (status == LFR_SUCCESSFUL) // check TDS mode
277 276 {
278 277 mode = (bytePosPtr[ BYTE_POS_UPDATE_INFO_PARAMETERS_SET6 ] & BITS_TDS_MODE) >> SHIFT_TDS_MODE;
279 278 status = check_update_info_hk_tds_mode( mode );
280 279 }
281 280 if (status == LFR_SUCCESSFUL) // check THR mode
282 281 {
283 282 mode = (bytePosPtr[ BYTE_POS_UPDATE_INFO_PARAMETERS_SET6 ] & BITS_THR_MODE);
284 283 status = check_update_info_hk_thr_mode( mode );
285 284 }
286 285 if (status == LFR_SUCCESSFUL) // if the parameter check is successful
287 286 {
288 287 val = (housekeeping_packet.hk_lfr_update_info_tc_cnt[0] * CONST_256)
289 288 + housekeeping_packet.hk_lfr_update_info_tc_cnt[1];
290 289 val++;
291 290 housekeeping_packet.hk_lfr_update_info_tc_cnt[0] = (unsigned char) (val >> SHIFT_1_BYTE);
292 291 housekeeping_packet.hk_lfr_update_info_tc_cnt[1] = (unsigned char) (val);
293 292 }
294 293
295 294 // pa_bia_status_info
296 295 // => pa_bia_mode_mux_set 3 bits
297 296 // => pa_bia_mode_hv_enabled 1 bit
298 297 // => pa_bia_mode_bias1_enabled 1 bit
299 298 // => pa_bia_mode_bias2_enabled 1 bit
300 299 // => pa_bia_mode_bias3_enabled 1 bit
301 300 // => pa_bia_on_off (cp_dpu_bias_on_off)
302 301 pa_bia_status_info = bytePosPtr[ BYTE_POS_UPDATE_INFO_PARAMETERS_SET2 ] & BITS_BIA; // [1111 1110]
303 302 pa_bia_status_info = pa_bia_status_info
304 303 | (bytePosPtr[ BYTE_POS_UPDATE_INFO_PARAMETERS_SET1 ] & 1);
305 304
306 305 // REACTION_WHEELS_FREQUENCY, copy the incoming parameters in the local variable (to be copied in HK packets)
307 306
308 307 cp_rpw_sc_rw_f_flags = bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW_F_FLAGS ];
309 308 getReactionWheelsFrequencies( TC );
310 309 build_sy_lfr_rw_masks();
311 310
312 311 // once the masks are built, they have to be merged with the fbins_mask
313 312 merge_fbins_masks();
314 313
315 314 result = status;
316 315
317 316 return result;
318 317 }
319 318
320 319 int action_enable_calibration(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
321 320 {
322 321 /** This function executes specific actions when a TC_LFR_ENABLE_CALIBRATION TeleCommand has been received.
323 322 *
324 323 * @param TC points to the TeleCommand packet that is being processed
325 324 * @param queue_id is the id of the queue which handles TM transmission by the SpaceWire driver
326 325 *
327 326 */
328 327
329 328 int result;
330 329
331 330 result = LFR_DEFAULT;
332 331
333 332 setCalibration( true );
334 333
335 334 result = LFR_SUCCESSFUL;
336 335
337 336 return result;
338 337 }
339 338
340 339 int action_disable_calibration(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
341 340 {
342 341 /** This function executes specific actions when a TC_LFR_DISABLE_CALIBRATION TeleCommand has been received.
343 342 *
344 343 * @param TC points to the TeleCommand packet that is being processed
345 344 * @param queue_id is the id of the queue which handles TM transmission by the SpaceWire driver
346 345 *
347 346 */
348 347
349 348 int result;
350 349
351 350 result = LFR_DEFAULT;
352 351
353 352 setCalibration( false );
354 353
355 354 result = LFR_SUCCESSFUL;
356 355
357 356 return result;
358 357 }
359 358
360 359 int action_update_time(ccsdsTelecommandPacket_t *TC)
361 360 {
362 361 /** This function executes specific actions when a TC_LFR_UPDATE_TIME TeleCommand has been received.
363 362 *
364 363 * @param TC points to the TeleCommand packet that is being processed
365 364 * @param queue_id is the id of the queue which handles TM transmission by the SpaceWire driver
366 365 *
367 366 * @return LFR_SUCCESSFUL
368 367 *
369 368 */
370 369
371 370 unsigned int val;
372 371
373 372 time_management_regs->coarse_time_load = (TC->dataAndCRC[BYTE_0] << SHIFT_3_BYTES)
374 373 + (TC->dataAndCRC[BYTE_1] << SHIFT_2_BYTES)
375 374 + (TC->dataAndCRC[BYTE_2] << SHIFT_1_BYTE)
376 375 + TC->dataAndCRC[BYTE_3];
377 376
378 377 val = (housekeeping_packet.hk_lfr_update_time_tc_cnt[0] * CONST_256)
379 378 + housekeeping_packet.hk_lfr_update_time_tc_cnt[1];
380 379 val++;
381 380 housekeeping_packet.hk_lfr_update_time_tc_cnt[0] = (unsigned char) (val >> SHIFT_1_BYTE);
382 381 housekeeping_packet.hk_lfr_update_time_tc_cnt[1] = (unsigned char) (val);
383 382
384 383 oneTcLfrUpdateTimeReceived = 1;
385 384
386 385 return LFR_SUCCESSFUL;
387 386 }
388 387
389 388 //*******************
390 389 // ENTERING THE MODES
391 390 int check_mode_value( unsigned char requestedMode )
392 391 {
393 392 int status;
394 393
395 394 status = LFR_DEFAULT;
396 395
397 396 if ( (requestedMode != LFR_MODE_STANDBY)
398 397 && (requestedMode != LFR_MODE_NORMAL) && (requestedMode != LFR_MODE_BURST)
399 398 && (requestedMode != LFR_MODE_SBM1) && (requestedMode != LFR_MODE_SBM2) )
400 399 {
401 400 status = LFR_DEFAULT;
402 401 }
403 402 else
404 403 {
405 404 status = LFR_SUCCESSFUL;
406 405 }
407 406
408 407 return status;
409 408 }
410 409
411 410 int check_mode_transition( unsigned char requestedMode )
412 411 {
413 412 /** This function checks the validity of the transition requested by the TC_LFR_ENTER_MODE.
414 413 *
415 414 * @param requestedMode is the mode requested by the TC_LFR_ENTER_MODE
416 415 *
417 416 * @return LFR directive status codes:
418 417 * - LFR_SUCCESSFUL - the transition is authorized
419 418 * - LFR_DEFAULT - the transition is not authorized
420 419 *
421 420 */
422 421
423 422 int status;
424 423
425 424 switch (requestedMode)
426 425 {
427 426 case LFR_MODE_STANDBY:
428 427 if ( lfrCurrentMode == LFR_MODE_STANDBY ) {
429 428 status = LFR_DEFAULT;
430 429 }
431 430 else
432 431 {
433 432 status = LFR_SUCCESSFUL;
434 433 }
435 434 break;
436 435 case LFR_MODE_NORMAL:
437 436 if ( lfrCurrentMode == LFR_MODE_NORMAL ) {
438 437 status = LFR_DEFAULT;
439 438 }
440 439 else {
441 440 status = LFR_SUCCESSFUL;
442 441 }
443 442 break;
444 443 case LFR_MODE_BURST:
445 444 if ( lfrCurrentMode == LFR_MODE_BURST ) {
446 445 status = LFR_DEFAULT;
447 446 }
448 447 else {
449 448 status = LFR_SUCCESSFUL;
450 449 }
451 450 break;
452 451 case LFR_MODE_SBM1:
453 452 if ( lfrCurrentMode == LFR_MODE_SBM1 ) {
454 453 status = LFR_DEFAULT;
455 454 }
456 455 else {
457 456 status = LFR_SUCCESSFUL;
458 457 }
459 458 break;
460 459 case LFR_MODE_SBM2:
461 460 if ( lfrCurrentMode == LFR_MODE_SBM2 ) {
462 461 status = LFR_DEFAULT;
463 462 }
464 463 else {
465 464 status = LFR_SUCCESSFUL;
466 465 }
467 466 break;
468 467 default:
469 468 status = LFR_DEFAULT;
470 469 break;
471 470 }
472 471
473 472 return status;
474 473 }
475 474
476 475 void update_last_valid_transition_date( unsigned int transitionCoarseTime )
477 476 {
478 477 if (transitionCoarseTime == 0)
479 478 {
480 479 lastValidEnterModeTime = time_management_regs->coarse_time + 1;
481 480 PRINTF1("lastValidEnterModeTime = 0x%x (transitionCoarseTime = 0 => coarse_time+1)\n", lastValidEnterModeTime);
482 481 }
483 482 else
484 483 {
485 484 lastValidEnterModeTime = transitionCoarseTime;
486 485 PRINTF1("lastValidEnterModeTime = 0x%x\n", transitionCoarseTime);
487 486 }
488 487 }
489 488
490 489 int check_transition_date( unsigned int transitionCoarseTime )
491 490 {
492 491 int status;
493 492 unsigned int localCoarseTime;
494 493 unsigned int deltaCoarseTime;
495 494
496 495 status = LFR_SUCCESSFUL;
497 496
498 497 if (transitionCoarseTime == 0) // transition time = 0 means an instant transition
499 498 {
500 499 status = LFR_SUCCESSFUL;
501 500 }
502 501 else
503 502 {
504 503 localCoarseTime = time_management_regs->coarse_time & COARSE_TIME_MASK;
505 504
506 505 PRINTF2("localTime = %x, transitionTime = %x\n", localCoarseTime, transitionCoarseTime);
507 506
508 507 if ( transitionCoarseTime <= localCoarseTime ) // SSS-CP-EQS-322
509 508 {
510 509 status = LFR_DEFAULT;
511 510 PRINTF("ERR *** in check_transition_date *** transitionCoarseTime <= localCoarseTime\n");
512 511 }
513 512
514 513 if (status == LFR_SUCCESSFUL)
515 514 {
516 515 deltaCoarseTime = transitionCoarseTime - localCoarseTime;
517 516 if ( deltaCoarseTime > MAX_DELTA_COARSE_TIME ) // SSS-CP-EQS-323
518 517 {
519 518 status = LFR_DEFAULT;
520 519 PRINTF1("ERR *** in check_transition_date *** deltaCoarseTime = %x\n", deltaCoarseTime)
521 520 }
522 521 }
523 522 }
524 523
525 524 return status;
526 525 }
527 526
528 527 int restart_asm_activities( unsigned char lfrRequestedMode )
529 528 {
530 529 rtems_status_code status;
531 530
532 531 status = stop_spectral_matrices();
533 532
534 533 thisIsAnASMRestart = 1;
535 534
536 535 status = restart_asm_tasks( lfrRequestedMode );
537 536
538 537 launch_spectral_matrix();
539 538
540 539 return status;
541 540 }
542 541
543 542 int stop_spectral_matrices( void )
544 543 {
545 544 /** This function stops and restarts the current mode average spectral matrices activities.
546 545 *
547 546 * @return RTEMS directive status codes:
548 547 * - RTEMS_SUCCESSFUL - task restarted successfully
549 548 * - RTEMS_INVALID_ID - task id invalid
550 549 * - RTEMS_ALREADY_SUSPENDED - task already suspended
551 550 *
552 551 */
553 552
554 553 rtems_status_code status;
555 554
556 555 status = RTEMS_SUCCESSFUL;
557 556
558 557 // (1) mask interruptions
559 558 LEON_Mask_interrupt( IRQ_SPECTRAL_MATRIX ); // mask spectral matrix interrupt
560 559
561 560 // (2) reset spectral matrices registers
562 561 set_sm_irq_onNewMatrix( 0 ); // stop the spectral matrices
563 562 reset_sm_status();
564 563
565 564 // (3) clear interruptions
566 565 LEON_Clear_interrupt( IRQ_SPECTRAL_MATRIX ); // clear spectral matrix interrupt
567 566
568 567 // suspend several tasks
569 568 if (lfrCurrentMode != LFR_MODE_STANDBY) {
570 569 status = suspend_asm_tasks();
571 570 }
572 571
573 572 if (status != RTEMS_SUCCESSFUL)
574 573 {
575 574 PRINTF1("in stop_current_mode *** in suspend_science_tasks *** ERR code: %d\n", status)
576 575 }
577 576
578 577 return status;
579 578 }
580 579
581 580 int stop_current_mode( void )
582 581 {
583 582 /** This function stops the current mode by masking interrupt lines and suspending science tasks.
584 583 *
585 584 * @return RTEMS directive status codes:
586 585 * - RTEMS_SUCCESSFUL - task restarted successfully
587 586 * - RTEMS_INVALID_ID - task id invalid
588 587 * - RTEMS_ALREADY_SUSPENDED - task already suspended
589 588 *
590 589 */
591 590
592 591 rtems_status_code status;
593 592
594 593 status = RTEMS_SUCCESSFUL;
595 594
596 595 // (1) mask interruptions
597 596 LEON_Mask_interrupt( IRQ_WAVEFORM_PICKER ); // mask waveform picker interrupt
598 597 LEON_Mask_interrupt( IRQ_SPECTRAL_MATRIX ); // clear spectral matrix interrupt
599 598
600 599 // (2) reset waveform picker registers
601 600 reset_wfp_burst_enable(); // reset burst and enable bits
602 601 reset_wfp_status(); // reset all the status bits
603 602
604 603 // (3) reset spectral matrices registers
605 604 set_sm_irq_onNewMatrix( 0 ); // stop the spectral matrices
606 605 reset_sm_status();
607 606
608 607 // reset lfr VHDL module
609 608 reset_lfr();
610 609
611 610 reset_extractSWF(); // reset the extractSWF flag to false
612 611
613 612 // (4) clear interruptions
614 613 LEON_Clear_interrupt( IRQ_WAVEFORM_PICKER ); // clear waveform picker interrupt
615 614 LEON_Clear_interrupt( IRQ_SPECTRAL_MATRIX ); // clear spectral matrix interrupt
616 615
617 616 // suspend several tasks
618 617 if (lfrCurrentMode != LFR_MODE_STANDBY) {
619 618 status = suspend_science_tasks();
620 619 }
621 620
622 621 if (status != RTEMS_SUCCESSFUL)
623 622 {
624 623 PRINTF1("in stop_current_mode *** in suspend_science_tasks *** ERR code: %d\n", status)
625 624 }
626 625
627 626 return status;
628 627 }
629 628
630 629 int enter_mode_standby( void )
631 630 {
632 631 /** This function is used to put LFR in the STANDBY mode.
633 632 *
634 633 * @param transitionCoarseTime is the requested transition time contained in the TC_LFR_ENTER_MODE
635 634 *
636 635 * @return RTEMS directive status codes:
637 636 * - RTEMS_SUCCESSFUL - task restarted successfully
638 637 * - RTEMS_INVALID_ID - task id invalid
639 638 * - RTEMS_INCORRECT_STATE - task never started
640 639 * - RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot restart remote task
641 640 *
642 641 * The STANDBY mode does not depends on a specific transition date, the effect of the TC_LFR_ENTER_MODE
643 642 * is immediate.
644 643 *
645 644 */
646 645
647 646 int status;
648 647
649 648 status = stop_current_mode(); // STOP THE CURRENT MODE
650 649
651 650 #ifdef PRINT_TASK_STATISTICS
652 651 rtems_cpu_usage_report();
653 652 #endif
654 653
655 654 #ifdef PRINT_STACK_REPORT
656 655 PRINTF("stack report selected\n")
657 656 rtems_stack_checker_report_usage();
658 657 #endif
659 658
660 659 return status;
661 660 }
662 661
663 662 int enter_mode_normal( unsigned int transitionCoarseTime )
664 663 {
665 664 /** This function is used to start the NORMAL mode.
666 665 *
667 666 * @param transitionCoarseTime is the requested transition time contained in the TC_LFR_ENTER_MODE
668 667 *
669 668 * @return RTEMS directive status codes:
670 669 * - RTEMS_SUCCESSFUL - task restarted successfully
671 670 * - RTEMS_INVALID_ID - task id invalid
672 671 * - RTEMS_INCORRECT_STATE - task never started
673 672 * - RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot restart remote task
674 673 *
675 674 * The way the NORMAL mode is started depends on the LFR current mode. If LFR is in SBM1 or SBM2,
676 675 * the snapshots are not restarted, only ASM, BP and CWF data generation are affected.
677 676 *
678 677 */
679 678
680 679 int status;
681 680
682 681 #ifdef PRINT_TASK_STATISTICS
683 682 rtems_cpu_usage_reset();
684 683 #endif
685 684
686 685 status = RTEMS_UNSATISFIED;
687 686
688 687 printf("hop\n");
689 688
690 689 switch( lfrCurrentMode )
691 690 {
692 691 case LFR_MODE_STANDBY:
693 692 status = restart_science_tasks( LFR_MODE_NORMAL ); // restart science tasks
694 693 if (status == RTEMS_SUCCESSFUL) // relaunch spectral_matrix and waveform_picker modules
695 694 {
696 695 launch_spectral_matrix( );
697 696 launch_waveform_picker( LFR_MODE_NORMAL, transitionCoarseTime );
698 697 }
699 698 break;
700 699 case LFR_MODE_BURST:
701 700 status = stop_current_mode(); // stop the current mode
702 701 status = restart_science_tasks( LFR_MODE_NORMAL ); // restart the science tasks
703 702 if (status == RTEMS_SUCCESSFUL) // relaunch spectral_matrix and waveform_picker modules
704 703 {
705 704 launch_spectral_matrix( );
706 705 launch_waveform_picker( LFR_MODE_NORMAL, transitionCoarseTime );
707 706 }
708 707 break;
709 708 case LFR_MODE_SBM1:
710 709 status = restart_asm_activities( LFR_MODE_NORMAL ); // this is necessary to restart ASM tasks to update the parameters
711 710 status = LFR_SUCCESSFUL; // lfrCurrentMode will be updated after the execution of close_action
712 711 update_last_valid_transition_date( transitionCoarseTime );
713 712 break;
714 713 case LFR_MODE_SBM2:
715 714 status = restart_asm_activities( LFR_MODE_NORMAL ); // this is necessary to restart ASM tasks to update the parameters
716 715 status = LFR_SUCCESSFUL; // lfrCurrentMode will be updated after the execution of close_action
717 716 update_last_valid_transition_date( transitionCoarseTime );
718 717 break;
719 718 default:
720 719 break;
721 720 }
722 721
723 722 if (status != RTEMS_SUCCESSFUL)
724 723 {
725 724 PRINTF1("ERR *** in enter_mode_normal *** status = %d\n", status)
726 725 status = RTEMS_UNSATISFIED;
727 726 }
728 727
729 728 return status;
730 729 }
731 730
732 731 int enter_mode_burst( unsigned int transitionCoarseTime )
733 732 {
734 733 /** This function is used to start the BURST mode.
735 734 *
736 735 * @param transitionCoarseTime is the requested transition time contained in the TC_LFR_ENTER_MODE
737 736 *
738 737 * @return RTEMS directive status codes:
739 738 * - RTEMS_SUCCESSFUL - task restarted successfully
740 739 * - RTEMS_INVALID_ID - task id invalid
741 740 * - RTEMS_INCORRECT_STATE - task never started
742 741 * - RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot restart remote task
743 742 *
744 743 * The way the BURST mode is started does not depend on the LFR current mode.
745 744 *
746 745 */
747 746
748 747
749 748 int status;
750 749
751 750 #ifdef PRINT_TASK_STATISTICS
752 751 rtems_cpu_usage_reset();
753 752 #endif
754 753
755 754 status = stop_current_mode(); // stop the current mode
756 755 status = restart_science_tasks( LFR_MODE_BURST ); // restart the science tasks
757 756 if (status == RTEMS_SUCCESSFUL) // relaunch spectral_matrix and waveform_picker modules
758 757 {
759 758 launch_spectral_matrix( );
760 759 launch_waveform_picker( LFR_MODE_BURST, transitionCoarseTime );
761 760 }
762 761
763 762 if (status != RTEMS_SUCCESSFUL)
764 763 {
765 764 PRINTF1("ERR *** in enter_mode_burst *** status = %d\n", status)
766 765 status = RTEMS_UNSATISFIED;
767 766 }
768 767
769 768 return status;
770 769 }
771 770
772 771 int enter_mode_sbm1( unsigned int transitionCoarseTime )
773 772 {
774 773 /** This function is used to start the SBM1 mode.
775 774 *
776 775 * @param transitionCoarseTime is the requested transition time contained in the TC_LFR_ENTER_MODE
777 776 *
778 777 * @return RTEMS directive status codes:
779 778 * - RTEMS_SUCCESSFUL - task restarted successfully
780 779 * - RTEMS_INVALID_ID - task id invalid
781 780 * - RTEMS_INCORRECT_STATE - task never started
782 781 * - RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot restart remote task
783 782 *
784 783 * The way the SBM1 mode is started depends on the LFR current mode. If LFR is in NORMAL or SBM2,
785 784 * the snapshots are not restarted, only ASM, BP and CWF data generation are affected. In other
786 785 * cases, the acquisition is completely restarted.
787 786 *
788 787 */
789 788
790 789 int status;
791 790
792 791 #ifdef PRINT_TASK_STATISTICS
793 792 rtems_cpu_usage_reset();
794 793 #endif
795 794
796 795 status = RTEMS_UNSATISFIED;
797 796
798 797 switch( lfrCurrentMode )
799 798 {
800 799 case LFR_MODE_STANDBY:
801 800 status = restart_science_tasks( LFR_MODE_SBM1 ); // restart science tasks
802 801 if (status == RTEMS_SUCCESSFUL) // relaunch spectral_matrix and waveform_picker modules
803 802 {
804 803 launch_spectral_matrix( );
805 804 launch_waveform_picker( LFR_MODE_SBM1, transitionCoarseTime );
806 805 }
807 806 break;
808 807 case LFR_MODE_NORMAL: // lfrCurrentMode will be updated after the execution of close_action
809 808 status = restart_asm_activities( LFR_MODE_SBM1 );
810 809 status = LFR_SUCCESSFUL;
811 810 update_last_valid_transition_date( transitionCoarseTime );
812 811 break;
813 812 case LFR_MODE_BURST:
814 813 status = stop_current_mode(); // stop the current mode
815 814 status = restart_science_tasks( LFR_MODE_SBM1 ); // restart the science tasks
816 815 if (status == RTEMS_SUCCESSFUL) // relaunch spectral_matrix and waveform_picker modules
817 816 {
818 817 launch_spectral_matrix( );
819 818 launch_waveform_picker( LFR_MODE_SBM1, transitionCoarseTime );
820 819 }
821 820 break;
822 821 case LFR_MODE_SBM2:
823 822 status = restart_asm_activities( LFR_MODE_SBM1 );
824 823 status = LFR_SUCCESSFUL; // lfrCurrentMode will be updated after the execution of close_action
825 824 update_last_valid_transition_date( transitionCoarseTime );
826 825 break;
827 826 default:
828 827 break;
829 828 }
830 829
831 830 if (status != RTEMS_SUCCESSFUL)
832 831 {
833 832 PRINTF1("ERR *** in enter_mode_sbm1 *** status = %d\n", status);
834 833 status = RTEMS_UNSATISFIED;
835 834 }
836 835
837 836 return status;
838 837 }
839 838
840 839 int enter_mode_sbm2( unsigned int transitionCoarseTime )
841 840 {
842 841 /** This function is used to start the SBM2 mode.
843 842 *
844 843 * @param transitionCoarseTime is the requested transition time contained in the TC_LFR_ENTER_MODE
845 844 *
846 845 * @return RTEMS directive status codes:
847 846 * - RTEMS_SUCCESSFUL - task restarted successfully
848 847 * - RTEMS_INVALID_ID - task id invalid
849 848 * - RTEMS_INCORRECT_STATE - task never started
850 849 * - RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot restart remote task
851 850 *
852 851 * The way the SBM2 mode is started depends on the LFR current mode. If LFR is in NORMAL or SBM1,
853 852 * the snapshots are not restarted, only ASM, BP and CWF data generation are affected. In other
854 853 * cases, the acquisition is completely restarted.
855 854 *
856 855 */
857 856
858 857 int status;
859 858
860 859 #ifdef PRINT_TASK_STATISTICS
861 860 rtems_cpu_usage_reset();
862 861 #endif
863 862
864 863 status = RTEMS_UNSATISFIED;
865 864
866 865 switch( lfrCurrentMode )
867 866 {
868 867 case LFR_MODE_STANDBY:
869 868 status = restart_science_tasks( LFR_MODE_SBM2 ); // restart science tasks
870 869 if (status == RTEMS_SUCCESSFUL) // relaunch spectral_matrix and waveform_picker modules
871 870 {
872 871 launch_spectral_matrix( );
873 872 launch_waveform_picker( LFR_MODE_SBM2, transitionCoarseTime );
874 873 }
875 874 break;
876 875 case LFR_MODE_NORMAL:
877 876 status = restart_asm_activities( LFR_MODE_SBM2 );
878 877 status = LFR_SUCCESSFUL; // lfrCurrentMode will be updated after the execution of close_action
879 878 update_last_valid_transition_date( transitionCoarseTime );
880 879 break;
881 880 case LFR_MODE_BURST:
882 881 status = stop_current_mode(); // stop the current mode
883 882 status = restart_science_tasks( LFR_MODE_SBM2 ); // restart the science tasks
884 883 if (status == RTEMS_SUCCESSFUL) // relaunch spectral_matrix and waveform_picker modules
885 884 {
886 885 launch_spectral_matrix( );
887 886 launch_waveform_picker( LFR_MODE_SBM2, transitionCoarseTime );
888 887 }
889 888 break;
890 889 case LFR_MODE_SBM1:
891 890 status = restart_asm_activities( LFR_MODE_SBM2 );
892 891 status = LFR_SUCCESSFUL; // lfrCurrentMode will be updated after the execution of close_action
893 892 update_last_valid_transition_date( transitionCoarseTime );
894 893 break;
895 894 default:
896 895 break;
897 896 }
898 897
899 898 if (status != RTEMS_SUCCESSFUL)
900 899 {
901 900 PRINTF1("ERR *** in enter_mode_sbm2 *** status = %d\n", status)
902 901 status = RTEMS_UNSATISFIED;
903 902 }
904 903
905 904 return status;
906 905 }
907 906
908 907 int restart_science_tasks( unsigned char lfrRequestedMode )
909 908 {
910 909 /** This function is used to restart all science tasks.
911 910 *
912 911 * @return RTEMS directive status codes:
913 912 * - RTEMS_SUCCESSFUL - task restarted successfully
914 913 * - RTEMS_INVALID_ID - task id invalid
915 914 * - RTEMS_INCORRECT_STATE - task never started
916 915 * - RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot restart remote task
917 916 *
918 917 * Science tasks are AVF0, PRC0, WFRM, CWF3, CW2, CWF1
919 918 *
920 919 */
921 920
922 921 rtems_status_code status[NB_SCIENCE_TASKS];
923 922 rtems_status_code ret;
924 923
925 924 ret = RTEMS_SUCCESSFUL;
926 925
927 926 status[STATUS_0] = rtems_task_restart( Task_id[TASKID_AVF0], lfrRequestedMode );
928 927 if (status[STATUS_0] != RTEMS_SUCCESSFUL)
929 928 {
930 929 PRINTF1("in restart_science_task *** AVF0 ERR %d\n", status[STATUS_0])
931 930 }
932 931
933 932 status[STATUS_1] = rtems_task_restart( Task_id[TASKID_PRC0], lfrRequestedMode );
934 933 if (status[STATUS_1] != RTEMS_SUCCESSFUL)
935 934 {
936 935 PRINTF1("in restart_science_task *** PRC0 ERR %d\n", status[STATUS_1])
937 936 }
938 937
939 938 status[STATUS_2] = rtems_task_restart( Task_id[TASKID_WFRM],1 );
940 939 if (status[STATUS_2] != RTEMS_SUCCESSFUL)
941 940 {
942 941 PRINTF1("in restart_science_task *** WFRM ERR %d\n", status[STATUS_2])
943 942 }
944 943
945 944 status[STATUS_3] = rtems_task_restart( Task_id[TASKID_CWF3],1 );
946 945 if (status[STATUS_3] != RTEMS_SUCCESSFUL)
947 946 {
948 947 PRINTF1("in restart_science_task *** CWF3 ERR %d\n", status[STATUS_3])
949 948 }
950 949
951 950 status[STATUS_4] = rtems_task_restart( Task_id[TASKID_CWF2],1 );
952 951 if (status[STATUS_4] != RTEMS_SUCCESSFUL)
953 952 {
954 953 PRINTF1("in restart_science_task *** CWF2 ERR %d\n", status[STATUS_4])
955 954 }
956 955
957 956 status[STATUS_5] = rtems_task_restart( Task_id[TASKID_CWF1],1 );
958 957 if (status[STATUS_5] != RTEMS_SUCCESSFUL)
959 958 {
960 959 PRINTF1("in restart_science_task *** CWF1 ERR %d\n", status[STATUS_5])
961 960 }
962 961
963 962 status[STATUS_6] = rtems_task_restart( Task_id[TASKID_AVF1], lfrRequestedMode );
964 963 if (status[STATUS_6] != RTEMS_SUCCESSFUL)
965 964 {
966 965 PRINTF1("in restart_science_task *** AVF1 ERR %d\n", status[STATUS_6])
967 966 }
968 967
969 968 status[STATUS_7] = rtems_task_restart( Task_id[TASKID_PRC1],lfrRequestedMode );
970 969 if (status[STATUS_7] != RTEMS_SUCCESSFUL)
971 970 {
972 971 PRINTF1("in restart_science_task *** PRC1 ERR %d\n", status[STATUS_7])
973 972 }
974 973
975 974 status[STATUS_8] = rtems_task_restart( Task_id[TASKID_AVF2], 1 );
976 975 if (status[STATUS_8] != RTEMS_SUCCESSFUL)
977 976 {
978 977 PRINTF1("in restart_science_task *** AVF2 ERR %d\n", status[STATUS_8])
979 978 }
980 979
981 980 status[STATUS_9] = rtems_task_restart( Task_id[TASKID_PRC2], 1 );
982 981 if (status[STATUS_9] != RTEMS_SUCCESSFUL)
983 982 {
984 983 PRINTF1("in restart_science_task *** PRC2 ERR %d\n", status[STATUS_9])
985 984 }
986 985
987 986 if ( (status[STATUS_0] != RTEMS_SUCCESSFUL) || (status[STATUS_1] != RTEMS_SUCCESSFUL) ||
988 987 (status[STATUS_2] != RTEMS_SUCCESSFUL) || (status[STATUS_3] != RTEMS_SUCCESSFUL) ||
989 988 (status[STATUS_4] != RTEMS_SUCCESSFUL) || (status[STATUS_5] != RTEMS_SUCCESSFUL) ||
990 989 (status[STATUS_6] != RTEMS_SUCCESSFUL) || (status[STATUS_7] != RTEMS_SUCCESSFUL) ||
991 990 (status[STATUS_8] != RTEMS_SUCCESSFUL) || (status[STATUS_9] != RTEMS_SUCCESSFUL) )
992 991 {
993 992 ret = RTEMS_UNSATISFIED;
994 993 }
995 994
996 995 return ret;
997 996 }
998 997
999 998 int restart_asm_tasks( unsigned char lfrRequestedMode )
1000 999 {
1001 1000 /** This function is used to restart average spectral matrices tasks.
1002 1001 *
1003 1002 * @return RTEMS directive status codes:
1004 1003 * - RTEMS_SUCCESSFUL - task restarted successfully
1005 1004 * - RTEMS_INVALID_ID - task id invalid
1006 1005 * - RTEMS_INCORRECT_STATE - task never started
1007 1006 * - RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot restart remote task
1008 1007 *
1009 1008 * ASM tasks are AVF0, PRC0, AVF1, PRC1, AVF2 and PRC2
1010 1009 *
1011 1010 */
1012 1011
1013 1012 rtems_status_code status[NB_ASM_TASKS];
1014 1013 rtems_status_code ret;
1015 1014
1016 1015 ret = RTEMS_SUCCESSFUL;
1017 1016
1018 1017 status[STATUS_0] = rtems_task_restart( Task_id[TASKID_AVF0], lfrRequestedMode );
1019 1018 if (status[STATUS_0] != RTEMS_SUCCESSFUL)
1020 1019 {
1021 1020 PRINTF1("in restart_science_task *** AVF0 ERR %d\n", status[STATUS_0])
1022 1021 }
1023 1022
1024 1023 status[STATUS_1] = rtems_task_restart( Task_id[TASKID_PRC0], lfrRequestedMode );
1025 1024 if (status[STATUS_1] != RTEMS_SUCCESSFUL)
1026 1025 {
1027 1026 PRINTF1("in restart_science_task *** PRC0 ERR %d\n", status[STATUS_1])
1028 1027 }
1029 1028
1030 1029 status[STATUS_2] = rtems_task_restart( Task_id[TASKID_AVF1], lfrRequestedMode );
1031 1030 if (status[STATUS_2] != RTEMS_SUCCESSFUL)
1032 1031 {
1033 1032 PRINTF1("in restart_science_task *** AVF1 ERR %d\n", status[STATUS_2])
1034 1033 }
1035 1034
1036 1035 status[STATUS_3] = rtems_task_restart( Task_id[TASKID_PRC1],lfrRequestedMode );
1037 1036 if (status[STATUS_3] != RTEMS_SUCCESSFUL)
1038 1037 {
1039 1038 PRINTF1("in restart_science_task *** PRC1 ERR %d\n", status[STATUS_3])
1040 1039 }
1041 1040
1042 1041 status[STATUS_4] = rtems_task_restart( Task_id[TASKID_AVF2], 1 );
1043 1042 if (status[STATUS_4] != RTEMS_SUCCESSFUL)
1044 1043 {
1045 1044 PRINTF1("in restart_science_task *** AVF2 ERR %d\n", status[STATUS_4])
1046 1045 }
1047 1046
1048 1047 status[STATUS_5] = rtems_task_restart( Task_id[TASKID_PRC2], 1 );
1049 1048 if (status[STATUS_5] != RTEMS_SUCCESSFUL)
1050 1049 {
1051 1050 PRINTF1("in restart_science_task *** PRC2 ERR %d\n", status[STATUS_5])
1052 1051 }
1053 1052
1054 1053 if ( (status[STATUS_0] != RTEMS_SUCCESSFUL) || (status[STATUS_1] != RTEMS_SUCCESSFUL) ||
1055 1054 (status[STATUS_2] != RTEMS_SUCCESSFUL) || (status[STATUS_3] != RTEMS_SUCCESSFUL) ||
1056 1055 (status[STATUS_4] != RTEMS_SUCCESSFUL) || (status[STATUS_5] != RTEMS_SUCCESSFUL) )
1057 1056 {
1058 1057 ret = RTEMS_UNSATISFIED;
1059 1058 }
1060 1059
1061 1060 return ret;
1062 1061 }
1063 1062
1064 1063 int suspend_science_tasks( void )
1065 1064 {
1066 1065 /** This function suspends the science tasks.
1067 1066 *
1068 1067 * @return RTEMS directive status codes:
1069 1068 * - RTEMS_SUCCESSFUL - task restarted successfully
1070 1069 * - RTEMS_INVALID_ID - task id invalid
1071 1070 * - RTEMS_ALREADY_SUSPENDED - task already suspended
1072 1071 *
1073 1072 */
1074 1073
1075 1074 rtems_status_code status;
1076 1075
1077 1076 PRINTF("in suspend_science_tasks\n")
1078 1077
1079 1078 status = rtems_task_suspend( Task_id[TASKID_AVF0] ); // suspend AVF0
1080 1079 if ((status != RTEMS_SUCCESSFUL) && (status != RTEMS_ALREADY_SUSPENDED))
1081 1080 {
1082 1081 PRINTF1("in suspend_science_task *** AVF0 ERR %d\n", status)
1083 1082 }
1084 1083 else
1085 1084 {
1086 1085 status = RTEMS_SUCCESSFUL;
1087 1086 }
1088 1087 if (status == RTEMS_SUCCESSFUL) // suspend PRC0
1089 1088 {
1090 1089 status = rtems_task_suspend( Task_id[TASKID_PRC0] );
1091 1090 if ((status != RTEMS_SUCCESSFUL) && (status != RTEMS_ALREADY_SUSPENDED))
1092 1091 {
1093 1092 PRINTF1("in suspend_science_task *** PRC0 ERR %d\n", status)
1094 1093 }
1095 1094 else
1096 1095 {
1097 1096 status = RTEMS_SUCCESSFUL;
1098 1097 }
1099 1098 }
1100 1099 if (status == RTEMS_SUCCESSFUL) // suspend AVF1
1101 1100 {
1102 1101 status = rtems_task_suspend( Task_id[TASKID_AVF1] );
1103 1102 if ((status != RTEMS_SUCCESSFUL) && (status != RTEMS_ALREADY_SUSPENDED))
1104 1103 {
1105 1104 PRINTF1("in suspend_science_task *** AVF1 ERR %d\n", status)
1106 1105 }
1107 1106 else
1108 1107 {
1109 1108 status = RTEMS_SUCCESSFUL;
1110 1109 }
1111 1110 }
1112 1111 if (status == RTEMS_SUCCESSFUL) // suspend PRC1
1113 1112 {
1114 1113 status = rtems_task_suspend( Task_id[TASKID_PRC1] );
1115 1114 if ((status != RTEMS_SUCCESSFUL) && (status != RTEMS_ALREADY_SUSPENDED))
1116 1115 {
1117 1116 PRINTF1("in suspend_science_task *** PRC1 ERR %d\n", status)
1118 1117 }
1119 1118 else
1120 1119 {
1121 1120 status = RTEMS_SUCCESSFUL;
1122 1121 }
1123 1122 }
1124 1123 if (status == RTEMS_SUCCESSFUL) // suspend AVF2
1125 1124 {
1126 1125 status = rtems_task_suspend( Task_id[TASKID_AVF2] );
1127 1126 if ((status != RTEMS_SUCCESSFUL) && (status != RTEMS_ALREADY_SUSPENDED))
1128 1127 {
1129 1128 PRINTF1("in suspend_science_task *** AVF2 ERR %d\n", status)
1130 1129 }
1131 1130 else
1132 1131 {
1133 1132 status = RTEMS_SUCCESSFUL;
1134 1133 }
1135 1134 }
1136 1135 if (status == RTEMS_SUCCESSFUL) // suspend PRC2
1137 1136 {
1138 1137 status = rtems_task_suspend( Task_id[TASKID_PRC2] );
1139 1138 if ((status != RTEMS_SUCCESSFUL) && (status != RTEMS_ALREADY_SUSPENDED))
1140 1139 {
1141 1140 PRINTF1("in suspend_science_task *** PRC2 ERR %d\n", status)
1142 1141 }
1143 1142 else
1144 1143 {
1145 1144 status = RTEMS_SUCCESSFUL;
1146 1145 }
1147 1146 }
1148 1147 if (status == RTEMS_SUCCESSFUL) // suspend WFRM
1149 1148 {
1150 1149 status = rtems_task_suspend( Task_id[TASKID_WFRM] );
1151 1150 if ((status != RTEMS_SUCCESSFUL) && (status != RTEMS_ALREADY_SUSPENDED))
1152 1151 {
1153 1152 PRINTF1("in suspend_science_task *** WFRM ERR %d\n", status)
1154 1153 }
1155 1154 else
1156 1155 {
1157 1156 status = RTEMS_SUCCESSFUL;
1158 1157 }
1159 1158 }
1160 1159 if (status == RTEMS_SUCCESSFUL) // suspend CWF3
1161 1160 {
1162 1161 status = rtems_task_suspend( Task_id[TASKID_CWF3] );
1163 1162 if ((status != RTEMS_SUCCESSFUL) && (status != RTEMS_ALREADY_SUSPENDED))
1164 1163 {
1165 1164 PRINTF1("in suspend_science_task *** CWF3 ERR %d\n", status)
1166 1165 }
1167 1166 else
1168 1167 {
1169 1168 status = RTEMS_SUCCESSFUL;
1170 1169 }
1171 1170 }
1172 1171 if (status == RTEMS_SUCCESSFUL) // suspend CWF2
1173 1172 {
1174 1173 status = rtems_task_suspend( Task_id[TASKID_CWF2] );
1175 1174 if ((status != RTEMS_SUCCESSFUL) && (status != RTEMS_ALREADY_SUSPENDED))
1176 1175 {
1177 1176 PRINTF1("in suspend_science_task *** CWF2 ERR %d\n", status)
1178 1177 }
1179 1178 else
1180 1179 {
1181 1180 status = RTEMS_SUCCESSFUL;
1182 1181 }
1183 1182 }
1184 1183 if (status == RTEMS_SUCCESSFUL) // suspend CWF1
1185 1184 {
1186 1185 status = rtems_task_suspend( Task_id[TASKID_CWF1] );
1187 1186 if ((status != RTEMS_SUCCESSFUL) && (status != RTEMS_ALREADY_SUSPENDED))
1188 1187 {
1189 1188 PRINTF1("in suspend_science_task *** CWF1 ERR %d\n", status)
1190 1189 }
1191 1190 else
1192 1191 {
1193 1192 status = RTEMS_SUCCESSFUL;
1194 1193 }
1195 1194 }
1196 1195
1197 1196 return status;
1198 1197 }
1199 1198
1200 1199 int suspend_asm_tasks( void )
1201 1200 {
1202 1201 /** This function suspends the science tasks.
1203 1202 *
1204 1203 * @return RTEMS directive status codes:
1205 1204 * - RTEMS_SUCCESSFUL - task restarted successfully
1206 1205 * - RTEMS_INVALID_ID - task id invalid
1207 1206 * - RTEMS_ALREADY_SUSPENDED - task already suspended
1208 1207 *
1209 1208 */
1210 1209
1211 1210 rtems_status_code status;
1212 1211
1213 1212 PRINTF("in suspend_science_tasks\n")
1214 1213
1215 1214 status = rtems_task_suspend( Task_id[TASKID_AVF0] ); // suspend AVF0
1216 1215 if ((status != RTEMS_SUCCESSFUL) && (status != RTEMS_ALREADY_SUSPENDED))
1217 1216 {
1218 1217 PRINTF1("in suspend_science_task *** AVF0 ERR %d\n", status)
1219 1218 }
1220 1219 else
1221 1220 {
1222 1221 status = RTEMS_SUCCESSFUL;
1223 1222 }
1224 1223
1225 1224 if (status == RTEMS_SUCCESSFUL) // suspend PRC0
1226 1225 {
1227 1226 status = rtems_task_suspend( Task_id[TASKID_PRC0] );
1228 1227 if ((status != RTEMS_SUCCESSFUL) && (status != RTEMS_ALREADY_SUSPENDED))
1229 1228 {
1230 1229 PRINTF1("in suspend_science_task *** PRC0 ERR %d\n", status)
1231 1230 }
1232 1231 else
1233 1232 {
1234 1233 status = RTEMS_SUCCESSFUL;
1235 1234 }
1236 1235 }
1237 1236
1238 1237 if (status == RTEMS_SUCCESSFUL) // suspend AVF1
1239 1238 {
1240 1239 status = rtems_task_suspend( Task_id[TASKID_AVF1] );
1241 1240 if ((status != RTEMS_SUCCESSFUL) && (status != RTEMS_ALREADY_SUSPENDED))
1242 1241 {
1243 1242 PRINTF1("in suspend_science_task *** AVF1 ERR %d\n", status)
1244 1243 }
1245 1244 else
1246 1245 {
1247 1246 status = RTEMS_SUCCESSFUL;
1248 1247 }
1249 1248 }
1250 1249
1251 1250 if (status == RTEMS_SUCCESSFUL) // suspend PRC1
1252 1251 {
1253 1252 status = rtems_task_suspend( Task_id[TASKID_PRC1] );
1254 1253 if ((status != RTEMS_SUCCESSFUL) && (status != RTEMS_ALREADY_SUSPENDED))
1255 1254 {
1256 1255 PRINTF1("in suspend_science_task *** PRC1 ERR %d\n", status)
1257 1256 }
1258 1257 else
1259 1258 {
1260 1259 status = RTEMS_SUCCESSFUL;
1261 1260 }
1262 1261 }
1263 1262
1264 1263 if (status == RTEMS_SUCCESSFUL) // suspend AVF2
1265 1264 {
1266 1265 status = rtems_task_suspend( Task_id[TASKID_AVF2] );
1267 1266 if ((status != RTEMS_SUCCESSFUL) && (status != RTEMS_ALREADY_SUSPENDED))
1268 1267 {
1269 1268 PRINTF1("in suspend_science_task *** AVF2 ERR %d\n", status)
1270 1269 }
1271 1270 else
1272 1271 {
1273 1272 status = RTEMS_SUCCESSFUL;
1274 1273 }
1275 1274 }
1276 1275
1277 1276 if (status == RTEMS_SUCCESSFUL) // suspend PRC2
1278 1277 {
1279 1278 status = rtems_task_suspend( Task_id[TASKID_PRC2] );
1280 1279 if ((status != RTEMS_SUCCESSFUL) && (status != RTEMS_ALREADY_SUSPENDED))
1281 1280 {
1282 1281 PRINTF1("in suspend_science_task *** PRC2 ERR %d\n", status)
1283 1282 }
1284 1283 else
1285 1284 {
1286 1285 status = RTEMS_SUCCESSFUL;
1287 1286 }
1288 1287 }
1289 1288
1290 1289 return status;
1291 1290 }
1292 1291
1293 1292 void launch_waveform_picker( unsigned char mode, unsigned int transitionCoarseTime )
1294 1293 {
1295 1294
1296 1295 WFP_reset_current_ring_nodes();
1297 1296
1298 1297 reset_waveform_picker_regs();
1299 1298
1300 1299 set_wfp_burst_enable_register( mode );
1301 1300
1302 1301 LEON_Clear_interrupt( IRQ_WAVEFORM_PICKER );
1303 1302 LEON_Unmask_interrupt( IRQ_WAVEFORM_PICKER );
1304 1303
1305 1304 if (transitionCoarseTime == 0)
1306 1305 {
1307 1306 // instant transition means transition on the next valid date
1308 1307 // this is mandatory to have a good snapshot period and a good correction of the snapshot period
1309 1308 waveform_picker_regs->start_date = time_management_regs->coarse_time + 1;
1310 1309 }
1311 1310 else
1312 1311 {
1313 1312 waveform_picker_regs->start_date = transitionCoarseTime;
1314 1313 }
1315 1314
1316 1315 update_last_valid_transition_date(waveform_picker_regs->start_date);
1317 1316
1318 1317 }
1319 1318
1320 1319 void launch_spectral_matrix( void )
1321 1320 {
1322 1321 SM_reset_current_ring_nodes();
1323 1322
1324 1323 reset_spectral_matrix_regs();
1325 1324
1326 1325 reset_nb_sm();
1327 1326
1328 1327 set_sm_irq_onNewMatrix( 1 );
1329 1328
1330 1329 LEON_Clear_interrupt( IRQ_SPECTRAL_MATRIX );
1331 1330 LEON_Unmask_interrupt( IRQ_SPECTRAL_MATRIX );
1332 1331
1333 1332 }
1334 1333
1335 1334 void set_sm_irq_onNewMatrix( unsigned char value )
1336 1335 {
1337 1336 if (value == 1)
1338 1337 {
1339 1338 spectral_matrix_regs->config = spectral_matrix_regs->config | BIT_IRQ_ON_NEW_MATRIX;
1340 1339 }
1341 1340 else
1342 1341 {
1343 1342 spectral_matrix_regs->config = spectral_matrix_regs->config & MASK_IRQ_ON_NEW_MATRIX; // 1110
1344 1343 }
1345 1344 }
1346 1345
1347 1346 void set_sm_irq_onError( unsigned char value )
1348 1347 {
1349 1348 if (value == 1)
1350 1349 {
1351 1350 spectral_matrix_regs->config = spectral_matrix_regs->config | BIT_IRQ_ON_ERROR;
1352 1351 }
1353 1352 else
1354 1353 {
1355 1354 spectral_matrix_regs->config = spectral_matrix_regs->config & MASK_IRQ_ON_ERROR; // 1101
1356 1355 }
1357 1356 }
1358 1357
1359 1358 //*****************************
1360 1359 // CONFIGURE CALIBRATION SIGNAL
1361 1360 void setCalibrationPrescaler( unsigned int prescaler )
1362 1361 {
1363 1362 // prescaling of the master clock (25 MHz)
1364 1363 // master clock is divided by 2^prescaler
1365 1364 time_management_regs->calPrescaler = prescaler;
1366 1365 }
1367 1366
1368 1367 void setCalibrationDivisor( unsigned int divisionFactor )
1369 1368 {
1370 1369 // division of the prescaled clock by the division factor
1371 1370 time_management_regs->calDivisor = divisionFactor;
1372 1371 }
1373 1372
1374 1373 void setCalibrationData( void )
1375 1374 {
1376 1375 /** This function is used to store the values used to drive the DAC in order to generate the SCM calibration signal
1377 1376 *
1378 1377 * @param void
1379 1378 *
1380 1379 * @return void
1381 1380 *
1382 1381 */
1383 1382
1384 1383 unsigned int k;
1385 1384 unsigned short data;
1386 1385 float val;
1387 1386 float Ts;
1388 1387
1389 1388 time_management_regs->calDataPtr = INIT_CHAR;
1390 1389
1391 1390 Ts = 1 / CAL_FS;
1392 1391
1393 1392 // build the signal for the SCM calibration
1394 1393 for (k = 0; k < CAL_NB_PTS; k++)
1395 1394 {
1396 val = sin( 2 * pi * CAL_F0 * k * Ts )
1397 + sin( 2 * pi * CAL_F1 * k * Ts );
1395 val = CAL_A0 * sin( CAL_W0 * k * Ts )
1396 + CAL_A1 * sin( CAL_W1 * k * Ts );
1398 1397 data = (unsigned short) ((val * CAL_SCALE_FACTOR) + CONST_2048);
1399 1398 time_management_regs->calData = data & CAL_DATA_MASK;
1400 1399 }
1401 1400 }
1402 1401
1403 1402 void setCalibrationDataInterleaved( void )
1404 1403 {
1405 1404 /** This function is used to store the values used to drive the DAC in order to generate the SCM calibration signal
1406 1405 *
1407 1406 * @param void
1408 1407 *
1409 1408 * @return void
1410 1409 *
1411 1410 * In interleaved mode, one can store more values than in normal mode.
1412 1411 * The data are stored in bunch of 18 bits, 12 bits from one sample and 6 bits from another sample.
1413 1412 * T store 3 values, one need two write operations.
1414 1413 * s1 [ b11 b10 b9 b8 b7 b6 ] s0 [ b11 b10 b9 b8 b7 b6 b5 b3 b2 b1 b0 ]
1415 1414 * s1 [ b5 b4 b3 b2 b1 b0 ] s2 [ b11 b10 b9 b8 b7 b6 b5 b3 b2 b1 b0 ]
1416 1415 *
1417 1416 */
1418 1417
1419 1418 unsigned int k;
1420 1419 float val;
1421 1420 float Ts;
1422 1421 unsigned short data[CAL_NB_PTS_INTER];
1423 1422 unsigned char *dataPtr;
1424 1423
1425 1424 Ts = 1 / CAL_FS_INTER;
1426 1425
1427 1426 time_management_regs->calDataPtr = INIT_CHAR;
1428 1427
1429 1428 // build the signal for the SCM calibration
1430 1429 for (k=0; k<CAL_NB_PTS_INTER; k++)
1431 1430 {
1432 1431 val = sin( 2 * pi * CAL_F0 * k * Ts )
1433 1432 + sin( 2 * pi * CAL_F1 * k * Ts );
1434 1433 data[k] = (unsigned short) ((val * CONST_512) + CONST_2048);
1435 1434 }
1436 1435
1437 1436 // write the signal in interleaved mode
1438 1437 for (k=0; k < STEPS_FOR_STORAGE_INTER; k++)
1439 1438 {
1440 1439 dataPtr = (unsigned char*) &data[ (k * BYTES_FOR_2_SAMPLES) + 2 ];
1441 1440 time_management_regs->calData = ( data[ k * BYTES_FOR_2_SAMPLES ] & CAL_DATA_MASK )
1442 1441 + ( (dataPtr[0] & CAL_DATA_MASK_INTER) << CAL_DATA_SHIFT_INTER);
1443 1442 time_management_regs->calData = ( data[(k * BYTES_FOR_2_SAMPLES) + 1] & CAL_DATA_MASK )
1444 1443 + ( (dataPtr[1] & CAL_DATA_MASK_INTER) << CAL_DATA_SHIFT_INTER);
1445 1444 }
1446 1445 }
1447 1446
1448 1447 void setCalibrationReload( bool state)
1449 1448 {
1450 1449 if (state == true)
1451 1450 {
1452 1451 time_management_regs->calDACCtrl = time_management_regs->calDACCtrl | BIT_CAL_RELOAD; // [0001 0000]
1453 1452 }
1454 1453 else
1455 1454 {
1456 1455 time_management_regs->calDACCtrl = time_management_regs->calDACCtrl & MASK_CAL_RELOAD; // [1110 1111]
1457 1456 }
1458 1457 }
1459 1458
1460 1459 void setCalibrationEnable( bool state )
1461 1460 {
1462 1461 // this bit drives the multiplexer
1463 1462 if (state == true)
1464 1463 {
1465 1464 time_management_regs->calDACCtrl = time_management_regs->calDACCtrl | BIT_CAL_ENABLE; // [0100 0000]
1466 1465 }
1467 1466 else
1468 1467 {
1469 1468 time_management_regs->calDACCtrl = time_management_regs->calDACCtrl & MASK_CAL_ENABLE; // [1011 1111]
1470 1469 }
1471 1470 }
1472 1471
1473 1472 void setCalibrationInterleaved( bool state )
1474 1473 {
1475 1474 // this bit drives the multiplexer
1476 1475 if (state == true)
1477 1476 {
1478 1477 time_management_regs->calDACCtrl = time_management_regs->calDACCtrl | BIT_SET_INTERLEAVED; // [0010 0000]
1479 1478 }
1480 1479 else
1481 1480 {
1482 1481 time_management_regs->calDACCtrl = time_management_regs->calDACCtrl & MASK_SET_INTERLEAVED; // [1101 1111]
1483 1482 }
1484 1483 }
1485 1484
1486 1485 void setCalibration( bool state )
1487 1486 {
1488 1487 if (state == true)
1489 1488 {
1490 1489 setCalibrationEnable( true );
1491 1490 setCalibrationReload( false );
1492 1491 set_hk_lfr_calib_enable( true );
1493 1492 }
1494 1493 else
1495 1494 {
1496 1495 setCalibrationEnable( false );
1497 1496 setCalibrationReload( true );
1498 1497 set_hk_lfr_calib_enable( false );
1499 1498 }
1500 1499 }
1501 1500
1502 1501 void configureCalibration( bool interleaved )
1503 1502 {
1504 1503 setCalibration( false );
1505 1504 if ( interleaved == true )
1506 1505 {
1507 1506 setCalibrationInterleaved( true );
1508 1507 setCalibrationPrescaler( 0 ); // 25 MHz => 25 000 000
1509 1508 setCalibrationDivisor( CAL_F_DIVISOR_INTER ); // => 240 384
1510 1509 setCalibrationDataInterleaved();
1511 1510 }
1512 1511 else
1513 1512 {
1514 1513 setCalibrationPrescaler( 0 ); // 25 MHz => 25 000 000
1515 1514 setCalibrationDivisor( CAL_F_DIVISOR ); // => 160 256 (39 - 1)
1516 1515 setCalibrationData();
1517 1516 }
1518 1517 }
1519 1518
1520 1519 //****************
1521 1520 // CLOSING ACTIONS
1522 1521 void update_last_TC_exe( ccsdsTelecommandPacket_t *TC, unsigned char * time )
1523 1522 {
1524 1523 /** This function is used to update the HK packets statistics after a successful TC execution.
1525 1524 *
1526 1525 * @param TC points to the TC being processed
1527 1526 * @param time is the time used to date the TC execution
1528 1527 *
1529 1528 */
1530 1529
1531 1530 unsigned int val;
1532 1531
1533 1532 housekeeping_packet.hk_lfr_last_exe_tc_id[0] = TC->packetID[0];
1534 1533 housekeeping_packet.hk_lfr_last_exe_tc_id[1] = TC->packetID[1];
1535 1534 housekeeping_packet.hk_lfr_last_exe_tc_type[0] = INIT_CHAR;
1536 1535 housekeeping_packet.hk_lfr_last_exe_tc_type[1] = TC->serviceType;
1537 1536 housekeeping_packet.hk_lfr_last_exe_tc_subtype[0] = INIT_CHAR;
1538 1537 housekeeping_packet.hk_lfr_last_exe_tc_subtype[1] = TC->serviceSubType;
1539 1538 housekeeping_packet.hk_lfr_last_exe_tc_time[BYTE_0] = time[BYTE_0];
1540 1539 housekeeping_packet.hk_lfr_last_exe_tc_time[BYTE_1] = time[BYTE_1];
1541 1540 housekeeping_packet.hk_lfr_last_exe_tc_time[BYTE_2] = time[BYTE_2];
1542 1541 housekeeping_packet.hk_lfr_last_exe_tc_time[BYTE_3] = time[BYTE_3];
1543 1542 housekeeping_packet.hk_lfr_last_exe_tc_time[BYTE_4] = time[BYTE_4];
1544 1543 housekeeping_packet.hk_lfr_last_exe_tc_time[BYTE_5] = time[BYTE_5];
1545 1544
1546 1545 val = (housekeeping_packet.hk_lfr_exe_tc_cnt[0] * CONST_256) + housekeeping_packet.hk_lfr_exe_tc_cnt[1];
1547 1546 val++;
1548 1547 housekeeping_packet.hk_lfr_exe_tc_cnt[0] = (unsigned char) (val >> SHIFT_1_BYTE);
1549 1548 housekeeping_packet.hk_lfr_exe_tc_cnt[1] = (unsigned char) (val);
1550 1549 }
1551 1550
1552 1551 void update_last_TC_rej(ccsdsTelecommandPacket_t *TC, unsigned char * time )
1553 1552 {
1554 1553 /** This function is used to update the HK packets statistics after a TC rejection.
1555 1554 *
1556 1555 * @param TC points to the TC being processed
1557 1556 * @param time is the time used to date the TC rejection
1558 1557 *
1559 1558 */
1560 1559
1561 1560 unsigned int val;
1562 1561
1563 1562 housekeeping_packet.hk_lfr_last_rej_tc_id[0] = TC->packetID[0];
1564 1563 housekeeping_packet.hk_lfr_last_rej_tc_id[1] = TC->packetID[1];
1565 1564 housekeeping_packet.hk_lfr_last_rej_tc_type[0] = INIT_CHAR;
1566 1565 housekeeping_packet.hk_lfr_last_rej_tc_type[1] = TC->serviceType;
1567 1566 housekeeping_packet.hk_lfr_last_rej_tc_subtype[0] = INIT_CHAR;
1568 1567 housekeeping_packet.hk_lfr_last_rej_tc_subtype[1] = TC->serviceSubType;
1569 1568 housekeeping_packet.hk_lfr_last_rej_tc_time[BYTE_0] = time[BYTE_0];
1570 1569 housekeeping_packet.hk_lfr_last_rej_tc_time[BYTE_1] = time[BYTE_1];
1571 1570 housekeeping_packet.hk_lfr_last_rej_tc_time[BYTE_2] = time[BYTE_2];
1572 1571 housekeeping_packet.hk_lfr_last_rej_tc_time[BYTE_3] = time[BYTE_3];
1573 1572 housekeeping_packet.hk_lfr_last_rej_tc_time[BYTE_4] = time[BYTE_4];
1574 1573 housekeeping_packet.hk_lfr_last_rej_tc_time[BYTE_5] = time[BYTE_5];
1575 1574
1576 1575 val = (housekeeping_packet.hk_lfr_rej_tc_cnt[0] * CONST_256) + housekeeping_packet.hk_lfr_rej_tc_cnt[1];
1577 1576 val++;
1578 1577 housekeeping_packet.hk_lfr_rej_tc_cnt[0] = (unsigned char) (val >> SHIFT_1_BYTE);
1579 1578 housekeeping_packet.hk_lfr_rej_tc_cnt[1] = (unsigned char) (val);
1580 1579 }
1581 1580
1582 1581 void close_action(ccsdsTelecommandPacket_t *TC, int result, rtems_id queue_id )
1583 1582 {
1584 1583 /** This function is the last step of the TC execution workflow.
1585 1584 *
1586 1585 * @param TC points to the TC being processed
1587 1586 * @param result is the result of the TC execution (LFR_SUCCESSFUL / LFR_DEFAULT)
1588 1587 * @param queue_id is the id of the RTEMS message queue used to send TM packets
1589 1588 * @param time is the time used to date the TC execution
1590 1589 *
1591 1590 */
1592 1591
1593 1592 unsigned char requestedMode;
1594 1593
1595 1594 if (result == LFR_SUCCESSFUL)
1596 1595 {
1597 1596 if ( !( (TC->serviceType==TC_TYPE_TIME) & (TC->serviceSubType==TC_SUBTYPE_UPDT_TIME) )
1598 1597 &
1599 1598 !( (TC->serviceType==TC_TYPE_GEN) & (TC->serviceSubType==TC_SUBTYPE_UPDT_INFO))
1600 1599 )
1601 1600 {
1602 1601 send_tm_lfr_tc_exe_success( TC, queue_id );
1603 1602 }
1604 1603 if ( (TC->serviceType == TC_TYPE_GEN) & (TC->serviceSubType == TC_SUBTYPE_ENTER) )
1605 1604 {
1606 1605 //**********************************
1607 1606 // UPDATE THE LFRMODE LOCAL VARIABLE
1608 1607 requestedMode = TC->dataAndCRC[1];
1609 1608 updateLFRCurrentMode( requestedMode );
1610 1609 }
1611 1610 }
1612 1611 else if (result == LFR_EXE_ERROR)
1613 1612 {
1614 1613 send_tm_lfr_tc_exe_error( TC, queue_id );
1615 1614 }
1616 1615 }
1617 1616
1618 1617 //***************************
1619 1618 // Interrupt Service Routines
1620 1619 rtems_isr commutation_isr1( rtems_vector_number vector )
1621 1620 {
1622 1621 if (rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
1623 1622 PRINTF("In commutation_isr1 *** Error sending event to DUMB\n")
1624 1623 }
1625 1624 }
1626 1625
1627 1626 rtems_isr commutation_isr2( rtems_vector_number vector )
1628 1627 {
1629 1628 if (rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
1630 1629 PRINTF("In commutation_isr2 *** Error sending event to DUMB\n")
1631 1630 }
1632 1631 }
1633 1632
1634 1633 //****************
1635 1634 // OTHER FUNCTIONS
1636 1635 void updateLFRCurrentMode( unsigned char requestedMode )
1637 1636 {
1638 1637 /** This function updates the value of the global variable lfrCurrentMode.
1639 1638 *
1640 1639 * lfrCurrentMode is a parameter used by several functions to know in which mode LFR is running.
1641 1640 *
1642 1641 */
1643 1642
1644 1643 // update the local value of lfrCurrentMode with the value contained in the housekeeping_packet structure
1645 1644 housekeeping_packet.lfr_status_word[0] = (housekeeping_packet.lfr_status_word[0] & STATUS_WORD_LFR_MODE_MASK)
1646 1645 + (unsigned char) ( requestedMode << STATUS_WORD_LFR_MODE_SHIFT );
1647 1646 lfrCurrentMode = requestedMode;
1648 1647 }
1649 1648
1650 1649 void set_lfr_soft_reset( unsigned char value )
1651 1650 {
1652 1651 if (value == 1)
1653 1652 {
1654 1653 time_management_regs->ctrl = time_management_regs->ctrl | BIT_SOFT_RESET; // [0100]
1655 1654 }
1656 1655 else
1657 1656 {
1658 1657 time_management_regs->ctrl = time_management_regs->ctrl & MASK_SOFT_RESET; // [1011]
1659 1658 }
1660 1659 }
1661 1660
1662 1661 void reset_lfr( void )
1663 1662 {
1664 1663 set_lfr_soft_reset( 1 );
1665 1664
1666 1665 set_lfr_soft_reset( 0 );
1667 1666
1668 1667 set_hk_lfr_sc_potential_flag( true );
1669 1668 }
General Comments 0
You need to be logged in to leave comments. Login now