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

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

waveform initialization modified due to a problem of compatibility...
paul@pc-solar1.lab-lpp.local -
r19:beef07605c12 default
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,37 +1,38
1 1 #ifndef WF_HANDLER_H_INCLUDED
2 2 #define WF_HANDLER_H_INCLUDED
3 3
4 4 #include <rtems.h>
5 5 #include <fsw_params.h>
6 6 #include <grspw.h>
7 7 #include <grlib_regs.h>
8 8 #include <ccsds_types.h>
9 9 #include <stdio.h>
10 10 #include <fsw_init.h>
11 11 #include <math.h>
12 12
13 13 #define pi 3.1415
14 14
15 15 //#include <sys/ioctl.h>
16 16
17 17 extern rtems_id Task_id[]; /* array of task ids */
18 18 extern int fdSPW;
19 19 extern volatile int wf_snap_f0[ ];
20 20 extern volatile int wf_snap_f1[ ];
21 extern volatile int wf_snap_f1_bis[ ];
21 22 extern volatile int wf_snap_f2[ ];
22 23 extern volatile int wf_cont_f3[ ];
23 24 extern waveform_picker_regs_t *waveform_picker_regs;
24 25
25 26 rtems_isr waveforms_isr( rtems_vector_number vector );
26 27 rtems_isr waveforms_simulator_isr( rtems_vector_number vector );
27 28 rtems_task wfrm_task(rtems_task_argument argument);
28 29
29 30 //******************
30 31 // general functions
31 32 void init_waveforms( void );
32 33 void reset_waveforms( void );
33 34 void send_waveform( ExtendedTMHeader_t *header, volatile int *waveform, unsigned int sid, spw_ioctl_pkt_send *spw_ioctl_send);
34 35 void init_waveform_picker_regs();
35 36 int build_value(int value1, int value0);
36 37
37 38 #endif // WF_HANDLER_H_INCLUDED
Show file before | Show file after | Hide comments
@@ -1,52 +1,53
1 1 #include <fsw_processing.h>
2 2 #include <rtems.h>
3 3 #include <ccsds_types.h>
4 4
5 5 // RTEMS GLOBAL VARIABLES
6 6 rtems_name misc_name[5];
7 7 rtems_name misc_id[5];
8 8 rtems_id Task_id[15]; /* array of task ids */
9 9 rtems_name Task_name[15]; /* array of task names */
10 10 int fdSPW = 0;
11 11 int fdUART = 0;
12 12
13 13 spectral_matrices_regs_t *spectral_matrices_regs = NULL;
14 14
15 15 // APB CONFIGURATION REGISTERS
16 16 time_management_regs_t *time_management_regs = (time_management_regs_t*) REGS_ADDR_TIME_MANAGEMENT;
17 17 waveform_picker_regs_t *waveform_picker_regs = (waveform_picker_regs_t*) REGS_ADDR_WAVEFORM_PICKER;
18 18 gptimer_regs_t *gptimer_regs = (gptimer_regs_t *) REGS_ADDR_GPTIMER;
19 19
20 // WAVEFORMS GLOBAL VARIABLES
21 volatile int wf_snap_f0[ 2 * NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK + 2]; // 2048 * 3 * 4 + 2 * 4 = 24576 + 8 bytes
22 volatile int wf_snap_f1[ 2 * NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK + 2]; // 2048 * 3 * 4 + 2 * 4 = 24576 + 8 bytes
23 volatile int wf_snap_f2[ 2 * NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK + 2]; // 2048 * 3 * 4 + 2 * 4 = 24576 + 8 bytes
24 volatile int wf_cont_f3[ 2 * NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK + 2]; // 2048 * 3 * 4 + 2 * 4 = 24576 + 8 bytes
20 // WAVEFORMS GLOBAL VARIABLES // 2048 * 3 * 4 + 2 * 4 = 24576 + 8 bytes
21 volatile int wf_snap_f0[ NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK + TIME_OFFSET];
22 volatile int wf_snap_f1[ NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK + TIME_OFFSET];
23 volatile int wf_snap_f1_bis[ NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK + TIME_OFFSET];
24 volatile int wf_snap_f2[ NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK + TIME_OFFSET];
25 volatile int wf_cont_f3[ NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK + TIME_OFFSET];
25 26
26 27 // SPECTRAL MATRICES GLOBAL VARIABLES
27 28 volatile int spec_mat_f0_a[ TOTAL_SIZE_SPEC_MAT ];
28 29 volatile int spec_mat_f0_b[ TOTAL_SIZE_SPEC_MAT ];
29 30 volatile int spec_mat_f0_c[ TOTAL_SIZE_SPEC_MAT ];
30 31 volatile int spec_mat_f0_d[ TOTAL_SIZE_SPEC_MAT ];
31 32 volatile int spec_mat_f0_e[ TOTAL_SIZE_SPEC_MAT ];
32 33 volatile int spec_mat_f0_f[ TOTAL_SIZE_SPEC_MAT ];
33 34 volatile int spec_mat_f0_g[ TOTAL_SIZE_SPEC_MAT ];
34 35 volatile int spec_mat_f0_h[ TOTAL_SIZE_SPEC_MAT ];
35 36 //
36 37 float averaged_spec_mat_f0[ TOTAL_SIZE_SPEC_MAT ];
37 38 float compressed_spec_mat_f0[ TOTAL_SIZE_COMPRESSED_MATRIX_f0 ];
38 39
39 40 // MODE PARAMETERS
40 41 struct param_norm_str param_norm;
41 42 struct param_burst_str param_burst;
42 43 struct param_sbm1_str param_sbm1;
43 44 struct param_sbm2_str param_sbm2;
44 45 unsigned char param_common[2];
45 46
46 47 // HK PACKETS
47 48 Packet_TM_LFR_HK_t housekeeping_packet;
48 49
49 50 // BASIC PARAMETERS GLOBAL VARIABLES
50 51 unsigned char LFR_BP1_F0[ NB_BINS_COMPRESSED_MATRIX_f0 * 9 ];
51 52 BP1_t data_BP1[ NB_BINS_COMPRESSED_MATRIX_f0 ];
52 53
Show file before | Show file after | Hide comments
@@ -1,414 +1,414
1 1 //*************************
2 2 // GPL reminder to be added
3 3 //*************************
4 4
5 5 #include <rtems.h>
6 6
7 7 /* configuration information */
8 8
9 9 #define CONFIGURE_INIT
10 10
11 11 #include <bsp.h> /* for device driver prototypes */
12 12
13 13 /* configuration information */
14 14
15 15 #define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
16 16 #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
17 17
18 18 #define CONFIGURE_MAXIMUM_TASKS 15
19 19 #define CONFIGURE_RTEMS_INIT_TASKS_TABLE
20 20 #define CONFIGURE_EXTRA_TASK_STACKS (3 * RTEMS_MINIMUM_STACK_SIZE)
21 21 #define CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS 32
22 22 #define CONFIGURE_INIT_TASK_PRIORITY 100
23 23 #define CONFIGURE_MAXIMUM_DRIVERS 16
24 24 #define CONFIGURE_MAXIMUM_PERIODS 5
25 25 #define CONFIGURE_MAXIMUM_MESSAGE_QUEUES 1
26 26
27 27 #include <rtems/confdefs.h>
28 28
29 29 /* If --drvmgr was enabled during the configuration of the RTEMS kernel */
30 30 #ifdef RTEMS_DRVMGR_STARTUP
31 31 #ifdef LEON3
32 32 /* Add Timer and UART Driver */
33 33 #ifdef CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
34 34 #define CONFIGURE_DRIVER_AMBAPP_GAISLER_GPTIMER
35 35 #endif
36 36 #ifdef CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
37 37 #define CONFIGURE_DRIVER_AMBAPP_GAISLER_APBUART
38 38 #endif
39 39 #endif
40 40 #define CONFIGURE_DRIVER_AMBAPP_GAISLER_GRSPW /* GRSPW Driver */
41 41 #include <drvmgr/drvmgr_confdefs.h>
42 42 #endif
43 43
44 44 #include <fsw_init.h>
45 45 #include <fsw_config.c>
46 46
47 47 char *lstates[6] = {"Error-reset",
48 48 "Error-wait",
49 49 "Ready",
50 50 "Started",
51 51 "Connecting",
52 52 "Run"
53 53 };
54 54
55 55 rtems_task Init( rtems_task_argument ignored )
56 56 {
57 57 rtems_status_code status;
58 58 rtems_isr_entry old_isr_handler;
59 59
60 60 PRINTF("\n\n\n\n\n")
61 61 PRINTF("***************************\n")
62 62 PRINTF("** START Flight Software **\n")
63 63 PRINTF("***************************\n")
64 64 PRINTF("\n\n")
65 65
66 66 //send_console_outputs_on_serial_port();
67 67 set_apbuart_scaler_reload_register(REGS_ADDR_APBUART, APBUART_SCALER_RELOAD_VALUE);
68 68
69 69 initLookUpTableForCRC(); // in tc_handler.h
70 70 init_default_mode_parameters();
71 71 create_message_queue();
72 72
73 73 create_names();
74 74 create_all_tasks();
75 75 start_all_tasks();
76 76
77 77 grspw_timecode_callback = &timecode_irq_handler;
78 78
79 79 configure_spw_link();
80 80
81 81 //****************************
82 82 // Spectral Matrices simulator
83 83 configure_timer((gptimer_regs_t*) REGS_ADDR_GPTIMER, TIMER_SM_SIMULATOR, CLKDIV_SM_SIMULATOR,
84 84 IRQ_SPARC_SM, spectral_matrices_isr );
85 85
86 86 //**********
87 87 // WAVEFORMS
88 88 // simulator
89 89
90 90 #ifdef GSA
91 91 configure_timer((gptimer_regs_t*) REGS_ADDR_GPTIMER, TIMER_WF_SIMULATOR, CLKDIV_WF_SIMULATOR,
92 92 IRQ_SPARC_WF, waveforms_simulator_isr );
93 93 #else
94 94 // configure the registers of the waveform picker
95 95 init_waveform_picker_regs();
96 96 // configure the waveform picker interrupt service routine
97 97 status = rtems_interrupt_catch( waveforms_isr,
98 98 IRQ_SPARC_WAVEFORM_PICKER,
99 99 &old_isr_handler) ;
100 100 LEON_Mask_interrupt( IRQ_WAVEFORM_PICKER );
101 101 #endif
102 102
103 103 //**********
104 104
105 105 //*****************************************
106 106 // irq handling of the time management unit
107 107 status = rtems_interrupt_catch( commutation_isr1,
108 108 IRQ_SPARC_TIME1,
109 109 &old_isr_handler) ; // see sparcv8.pdf p.76 for interrupt levels
110 110 if (status==RTEMS_SUCCESSFUL) {
111 111 PRINTF("OK *** commutation_isr1 *** rtems_interrupt_catch successfullly configured\n")
112 112 }
113 113
114 114 status = rtems_interrupt_catch( commutation_isr2,
115 115 IRQ_SPARC_TIME2,
116 116 &old_isr_handler) ; // see sparcv8.pdf p.76 for interrupt levels
117 117 if (status==RTEMS_SUCCESSFUL) {
118 118 PRINTF("OK *** commutation_isr2 *** rtems_interrupt_catch successfullly configured\n")
119 119 }
120 120
121 121 LEON_Unmask_interrupt( IRQ_TIME1 );
122 122 LEON_Unmask_interrupt( IRQ_TIME2 );
123 123
124 124 #ifdef GSA
125 if (rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
126 printf("in INIT *** Error sending event to WFRM\n");
127 }
125 //if (rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
126 // printf("in INIT *** Error sending event to WFRM\n");
127 //}
128 128 #endif
129 129
130 130 status = rtems_task_delete(RTEMS_SELF);
131 131
132 132 }
133 133
134 134 rtems_task spiq_task(rtems_task_argument unused)
135 135 {
136 136 rtems_event_set event_out;
137 137 rtems_status_code status;
138 138
139 139 while(true){
140 140 PRINTF("in SPIQ *** Waiting for SPW_LINKERR_EVENT\n")
141 141 rtems_event_receive(SPW_LINKERR_EVENT, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an SPW_LINKERR_EVENT
142 142
143 143 if (rtems_task_suspend(Task_id[TASKID_RECV])!=RTEMS_SUCCESSFUL) { // suspend RECV task
144 144 PRINTF("in SPIQ *** Error suspending RECV Task\n")
145 145 }
146 146 if (rtems_task_suspend(Task_id[TASKID_HOUS])!=RTEMS_SUCCESSFUL) { // suspend HOUS task
147 147 PRINTF("in SPIQ *** Error suspending HOUS Task\n")
148 148 }
149 149
150 150 configure_spw_link();
151 151
152 152 status = rtems_task_restart( Task_id[TASKID_HOUS], 1 );
153 153 if (status!=RTEMS_SUCCESSFUL) {
154 154 PRINTF1("in SPIQ *** Error restarting HOUS Task *** code %d\n", status)
155 155 }
156 156
157 157 if (rtems_task_restart(Task_id[TASKID_RECV], 1)!=RTEMS_SUCCESSFUL) { // restart RECV task
158 158 PRINTF("in SPIQ *** Error restarting RECV Task\n")
159 159 }
160 160 }
161 161 }
162 162
163 163 void init_default_mode_parameters()
164 164 {
165 165 // COMMON PARAMETERS
166 166 param_common[0] = 0x00;
167 167 param_common[1] = 0x10; // default value 0 0 0 1 0 0 0 0
168 168 // NORMAL MODE
169 169 param_norm.sy_lfr_n_swf_l = 2048; // nb sample
170 170 param_norm.sy_lfr_n_swf_p = 300; // sec
171 171 param_norm.sy_lfr_n_asm_p = 3600; // sec
172 172 param_norm.sy_lfr_n_bp_p0 = 4; // sec
173 173 param_norm.sy_lfr_n_bp_p1 = 20; // sec
174 174 // BURST MODE
175 175 param_burst.sy_lfr_b_bp_p0 = 1; // sec
176 176 param_burst.sy_lfr_b_bp_p1 = 5; // sec
177 177 // SBM1 MODE
178 178 param_sbm1.sy_lfr_s1_bp_p0 = 1; // sec
179 179 param_sbm1.sy_lfr_s1_bp_p1 = 1; // sec
180 180 // SBM2 MODE
181 181 param_sbm2.sy_lfr_s2_bp_p0 = 1; // sec
182 182 param_sbm2.sy_lfr_s2_bp_p0 = 5; // sec
183 183 }
184 184
185 185 int create_names( void )
186 186 {
187 187 // task names
188 188 Task_name[TASKID_RECV] = rtems_build_name( 'R', 'E', 'C', 'V' );
189 189 Task_name[TASKID_ACTN] = rtems_build_name( 'A', 'C', 'T', 'N' );
190 190 Task_name[TASKID_SPIQ] = rtems_build_name( 'S', 'P', 'I', 'Q' );
191 191 Task_name[TASKID_SMIQ] = rtems_build_name( 'S', 'M', 'I', 'Q' );
192 192 Task_name[TASKID_STAT] = rtems_build_name( 'S', 'T', 'A', 'T' );
193 193 Task_name[TASKID_AVF0] = rtems_build_name( 'A', 'V', 'F', '0' );
194 194 Task_name[TASKID_BPF0] = rtems_build_name( 'B', 'P', 'F', '0' );
195 195 Task_name[TASKID_WFRM] = rtems_build_name( 'W', 'F', 'R', 'M' );
196 196 Task_name[TASKID_DUMB] = rtems_build_name( 'D', 'U', 'M', 'B' );
197 197 Task_name[TASKID_HOUS] = rtems_build_name( 'H', 'O', 'U', 'S' );
198 198
199 199 // rate monotonic period name
200 200 HK_name = rtems_build_name( 'H', 'O', 'U', 'S' );
201 201
202 202 return 0;
203 203 }
204 204
205 205 int create_all_tasks( void )
206 206 {
207 207 rtems_status_code status;
208 208
209 209 // RECV
210 210 status = rtems_task_create(
211 211 Task_name[TASKID_RECV], 200, RTEMS_MINIMUM_STACK_SIZE * 2,
212 212 RTEMS_DEFAULT_MODES,
213 213 RTEMS_DEFAULT_ATTRIBUTES, &Task_id[TASKID_RECV]
214 214 );
215 215 // ACTN
216 216 status = rtems_task_create(
217 217 Task_name[TASKID_ACTN], 50, RTEMS_MINIMUM_STACK_SIZE * 2,
218 218 RTEMS_DEFAULT_MODES,
219 219 RTEMS_DEFAULT_ATTRIBUTES, &Task_id[TASKID_ACTN]
220 220 );
221 221 // SPIQ
222 222 status = rtems_task_create(
223 223 Task_name[TASKID_SPIQ], 5, RTEMS_MINIMUM_STACK_SIZE * 2,
224 224 RTEMS_DEFAULT_MODES | RTEMS_NO_PREEMPT,
225 225 RTEMS_DEFAULT_ATTRIBUTES, &Task_id[TASKID_SPIQ]
226 226 );
227 227 // SMIQ
228 228 status = rtems_task_create(
229 229 Task_name[TASKID_SMIQ], 10, RTEMS_MINIMUM_STACK_SIZE * 2,
230 230 RTEMS_DEFAULT_MODES | RTEMS_NO_PREEMPT,
231 231 RTEMS_DEFAULT_ATTRIBUTES, &Task_id[TASKID_SMIQ]
232 232 );
233 233 // STAT
234 234 status = rtems_task_create(
235 235 Task_name[TASKID_STAT], 150, RTEMS_MINIMUM_STACK_SIZE * 2,
236 236 RTEMS_DEFAULT_MODES,
237 237 RTEMS_DEFAULT_ATTRIBUTES, &Task_id[TASKID_STAT]
238 238 );
239 239 // AVF0
240 240 status = rtems_task_create(
241 241 Task_name[TASKID_AVF0], 50, RTEMS_MINIMUM_STACK_SIZE * 2,
242 242 RTEMS_DEFAULT_MODES | RTEMS_NO_PREEMPT,
243 243 RTEMS_DEFAULT_ATTRIBUTES | RTEMS_FLOATING_POINT, &Task_id[TASKID_AVF0]
244 244 );
245 245 // BPF0
246 246 status = rtems_task_create(
247 247 Task_name[TASKID_BPF0], 50, RTEMS_MINIMUM_STACK_SIZE * 2,
248 248 RTEMS_DEFAULT_MODES,
249 249 RTEMS_DEFAULT_ATTRIBUTES | RTEMS_FLOATING_POINT, &Task_id[TASKID_BPF0]
250 250 );
251 251 // WFRM
252 252 status = rtems_task_create(
253 253 Task_name[TASKID_WFRM], 100, RTEMS_MINIMUM_STACK_SIZE * 2,
254 254 RTEMS_DEFAULT_MODES,
255 255 RTEMS_DEFAULT_ATTRIBUTES | RTEMS_FLOATING_POINT, &Task_id[TASKID_WFRM]
256 256 );
257 257 // DUMB
258 258 status = rtems_task_create(
259 259 Task_name[TASKID_DUMB], 200, RTEMS_MINIMUM_STACK_SIZE * 2,
260 260 RTEMS_DEFAULT_MODES,
261 261 RTEMS_DEFAULT_ATTRIBUTES, &Task_id[TASKID_DUMB]
262 262 );
263 263 // HOUS
264 264 status = rtems_task_create(
265 265 Task_name[TASKID_HOUS], 199, RTEMS_MINIMUM_STACK_SIZE * 2,
266 266 RTEMS_DEFAULT_MODES,
267 267 RTEMS_DEFAULT_ATTRIBUTES, &Task_id[TASKID_HOUS]
268 268 );
269 269
270 270 return 0;
271 271 }
272 272
273 273 int start_all_tasks( void )
274 274 {
275 275 rtems_status_code status;
276 276
277 277 status = rtems_task_start( Task_id[TASKID_SPIQ], spiq_task, 1 );
278 278 if (status!=RTEMS_SUCCESSFUL) {
279 279 PRINTF("In INIT *** Error starting TASK_SPIQ\n")
280 280 }
281 281
282 282 status = rtems_task_start( Task_id[TASKID_RECV], recv_task, 1 );
283 283 if (status!=RTEMS_SUCCESSFUL) {
284 284 PRINTF("In INIT *** Error starting TASK_RECV\n")
285 285 }
286 286
287 287 status = rtems_task_start( Task_id[TASKID_ACTN], actn_task, 1 );
288 288 if (status!=RTEMS_SUCCESSFUL) {
289 289 PRINTF("In INIT *** Error starting TASK_ACTN\n")
290 290 }
291 291
292 292 status = rtems_task_start( Task_id[TASKID_SMIQ], smiq_task, 1 );
293 293 if (status!=RTEMS_SUCCESSFUL) {
294 294 PRINTF("In INIT *** Error starting TASK_BPPR\n")
295 295 }
296 296
297 297 status = rtems_task_start( Task_id[TASKID_STAT], stat_task, 1 );
298 298 if (status!=RTEMS_SUCCESSFUL) {
299 299 PRINTF("In INIT *** Error starting TASK_STAT\n")
300 300 }
301 301
302 302 status = rtems_task_start( Task_id[TASKID_AVF0], avf0_task, 1 );
303 303 if (status!=RTEMS_SUCCESSFUL) {
304 304 PRINTF("In INIT *** Error starting TASK_AVF0\n")
305 305 }
306 306
307 307 status = rtems_task_start( Task_id[TASKID_BPF0], bpf0_task, 1 );
308 308 if (status!=RTEMS_SUCCESSFUL) {
309 309 PRINTF("In INIT *** Error starting TASK_BPF0\n")
310 310 }
311 311
312 312 status = rtems_task_start( Task_id[TASKID_WFRM], wfrm_task, 1 );
313 313 if (status!=RTEMS_SUCCESSFUL) {
314 314 PRINTF("In INIT *** Error starting TASK_WFRM\n")
315 315 }
316 316
317 317 status = rtems_task_start( Task_id[TASKID_DUMB], dumb_task, 1 );
318 318 if (status!=RTEMS_SUCCESSFUL) {
319 319 PRINTF("In INIT *** Error starting TASK_DUMB\n")
320 320 }
321 321
322 322 status = rtems_task_start( Task_id[TASKID_HOUS], hous_task, 1 );
323 323 if (status!=RTEMS_SUCCESSFUL) {
324 324 PRINTF("In INIT *** Error starting TASK_HOUS\n")
325 325 }
326 326
327 327 return 0;
328 328 }
329 329
330 330 int configure_spw_link( void )
331 331 {
332 332 rtems_status_code status;
333 333
334 334 close(fdSPW); // close the device if it is already open
335 335 PRINTF("OK *** in configure_spw_link *** try to open "GRSPW_DEVICE_NAME"\n")
336 336 fdSPW = open(GRSPW_DEVICE_NAME, O_RDWR); // open the device. the open call reset the hardware
337 337 if (fdSPW<0) PRINTF("ERR *** in configure_spw_link *** Error opening"GRSPW_DEVICE_NAME"\n")
338 338 while(ioctl(fdSPW, SPACEWIRE_IOCTRL_START, 0) != RTEMS_SUCCESSFUL){
339 339 PRINTF(".")
340 340 fflush(stdout);
341 341 close(fdSPW); // close the device
342 342 fdSPW = open(GRSPW_DEVICE_NAME, O_RDWR); // open the device. the open call reset the hardware
343 343 if (fdSPW<0) PRINTF("ERR *** In configure_spw_link *** Error opening"GRSPW_DEVICE_NAME"\n")
344 344 rtems_task_wake_after(100);
345 345 }
346 346
347 347 PRINTF("OK *** In configure_spw_link *** "GRSPW_DEVICE_NAME" opened and started successfully\n")
348 348
349 349 configure_spacewire_set_NP(1, REGS_ADDR_GRSPW); // No Port force
350 350 configure_spacewire_set_RE(1, REGS_ADDR_GRSPW); // the dedicated call seems to break the no port force configuration
351 351
352 352 status = ioctl(fdSPW, SPACEWIRE_IOCTRL_SET_RXBLOCK, 1); // sets the blocking mode for reception
353 353 if (status!=RTEMS_SUCCESSFUL) PRINTF("in SPIQ *** Error SPACEWIRE_IOCTRL_SET_RXBLOCK\n")
354 354 //
355 355 status = ioctl(fdSPW, SPACEWIRE_IOCTRL_SET_EVENT_ID, Task_id[TASKID_SPIQ]); // sets the task ID to which an event is sent when a
356 356 if (status!=RTEMS_SUCCESSFUL) PRINTF("in SPIQ *** Error SPACEWIRE_IOCTRL_SET_EVENT_ID\n") // link-error interrupt occurs
357 357 //
358 358 status = ioctl(fdSPW, SPACEWIRE_IOCTRL_SET_DISABLE_ERR, 1); // automatic link-disabling due to link-error interrupts
359 359 if (status!=RTEMS_SUCCESSFUL) PRINTF("in SPIQ *** Error SPACEWIRE_IOCTRL_SET_DISABLE_ERR\n")
360 360 //
361 361 status = ioctl(fdSPW, SPACEWIRE_IOCTRL_SET_LINK_ERR_IRQ, 1); // sets the link-error interrupt bit
362 362 if (status!=RTEMS_SUCCESSFUL) PRINTF("in SPIQ *** Error SPACEWIRE_IOCTRL_SET_LINK_ERR_IRQ\n")
363 363 //
364 364 status = ioctl(fdSPW, SPACEWIRE_IOCTRL_SET_TXBLOCK_ON_FULL, 0); // transmission blocks on full
365 365 if (status!=RTEMS_SUCCESSFUL) PRINTF("in SPIQ *** Error SPACEWIRE_IOCTRL_SET_TXBLOCK_ON_FULL\n")
366 366 //
367 367 status = ioctl(fdSPW, SPACEWIRE_IOCTRL_SET_TCODE_CTRL, 0x0909);
368 368 if (status!=RTEMS_SUCCESSFUL) PRINTF("in SPIQ *** Error SPACEWIRE_IOCTRL_SET_TCODE_CTRL,\n")
369 369
370 370 PRINTF("OK *** in configure_spw_link *** "GRSPW_DEVICE_NAME" configured successfully\n")
371 371
372 372 return RTEMS_SUCCESSFUL;
373 373 }
374 374
375 375 void configure_spacewire_set_NP(unsigned char val, unsigned int regAddr) // [N]o [P]ort force
376 376 {
377 377 unsigned int *spwptr = (unsigned int*) regAddr;
378 378
379 379 if (val == 1) {
380 380 *spwptr = *spwptr | 0x00100000; // [NP] set the No port force bit
381 381 }
382 382 if (val== 0) {
383 383 *spwptr = *spwptr & 0xffdfffff;
384 384 }
385 385 }
386 386
387 387 void configure_spacewire_set_RE(unsigned char val, unsigned int regAddr) // [R]MAP [E]nable
388 388 {
389 389 unsigned int *spwptr = (unsigned int*) regAddr;
390 390
391 391 if (val == 1)
392 392 {
393 393 *spwptr = *spwptr | 0x00010000; // [RE] set the RMAP Enable bit
394 394 }
395 395 if (val== 0)
396 396 {
397 397 *spwptr = *spwptr & 0xfffdffff;
398 398 }
399 399 }
400 400
401 401 rtems_status_code write_spw(spw_ioctl_pkt_send* spw_ioctl_send)
402 402 {
403 403 rtems_status_code status;
404 404 status = ioctl( fdSPW, SPACEWIRE_IOCTRL_SEND, spw_ioctl_send );
405 405 return status;
406 406 }
407 407
408 408 void timecode_irq_handler(void *pDev, void *regs, int minor, unsigned int tc)
409 409 {
410 410 if (rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_1 ) != RTEMS_SUCCESSFUL) {
411 411 printf("In timecode_irq_handler *** Error sending event to DUMB\n");
412 412 }
413 413 }
414 414
Show file before | Show file after | Hide comments
@@ -1,711 +1,736
1 1 #include <tc_handler.h>
2 2 #include <fsw_params.h>
3 3
4 4 char *DumbMessages[5] = {"default",
5 5 "timecode_irq_handler",
6 6 "waveforms_isr",
7 7 "",
8 8 ""
9 9 };
10 10
11 11 unsigned char currentTC_LEN_RCV[2]; // SHALL be equal to the current TC packet estimated packet length field
12 12 unsigned char currentTC_COMPUTED_CRC[2];
13 13 unsigned int currentTC_LEN_RCV_AsUnsignedInt;
14 14 unsigned int currentTM_length;
15 15 unsigned char currentTC_processedFlag;
16 16
17 17 unsigned int lookUpTableForCRC[256];
18 18
19 19 //**********************
20 20 // GENERAL USE FUNCTIONS
21 21 unsigned int Crc_opt( unsigned char D, unsigned int Chk)
22 22 {
23 23 return(((Chk << 8) & 0xff00)^lookUpTableForCRC [(((Chk >> 8)^D) & 0x00ff)]);
24 24 }
25 25
26 26 void initLookUpTableForCRC( void )
27 27 {
28 28 unsigned int i;
29 29 unsigned int tmp;
30 30
31 31 for (i=0; i<256; i++)
32 32 {
33 33 tmp = 0;
34 34 if((i & 1) != 0) {
35 35 tmp = tmp ^ 0x1021;
36 36 }
37 37 if((i & 2) != 0) {
38 38 tmp = tmp ^ 0x2042;
39 39 }
40 40 if((i & 4) != 0) {
41 41 tmp = tmp ^ 0x4084;
42 42 }
43 43 if((i & 8) != 0) {
44 44 tmp = tmp ^ 0x8108;
45 45 }
46 46 if((i & 16) != 0) {
47 47 tmp = tmp ^ 0x1231;
48 48 }
49 49 if((i & 32) != 0) {
50 50 tmp = tmp ^ 0x2462;
51 51 }
52 52 if((i & 64) != 0) {
53 53 tmp = tmp ^ 0x48c4;
54 54 }
55 55 if((i & 128) != 0) {
56 56 tmp = tmp ^ 0x9188;
57 57 }
58 58 lookUpTableForCRC[i] = tmp;
59 59 }
60 60 }
61 61
62 62 void GetCRCAsTwoBytes(unsigned char* data, unsigned char* crcAsTwoBytes, unsigned int sizeOfData)
63 63 {
64 64 unsigned int Chk;
65 65 int j;
66 66 Chk = 0xffff; // reset the syndrom to all ones
67 67 for (j=0; j<sizeOfData; j++) {
68 68 Chk = Crc_opt(data[j], Chk);
69 69 }
70 70 crcAsTwoBytes[0] = (unsigned char) (Chk >> 8);
71 71 crcAsTwoBytes[1] = (unsigned char) (Chk & 0x00ff);
72 72 }
73 73
74 74 //*********************
75 75 // ACCEPTANCE FUNCTIONS
76 76 int TC_checker(ccsdsTelecommandPacket_t *TC, unsigned int tc_len_recv)
77 77 {
78 78 int ret = 0;
79 79 rtems_status_code status;
80 80 spw_ioctl_pkt_send spw_ioctl_send;
81 81 TMHeader_t TM_header;
82 82 unsigned int code = 0;
83 83 unsigned char computed_CRC[2];
84 84 char data[ TM_LEN_EXE_CORR + CCSDS_TC_TM_PACKET_OFFSET - TM_HEADER_LEN ];
85 85
86 86 GetCRCAsTwoBytes( (unsigned char*) TC->packetID, computed_CRC, tc_len_recv + 5 );
87 87 code = acceptTM( TC, tc_len_recv ) ;
88 88 if ( (code == 0) | (code == 1) | (code == 2)
89 89 | (code == 3) | (code == 4) | (code == 5) )
90 90 { // generate TM_LFR_TC_EXE_CORRUPTED
91 91 // BUILD HEADER
92 92 TM_build_header( TM_LFR_TC_EXE_ERR, TM_LEN_EXE_CORR, 0, 0, &TM_header);
93 93 // BUILD DATA
94 94 TM_build_data( TC, data, SID_EXE_CORR, computed_CRC);
95 95 // PREPARE TM SENDING
96 96 spw_ioctl_send.hlen = TM_HEADER_LEN + 4; // + 4 is for the protocole extra header
97 97 spw_ioctl_send.hdr = (char*) &TM_header;
98 98 spw_ioctl_send.dlen = 16;
99 99 spw_ioctl_send.data = data;
100 100 // SEND PACKET
101 101 write_spw(&spw_ioctl_send);
102 102 }
103 103 else { // send valid TC to the action launcher
104 104 status = rtems_message_queue_send( misc_id[0], TC, tc_len_recv + CCSDS_TC_TM_PACKET_OFFSET + 3);
105 105 ret = -1;
106 106 }
107 107 return ret;
108 108 }
109 109
110 110 unsigned char acceptTM(ccsdsTelecommandPacket_t * TMPacket, unsigned int TC_LEN_RCV)
111 111 {
112 112 unsigned char ret = 0;
113 113 unsigned char pid = 0;
114 114 unsigned char category = 0;
115 115 unsigned int length = 0;
116 116 unsigned char packetType = 0;
117 117 unsigned char packetSubtype = 0;
118 118 unsigned char * CCSDSContent = NULL;
119 119
120 120 // APID check *** APID on 2 bytes
121 121 pid = ((TMPacket->packetID[0] & 0x07)<<4) + ( (TMPacket->packetID[1]>>4) & 0x0f ); // PID = 11 *** 7 bits xxxxx210 7654xxxx
122 122 category = (TMPacket->packetID[1] & 0x0f); // PACKET_CATEGORY = 12 *** 4 bits xxxxxxxx xxxx3210
123 123 length = (TMPacket->packetLength[0] * 256) + TMPacket->packetLength[1];
124 124 packetType = TMPacket->dataFieldHeader[1];
125 125 packetSubtype = TMPacket->dataFieldHeader[2];
126 126
127 127 if (pid!=CCSDS_PROCESS_ID) {
128 128 ret = ILLEGAL_APID;
129 129 }
130 130 else if (category!=CCSDS_PACKET_CATEGORY) {
131 131 ret = ILLEGAL_APID;
132 132 }
133 133 else if (length != TC_LEN_RCV ) { // packet length check
134 134 ret = WRONG_LEN_PACKET; // LEN RCV != SIZE FIELD
135 135 }
136 136 else if (length >= CCSDS_TC_PKT_MAX_SIZE) {
137 137 ret = WRONG_LEN_PACKET; // check that the packet does not exceed the MAX size
138 138 }
139 139 else if (packetType == TC_TYPE_GEN){ // service type, subtype and packet length check
140 140 switch(packetSubtype){ //subtype, autorized values are 3, 20, 21, 24, 27, 28, 30, 40, 50, 60, 61
141 141 case TC_SUBTYPE_RESET:
142 142 if (length!=(TC_LEN_RESET-CCSDS_TC_TM_PACKET_OFFSET)) {
143 143 ret = WRONG_LEN_PACKET;
144 144 }
145 145 else {
146 146 ret = CCSDS_TM_VALID;
147 147 }
148 148 break;
149 149 case TC_SUBTYPE_LOAD_COMM:
150 150 if (length!=(TC_LEN_LOAD_COMM-CCSDS_TC_TM_PACKET_OFFSET)) {
151 151 ret = WRONG_LEN_PACKET;
152 152 }
153 153 else {
154 154 ret = CCSDS_TM_VALID;
155 155 }
156 156 break;
157 157 case TC_SUBTYPE_LOAD_NORM:
158 158 if (length!=(TC_LEN_LOAD_NORM-CCSDS_TC_TM_PACKET_OFFSET)) {
159 159 ret = WRONG_LEN_PACKET;
160 160 }
161 161 else {
162 162 ret = CCSDS_TM_VALID;
163 163 }
164 164 break;
165 165 case TC_SUBTYPE_LOAD_BURST:
166 166 if (length!=(TC_LEN_LOAD_BURST-CCSDS_TC_TM_PACKET_OFFSET)) {
167 167 ret = WRONG_LEN_PACKET;
168 168 }
169 169 else {
170 170 ret = CCSDS_TM_VALID;
171 171 }
172 172 break;
173 173 case TC_SUBTYPE_LOAD_SBM1:
174 174 if (length!=(TC_LEN_LOAD_SBM1-CCSDS_TC_TM_PACKET_OFFSET)) {
175 175 ret = WRONG_LEN_PACKET;
176 176 }
177 177 else {
178 178 ret = CCSDS_TM_VALID;
179 179 }
180 180 break;
181 181 case TC_SUBTYPE_LOAD_SBM2:
182 182 if (length!=(TC_LEN_LOAD_SBM2-CCSDS_TC_TM_PACKET_OFFSET)) {
183 183 ret = WRONG_LEN_PACKET;
184 184 }
185 185 else {
186 186 ret = CCSDS_TM_VALID;
187 187 }
188 188 break;
189 189 case TC_SUBTYPE_DUMP:
190 190 if (length!=(TC_LEN_DUMP-CCSDS_TC_TM_PACKET_OFFSET)) {
191 191 ret = WRONG_LEN_PACKET;
192 192 }
193 193 else {
194 194 ret = CCSDS_TM_VALID;
195 195 }
196 196 break;
197 197 case TC_SUBTYPE_ENTER:
198 198 if (length!=(TC_LEN_ENTER-CCSDS_TC_TM_PACKET_OFFSET)) {
199 199 ret = WRONG_LEN_PACKET;
200 200 }
201 201 else {
202 202 ret = CCSDS_TM_VALID;
203 203 }
204 204 break;
205 205 case TC_SUBTYPE_UPDT_INFO:
206 206 if (length!=(TC_LEN_UPDT_INFO-CCSDS_TC_TM_PACKET_OFFSET)) {
207 207 ret = WRONG_LEN_PACKET;
208 208 }
209 209 else {
210 210 ret = CCSDS_TM_VALID;
211 211 }
212 212 break;
213 213 case TC_SUBTYPE_EN_CAL:
214 214 if (length!=(TC_LEN_EN_CAL-CCSDS_TC_TM_PACKET_OFFSET)) {
215 215 ret = WRONG_LEN_PACKET;
216 216 }
217 217 else {
218 218 ret = CCSDS_TM_VALID;
219 219 }
220 220 break;
221 221 case TC_SUBTYPE_DIS_CAL:
222 222 if (length!=(TC_LEN_DIS_CAL-CCSDS_TC_TM_PACKET_OFFSET)) {
223 223 ret = WRONG_LEN_PACKET;
224 224 }
225 225 else {
226 226 ret = CCSDS_TM_VALID;
227 227 }
228 228 break;
229 229 default:
230 230 ret = ILL_SUBTYPE;
231 231 break;
232 232 }
233 233 }
234 234 else if (packetType == TC_TYPE_TIME){
235 235 if (packetSubtype!=TC_SUBTYPE_UPDT_TIME) {
236 236 ret = ILL_SUBTYPE;
237 237 }
238 238 else if (length!=(TC_LEN_UPDT_TIME-CCSDS_TC_TM_PACKET_OFFSET)) {
239 239 ret = WRONG_LEN_PACKET;
240 240 }
241 241 else {
242 242 ret = CCSDS_TM_VALID;
243 243 }
244 244 }
245 245 else {
246 246 ret = ILL_TYPE;
247 247 }
248 248
249 249 // source ID check // Source ID not documented in the ICD
250 250
251 251 // packet error control, CRC check
252 252 CCSDSContent = (unsigned char*) TMPacket->packetID;
253 253 GetCRCAsTwoBytes(CCSDSContent, currentTC_COMPUTED_CRC, length + CCSDS_TC_TM_PACKET_OFFSET - 2); // 2 CRC bytes removed from the calculation of the CRC
254 254 if (currentTC_COMPUTED_CRC[0] != CCSDSContent[length + CCSDS_TC_TM_PACKET_OFFSET -2]) {
255 255 ret = INCOR_CHECKSUM;
256 256 }
257 257 else if (currentTC_COMPUTED_CRC[1] != CCSDSContent[length + CCSDS_TC_TM_PACKET_OFFSET -1]) {
258 258 ret = INCOR_CHECKSUM;
259 259 }
260 260 else {
261 261 ret = CCSDS_TM_VALID;
262 262 }
263 263
264 264 return ret;
265 265 }
266 266
267 267 unsigned char TM_build_header( enum TM_TYPE tm_type, unsigned int packetLength,
268 268 unsigned int coarseTime, unsigned int fineTime, TMHeader_t *TMHeader)
269 269 {
270 270 TMHeader->targetLogicalAddress = CCSDS_DESTINATION_ID;
271 271 TMHeader->protocolIdentifier = 0x02;
272 272 TMHeader->reserved = 0x00;
273 273 TMHeader->userApplication = 0x00;
274 274 TMHeader->packetID[0] = 0x0c;
275 275 TMHeader->packetSequenceControl[0] = 0xc0;
276 276 TMHeader->packetSequenceControl[1] = 0x00;
277 277 TMHeader->packetLength[0] = (unsigned char) (packetLength>>8);
278 278 TMHeader->packetLength[1] = (unsigned char) packetLength;
279 279 TMHeader->dataFieldHeader[0] = 0x10;
280 280 TMHeader->dataFieldHeader[3] = CCSDS_DESTINATION_ID;
281 281 switch (tm_type){
282 282 case(TM_LFR_TC_EXE_OK):
283 283 TMHeader->packetID[1] = 0xc1;
284 284 TMHeader->dataFieldHeader[1] = 1; // type
285 285 TMHeader->dataFieldHeader[2] = 7; // subtype
286 286 break;
287 287 case(TM_LFR_TC_EXE_ERR):
288 288 TMHeader->packetID[1] = 0xc1;
289 289 TMHeader->dataFieldHeader[1] = 1; // type
290 290 TMHeader->dataFieldHeader[2] = 8; // subtype
291 291 break;
292 292 case(TM_LFR_HK):
293 293 TMHeader->packetID[1] = 0xc4;
294 294 TMHeader->dataFieldHeader[1] = 3; // type
295 295 TMHeader->dataFieldHeader[2] = 25; // subtype
296 296 break;
297 297 case(TM_LFR_SCI):
298 298 TMHeader->packetID[1] = 0xcc;
299 299 TMHeader->dataFieldHeader[1] = 21; // type
300 300 TMHeader->dataFieldHeader[2] = 3; // subtype
301 301 break;
302 302 case(TM_LFR_SCI_SBM):
303 303 TMHeader->packetID[1] = 0xfc;
304 304 TMHeader->dataFieldHeader[1] = 21; // type
305 305 TMHeader->dataFieldHeader[2] = 3; // subtype
306 306 break;
307 307 case(TM_LFR_PAR_DUMP):
308 308 TMHeader->packetID[1] = 0xc9;
309 309 TMHeader->dataFieldHeader[1] = 181; // type
310 310 TMHeader->dataFieldHeader[2] = 31; // subtype
311 311 break;
312 312 default:
313 313 return 0;
314 314 }
315 315 TMHeader->dataFieldHeader[4] = (unsigned char) (time_management_regs->coarse_time>>24);
316 316 TMHeader->dataFieldHeader[5] = (unsigned char) (time_management_regs->coarse_time>>16);
317 317 TMHeader->dataFieldHeader[6] = (unsigned char) (time_management_regs->coarse_time>>8);
318 318 TMHeader->dataFieldHeader[7] = (unsigned char) (time_management_regs->coarse_time);
319 319 TMHeader->dataFieldHeader[8] = (unsigned char) (time_management_regs->fine_time>>8);
320 320 TMHeader->dataFieldHeader[9] = (unsigned char) (time_management_regs->fine_time);
321 321 return 1;
322 322 }
323 323
324 324 unsigned char TM_build_header_bis( enum TM_TYPE tm_type, unsigned int packetLength,
325 325 unsigned int coarseTime, unsigned int fineTime, Packet_TM_LFR_TC_EXE_t *packet)
326 326 {
327 327
328 328 packet->targetLogicalAddress = CCSDS_DESTINATION_ID;
329 329 packet->protocolIdentifier = 0x02;
330 330 packet->reserved = 0x00;
331 331 packet->userApplication = 0x00;
332 332 packet->packetID[0] = 0x0c;
333 333 packet->packetSequenceControl[0] = 0xc0;
334 334 packet->packetSequenceControl[1] = 0x00;
335 335 packet->packetLength[0] = (unsigned char) (packetLength>>8);
336 336 packet->packetLength[1] = (unsigned char) packetLength;
337 337 packet->dataFieldHeader[0] = 0x10;
338 338 packet->dataFieldHeader[3] = CCSDS_DESTINATION_ID;
339 339 switch (tm_type){
340 340 case(TM_LFR_TC_EXE_OK):
341 341 packet->packetID[1] = 0xc1;
342 342 packet->dataFieldHeader[1] = 1; // type
343 343 packet->dataFieldHeader[2] = 7; // subtype
344 344 break;
345 345 case(TM_LFR_TC_EXE_ERR):
346 346 packet->packetID[1] = 0xc1;
347 347 packet->dataFieldHeader[1] = 1; // type
348 348 packet->dataFieldHeader[2] = 8; // subtype
349 349 break;
350 350 case(TM_LFR_HK):
351 351 packet->packetID[1] = 0xc4;
352 352 packet->dataFieldHeader[1] = 3; // type
353 353 packet->dataFieldHeader[2] = 25; // subtype
354 354 break;
355 355 case(TM_LFR_SCI):
356 356 packet->packetID[1] = 0xcc;
357 357 packet->dataFieldHeader[1] = 21; // type
358 358 packet->dataFieldHeader[2] = 3; // subtype
359 359 break;
360 360 case(TM_LFR_SCI_SBM):
361 361 packet->packetID[1] = 0xfc;
362 362 packet->dataFieldHeader[1] = 21; // type
363 363 packet->dataFieldHeader[2] = 3; // subtype
364 364 break;
365 365 case(TM_LFR_PAR_DUMP):
366 366 packet->packetID[1] = 0xc9;
367 367 packet->dataFieldHeader[1] = 181; // type
368 368 packet->dataFieldHeader[2] = 31; // subtype
369 369 break;
370 370 default:
371 371 return 0;
372 372 }
373 373 packet->dataFieldHeader[4] = (unsigned char) (time_management_regs->coarse_time>>24);
374 374 packet->dataFieldHeader[5] = (unsigned char) (time_management_regs->coarse_time>>16);
375 375 packet->dataFieldHeader[6] = (unsigned char) (time_management_regs->coarse_time>>8);
376 376 packet->dataFieldHeader[7] = (unsigned char) (time_management_regs->coarse_time);
377 377 packet->dataFieldHeader[8] = (unsigned char) (time_management_regs->fine_time>>8);
378 378 packet->dataFieldHeader[9] = (unsigned char) (time_management_regs->fine_time);
379 379 return 1;
380 380 }
381 381
382 382 unsigned char TM_build_data(ccsdsTelecommandPacket_t *TC, char* data, unsigned int SID, unsigned char *computed_CRC)
383 383 {
384 384 unsigned int packetLength;
385 385 packetLength = (TC->packetLength[0] * 256) + TC->packetLength[1];
386 386 switch (SID){
387 387 case (SID_NOT_EXE):
388 388 break;
389 389 case (SID_NOT_IMP):
390 390 data[0] = 0x9c;
391 391 data[1] = 0x42;
392 392 data[2] = TC->packetID[0];
393 393 data[3] = TC->packetID[1];
394 394 data[4] = TC->packetSequenceControl[0];
395 395 data[5] = TC->packetSequenceControl[1];
396 396 data[6] = TC->dataFieldHeader[1]; // type
397 397 data[7] = TC->dataFieldHeader[2]; // subtype
398 398 break;
399 399 case (SID_EXE_ERR):
400 400 break;
401 401 case (SID_EXE_CORR):
402 402 data[0] = 0x9c;
403 403 data[1] = 0x45;
404 404 data[2] = TC->packetID[0];
405 405 data[3] = TC->packetID[1];
406 406 data[4] = TC->packetSequenceControl[0];
407 407 data[5] = TC->packetSequenceControl[1];
408 408 data[6] = TC->dataFieldHeader[1]; // type
409 409 data[7] = TC->dataFieldHeader[2]; // subtype
410 410 data[8] = currentTC_LEN_RCV[0];
411 411 data[9] = currentTC_LEN_RCV[1];
412 412 data[10] = TC->packetLength[0];
413 413 data[11] = TC->packetLength[1];
414 414 data[12] = TC->dataAndCRC[packetLength];
415 415 data[13] = TC->dataAndCRC[packetLength+1];
416 416 data[14] = computed_CRC[0];
417 417 data[15] = computed_CRC[1];
418 418 break;
419 419 default:
420 420 return 0;
421 421 }
422 422 return 1;
423 423 }
424 424
425 425 int create_message_queue( void )
426 426 {
427 427 rtems_status_code status;
428 428 misc_name[0] = rtems_build_name( 'Q', 'U', 'E', 'U' );
429 429 status = rtems_message_queue_create( misc_name[0], ACTION_MSG_QUEUE_COUNT, CCSDS_TC_PKT_MAX_SIZE,
430 430 RTEMS_FIFO | RTEMS_LOCAL, &misc_id[0] );
431 431 if (status!=RTEMS_SUCCESSFUL) {
432 432 PRINTF("in create_message_queue *** error creating message queue\n")
433 433 }
434 434
435 435 return 0;
436 436 }
437 437
438 438 //***********
439 439 // RTEMS TASK
440 440 rtems_task recv_task( rtems_task_argument unused )
441 441 {
442 442 int len = 0;
443 443 unsigned int i = 0;
444 444 unsigned int data_length = 0;
445 445 ccsdsTelecommandPacket_t currentTC;
446 446 char data[100];
447 447
448 448 for(i=0; i<100; i++) data[i] = 0;
449 449
450 450 PRINTF("in RECV *** \n")
451 451
452 452 while(1)
453 453 {
454 454 len = read(fdSPW, (char*) &currentTC, CCSDS_TC_PKT_MAX_SIZE); // the call to read is blocking
455 455 if (len == -1){ // error during the read call
456 456 PRINTF("In RECV *** last read call returned -1\n")
457 457 if (rtems_event_send( Task_id[3], SPW_LINKERR_EVENT ) != RTEMS_SUCCESSFUL) {
458 458 PRINTF("IN RECV *** Error: rtems_event_send SPW_LINKERR_EVENT\n")
459 459 }
460 460 if (rtems_task_suspend(RTEMS_SELF) != RTEMS_SUCCESSFUL) {
461 461 PRINTF("In RECV *** Error: rtems_task_suspend(RTEMS_SELF)\n")
462 462 }
463 463 }
464 464 else {
465 465 PRINTF1("Got pck of length %d\n", len+1)
466 466 currentTC_LEN_RCV[0] = 0x00;
467 467 currentTC_LEN_RCV[1] = (unsigned char) (len - CCSDS_TC_TM_PACKET_OFFSET - 3); // build the corresponding packet size field
468 468 currentTC_LEN_RCV_AsUnsignedInt = (unsigned int) (len - CCSDS_TC_TM_PACKET_OFFSET - 3); // => -3 is for Prot ID, Reserved and User App bytes
469 469 // CHECK THE TC AND BUILD THE APPROPRIATE TM
470 470 data_length = TC_checker(&currentTC, currentTC_LEN_RCV_AsUnsignedInt);
471 471 if (data_length!=-1)
472 472 {
473 473 }
474 474 }
475 475 }
476 476 }
477 477
478 478 rtems_task actn_task( rtems_task_argument unused )
479 479 {
480 480 int result = 0;
481 481 rtems_status_code status; // RTEMS status code
482 482 ccsdsTelecommandPacket_t TC; // TC sent to the ACTN task
483 483 size_t size; // size of the incoming TC packet
484 484 unsigned char subtype = 0; // subtype of the current TC packet
485 485
486 486 PRINTF("in ACTN *** \n")
487 487
488 488 while(1)
489 489 {
490 490 status = rtems_message_queue_receive(misc_id[0], (char*) &TC, &size,
491 491 RTEMS_WAIT, RTEMS_NO_TIMEOUT);
492 492 if (status!=RTEMS_SUCCESSFUL) PRINTF1("in task ACTN *** error receiving a message, code %d \n", status)
493 493 else
494 494 {
495 495 subtype = TC.dataFieldHeader[2];
496 496 switch(subtype)
497 497 {
498 498 case TC_SUBTYPE_RESET:
499 499 result = action_default( &TC );
500 500 break;
501 501 //
502 502 case TC_SUBTYPE_LOAD_COMM:
503 503 result = action_default( &TC );
504 504 break;
505 505 //
506 506 case TC_SUBTYPE_LOAD_NORM:
507 507 result = action_load_norm( &TC );
508 508 send_tm_lfr_tc_exe_success( &TC );
509 509 break;
510 510 //
511 511 case TC_SUBTYPE_LOAD_BURST:
512 512 result = action_default( &TC );
513 513 break;
514 514 //
515 515 case TC_SUBTYPE_LOAD_SBM1:
516 516 result = action_default( &TC );
517 517 break;
518 518 //
519 519 case TC_SUBTYPE_LOAD_SBM2:
520 520 result = action_default( &TC );
521 521 break;
522 522 //
523 523 case TC_SUBTYPE_DUMP:
524 524 result = action_default( &TC );
525 525 break;
526 526 //
527 527 case TC_SUBTYPE_ENTER:
528 528 result = action_enter( &TC );
529 529 send_tm_lfr_tc_exe_success( &TC );
530 530 break;
531 531 //
532 532 case TC_SUBTYPE_UPDT_INFO:
533 533 result = action_default( &TC );
534 534 break;
535 535 //
536 536 case TC_SUBTYPE_EN_CAL:
537 537 result = action_default( &TC );
538 538 break;
539 539 //
540 540 case TC_SUBTYPE_DIS_CAL:
541 541 result = action_default( &TC );
542 542 break;
543 543 //
544 544 case TC_SUBTYPE_UPDT_TIME:
545 545 result = action_updt_time( &TC );
546 546 send_tm_lfr_tc_exe_success( &TC );
547 547 break;
548 548 //
549 549 default:
550 550 break;
551 551 }
552 552 }
553 553 }
554 554 }
555 555
556 556 rtems_task dumb_task( rtems_task_argument unused )
557 557 {
558 558 unsigned int coarse_time = 0;
559 559 unsigned int fine_time = 0;
560 560 unsigned int indice = 0;
561 561 unsigned int shiftedIndice = 0;
562 562 rtems_event_set event_out;
563 563
564 564 PRINTF("in DUMB *** \n")
565 565
566 566 while(1){
567 567 rtems_event_receive(RTEMS_EVENT_1, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT0
568 568 indice = 0;
569 569 shiftedIndice = (unsigned int) event_out;
570 570 while(!(shiftedIndice & 0x0001))
571 571 {
572 572 shiftedIndice = shiftedIndice >> 1;
573 573 indice++;
574 574 }
575 575 coarse_time = time_management_regs->coarse_time;
576 576 fine_time = time_management_regs->fine_time;
577 577 printf("in DUMB *** time = coarse: %x, fine: %x, %s\n", coarse_time, fine_time, DumbMessages[indice]);
578 578 }
579 579 }
580 580
581 581 //***********
582 582 // TC ACTIONS
583 583
584 584 int action_default(ccsdsTelecommandPacket_t *TC)
585 585 {
586 586 Packet_TM_LFR_TC_EXE_t packet;
587 587
588 588 TM_build_header_bis( TM_LFR_TC_EXE_ERR, TM_LEN_NOT_IMP,
589 589 time_management_regs->coarse_time, time_management_regs->fine_time, &packet);
590 590
591 591 packet.data[0] = 0x9c;
592 592 packet.data[1] = 0x42;
593 593 packet.data[2] = TC->packetID[0];
594 594 packet.data[3] = TC->packetID[1];
595 595 packet.data[4] = TC->packetSequenceControl[0];
596 596 packet.data[5] = TC->packetSequenceControl[1];
597 597 packet.data[6] = TC->dataFieldHeader[1]; // type
598 598 packet.data[7] = TC->dataFieldHeader[2]; // subtype
599 599
600 600 // SEND DATA
601 601 if (write ( fdSPW, &packet, LEN_TM_LFR_TC_EXE_NOT_IMP)==-1) {
602 602 PRINTF("ERR *** in action_default *** send TM packet\n");
603 603 }
604 604
605 605 return 0;
606 606 }
607 607
608 608 int action_enter(ccsdsTelecommandPacket_t *TC)
609 609 {
610 610 unsigned char lfr_mode = TC->dataAndCRC[1];
611 611 printf("enter mode %d\n", lfr_mode);
612 612 switch(lfr_mode)
613 613 {
614 //********
615 // STANDBY
614 616 case(LFR_MODE_STANDBY):
615 617 LEON_Mask_interrupt( IRQ_WF );
616 618 LEON_Mask_interrupt( IRQ_SM );
617 619 LEON_Mask_interrupt( IRQ_WAVEFORM_PICKER );
618 620 waveform_picker_regs->burst_enable = 0x00;
619 621 break;
622
623 //******
624 // NORMAL
620 625 case(LFR_MODE_NORMAL):
621
622 626 #ifdef GSA
623 627 LEON_Unmask_interrupt( IRQ_WF );
624 628 #else
625 629 LEON_Clear_interrupt( IRQ_WAVEFORM_PICKER );
626 630 LEON_Unmask_interrupt( IRQ_WAVEFORM_PICKER );
627 631 waveform_picker_regs->burst_enable = 0x07;
628 632 waveform_picker_regs->status = 0x00;
629 633 #endif
634 LEON_Unmask_interrupt( IRQ_SM );
635 break;
630 636
631 break;
637 //******
638 // BURST
632 639 case(LFR_MODE_BURST):
633 640 break;
641
642 //*****
643 // SBM1
634 644 case(LFR_MODE_SBM1):
645 #ifdef GSA
646 #else
647 LEON_Clear_interrupt( IRQ_WAVEFORM_PICKER );
648 LEON_Unmask_interrupt( IRQ_WAVEFORM_PICKER );
649 waveform_picker_regs->burst_enable = 0x20; // [0010 0000] burst f2, f1, f0 enable f3 f2 f1 f0
650 waveform_picker_regs->burst_enable = waveform_picker_regs->burst_enable | 0x02;
651 waveform_picker_regs->status = 0x00;
652 #endif
653 //LEON_Unmask_interrupt( IRQ_SM );
635 654 break;
655
656 //*****
657 // SBM2
636 658 case(LFR_MODE_SBM2):
637 659 break;
660
661 //********
662 // DEFAULT
638 663 default:
639 664 break;
640 665 }
641 666 return 0;
642 667 }
643 668
644 669 int action_load_norm(ccsdsTelecommandPacket_t *TC)
645 670 {
646 671 param_norm.sy_lfr_n_swf_l = (TC->dataAndCRC[0] * 256) + TC->dataAndCRC[1];
647 672 param_norm.sy_lfr_n_swf_p = (TC->dataAndCRC[2] * 256) + TC->dataAndCRC[3];
648 673 param_norm.sy_lfr_n_asm_p = (TC->dataAndCRC[4] * 256) + TC->dataAndCRC[5];
649 674 param_norm.sy_lfr_n_bp_p0 = TC->dataAndCRC[6];
650 675 param_norm.sy_lfr_n_bp_p1 = TC->dataAndCRC[7];
651 676 /*printf("sy_lfr_n_ => swf_l %d, swf_p %d, asm_p %d, bsp_p0 %d, bsp_p1 %d\n",
652 677 param_norm.sy_lfr_n_swf_l, param_norm.sy_lfr_n_swf_p,
653 678 param_norm.sy_lfr_n_asm_p, param_norm.sy_lfr_n_bp_p0, param_norm.sy_lfr_n_bp_p1);*/
654 679 return 0;
655 680 }
656 681
657 682 int action_updt_time(ccsdsTelecommandPacket_t *TC)
658 683 {
659 684 time_management_regs->coarse_time_load = (TC->dataAndCRC[0] << 24)
660 685 + (TC->dataAndCRC[1] << 16)
661 686 + (TC->dataAndCRC[2] << 8)
662 687 + TC->dataAndCRC[3];
663 688 //time_management_regs->ctrl = time_management_regs->ctrl | 1;
664 689 return 0;
665 690 }
666 691
667 692 int send_tm_lfr_tc_exe_success(ccsdsTelecommandPacket_t *TC)
668 693 {
669 694 TMHeader_t TM_header;
670 695 char data[4];
671 696 spw_ioctl_pkt_send spw_ioctl_send;
672 697
673 698 TM_build_header( TM_LFR_TC_EXE_OK, TM_LEN_EXE,
674 699 time_management_regs->coarse_time, time_management_regs->fine_time, &TM_header);
675 700
676 701 data[0] = TC->packetID[0];
677 702 data[1] = TC->packetID[1];
678 703 data[2] = TC->packetSequenceControl[0];
679 704 data[3] = TC->packetSequenceControl[1];
680 705
681 706 // filling the structure for the spacewire transmission
682 707 spw_ioctl_send.hlen = TM_HEADER_LEN + 3; // + 4 is for the protocole extra header
683 708 spw_ioctl_send.hdr = (char*) &TM_header;
684 709 spw_ioctl_send.dlen = 3;
685 710 spw_ioctl_send.data = data;
686 711
687 712 // SEND DATA
688 713 write_spw(&spw_ioctl_send);
689 714
690 715 return 0;
691 716 }
692 717
693 718 //***************************
694 719 // Interrupt Service Routines
695 720 rtems_isr commutation_isr1( rtems_vector_number vector )
696 721 {
697 722 if (rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
698 723 printf("In commutation_isr1 *** Error sending event to DUMB\n");
699 724 }
700 725 }
701 726
702 727 rtems_isr commutation_isr2( rtems_vector_number vector )
703 728 {
704 729 if (rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
705 730 printf("In commutation_isr2 *** Error sending event to DUMB\n");
706 731 }
707 732 }
708 733
709 734
710 735
711 736
Show file before | Show file after | Hide comments
@@ -1,309 +1,312
1 1 #include <wf_handler.h>
2 2
3 3 rtems_isr waveforms_isr( rtems_vector_number vector )
4 4 {
5 if ( (waveform_picker_regs->burst_enable & 0x7) == 0x0 ){// if no channel is enable
5 if (rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2 ) != RTEMS_SUCCESSFUL) {
6 printf("In waveforms_isr *** Error sending event to WFRM\n");
7 }
8 if (waveform_picker_regs->burst_enable == 0x22) {
9 if (waveform_picker_regs->addr_data_f1 == (int) wf_snap_f1) {
10 waveform_picker_regs->addr_data_f1 = (int) (wf_snap_f1_bis);
11 }
12 else {
13 waveform_picker_regs->addr_data_f1 = (int) (wf_snap_f1);
14 }
15 if (rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
16 printf("In waveforms_isr *** Error sending event to WFRM\n");
17 }
18 }
19 waveform_picker_regs->status = 0x00;
20 /*else if ( (waveform_picker_regs->burst_enable & 0x7) == 0x0 ){// if no channel is enable
6 21 if (rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2 ) != RTEMS_SUCCESSFUL) {
7 22 printf("In timecode_irq_handler *** Error sending event to DUMB\n");
8 23 }
9 24 }
10 25 else {
11 26 if ( (waveform_picker_regs->status & 0x7) == 0x7 ){ // f2 f1 and f0 are full
12 27 waveform_picker_regs->burst_enable = 0x00;
13 28 if (rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
14 29 printf("In waveforms_isr *** Error sending event to WFRM\n");
15 30 }
16 31 }
17 }
32 }*/
18 33 }
19 34
20 35 rtems_isr waveforms_simulator_isr( rtems_vector_number vector )
21 36 {
22 37 if (rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
23 38 printf("In waveforms_isr *** Error sending event to WFRM\n");
24 39 }
25 40 }
26 41
27 42 rtems_task wfrm_task(rtems_task_argument argument) //used with the waveform picker VHDL IP
28 43 {
29 44 spw_ioctl_pkt_send spw_ioctl_send;
30 45 rtems_event_set event_out;
31 46 ExtendedTMHeader_t header;
32 47
33 48 header.targetLogicalAddress = CCSDS_DESTINATION_ID;
34 49 header.protocolIdentifier = CCSDS_PROTOCOLE_ID;
35 50 header.reserved = 0x00;
36 51 header.userApplication = CCSDS_USER_APP;
37 52 header.packetID[0] = 0x0c;
38 53 header.packetID[1] = 0xcc;
39 54 header.packetSequenceControl[0] = 0x00;
40 55 header.packetSequenceControl[1] = 0x00;
41 56 header.packetLength[0] = 0x00;
42 57 header.packetLength[1] = 0x00;
43 58 header.dataFieldHeader[0] = 0x10;
44 59 header.dataFieldHeader[1] = TM_TYPE_LFR_SCIENCE; // service type
45 60 header.dataFieldHeader[2] = TM_SUBTYPE_LFR_SCIENCE; // service subtype
46 61 header.dataFieldHeader[3] = CCSDS_DESTINATION_ID_GROUND;
47 62
48 63 header.auxiliaryHeader[0] = 0x00;
49 64 header.auxiliaryHeader[1] = 0x1f;
50 65 header.auxiliaryHeader[2] = 0x07; // PKT_CNT
51 66 header.auxiliaryHeader[3] = 0x00; // PKT_NR
52 67 header.auxiliaryHeader[4] = 0x00; // BLK_NR MSB
53 68 header.auxiliaryHeader[5] = 0x00; // BLK_NR LSB
54 69
55 70 // BUILD THE PACKET HEADER
56 71 spw_ioctl_send.hlen = TM_HEADER_LEN + 4 + 6; // + 4 is for the protocole extra header, + 6 is for the auxiliary header
57 72 spw_ioctl_send.hdr = (char*) &header;
58 73
59 74 init_waveforms();
60 75
61 76 PRINTF("in WFRM ***\n")
62 77
63 78 while(1){
64 79
65 80 rtems_event_receive(RTEMS_EVENT_0, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT0
66 81 PRINTF("in WFRM *** send wfrm\n")
67 82 header.dataFieldHeader[4] = (unsigned char) (time_management_regs->coarse_time>>24);
68 83 header.dataFieldHeader[5] = (unsigned char) (time_management_regs->coarse_time>>16);
69 84 header.dataFieldHeader[6] = (unsigned char) (time_management_regs->coarse_time>>8);
70 85 header.dataFieldHeader[7] = (unsigned char) (time_management_regs->coarse_time);
71 86 header.dataFieldHeader[8] = (unsigned char) (time_management_regs->fine_time>>8);
72 87 header.dataFieldHeader[9] = (unsigned char) (time_management_regs->fine_time);
73 88
74 89 //***************
75 90 // send snapshots
76 91 // F0
77 send_waveform( &header, wf_snap_f0, SID_NORM_SWF_F0, &spw_ioctl_send);
92 //send_waveform( &header, wf_snap_f0, SID_NORM_SWF_F0, &spw_ioctl_send);
78 93 // F1
79 send_waveform( &header, wf_snap_f1, SID_NORM_SWF_F1, &spw_ioctl_send);
94 if (waveform_picker_regs->addr_data_f1 == (int) wf_snap_f1) {
95 send_waveform( &header, wf_snap_f1_bis, SID_NORM_SWF_F1, &spw_ioctl_send);
96 }
97 else {
98 send_waveform( &header, wf_snap_f1, SID_NORM_SWF_F1, &spw_ioctl_send);
99 }
80 100 // F2
81 send_waveform( &header, wf_snap_f2, SID_NORM_SWF_F2, &spw_ioctl_send);
101 //send_waveform( &header, wf_snap_f2, SID_NORM_SWF_F2, &spw_ioctl_send);
82 102
83 103 #ifdef GSA
84 104 // irq processed, reset the related register of the timer unit
85 105 gptimer_regs->timer[2].ctrl = gptimer_regs->timer[2].ctrl | 0x00000010;
86 106 #else
87 107 // irq processed, reset the related register of the waveform picker
88 waveform_picker_regs->status = 0x00;
89 waveform_picker_regs->burst_enable = 0x07;
108 //waveform_picker_regs->status = 0x00;
109 //waveform_picker_regs->burst_enable = 0x07;
90 110 #endif
91 111
92 112 }
93 113 }
94 114
95 115 //******************
96 116 // general functions
97 117 void init_waveforms( void )
98 118 {
99 119 int i = 0;
100 int aux1 = 0;
101 int aux2 = 0;
102 int val1 = 0;
103 int val2 = 0;
104 int val3 = 0;
105 int val4 = 0;
106 int amplitude1 = pow(2, 10);
107 static int delta_phi = 0;
108 120
109 121 for (i=0; i< NB_SAMPLES_PER_SNAPSHOT; i++)
110 122 {
111 aux1 = (int) (amplitude1 * cos((2*pi*i)/2048 + (delta_phi*pi)/180));
112 aux2 = (int) (amplitude1 * sin((2*pi*i)/2048 + (delta_phi*pi)/180));
113 val1 = build_value(aux1, aux2);
114 val2 = build_value(i, 2*i);
115 val3 = build_value(-aux1, -aux2);
116 val4 = build_value(-i, -2*i);
117 123 //***
118 124 // F0
119 125 wf_snap_f0[ (i* NB_WORDS_SWF_BLK) + 0 + TIME_OFFSET ] = 0x88887777; //
120 126 wf_snap_f0[ (i* NB_WORDS_SWF_BLK) + 1 + TIME_OFFSET ] = 0x22221111; //
121 127 wf_snap_f0[ (i* NB_WORDS_SWF_BLK) + 2 + TIME_OFFSET ] = 0x44443333; //
122 128
123 129 //***
124 130 // F1
125 wf_snap_f1[ (i* NB_WORDS_SWF_BLK) + 0 + TIME_OFFSET ] = val1;
126 wf_snap_f1[ (i* NB_WORDS_SWF_BLK) + 1 + TIME_OFFSET ] = val2;
131 wf_snap_f1[ (i* NB_WORDS_SWF_BLK) + 0 + TIME_OFFSET ] = 0x22221111;
132 wf_snap_f1[ (i* NB_WORDS_SWF_BLK) + 1 + TIME_OFFSET ] = 0x44443333;
127 133 wf_snap_f1[ (i* NB_WORDS_SWF_BLK) + 2 + TIME_OFFSET ] = 0xaaaa0000;
128 134
129 135 //***
130 136 // F2
131 wf_snap_f2[ (i* NB_WORDS_SWF_BLK) + 0 + TIME_OFFSET ] = val1;
132 wf_snap_f2[ (i* NB_WORDS_SWF_BLK) + 1 + TIME_OFFSET ] = val2;
137 wf_snap_f2[ (i* NB_WORDS_SWF_BLK) + 0 + TIME_OFFSET ] = 0x44443333;
138 wf_snap_f2[ (i* NB_WORDS_SWF_BLK) + 1 + TIME_OFFSET ] = 0x22221111;
133 139 wf_snap_f2[ (i* NB_WORDS_SWF_BLK) + 2 + TIME_OFFSET ] = 0xaaaa0000;
134 140
135 141 //***
136 142 // F3
137 143 //wf_cont_f3[ (i* NB_WORDS_SWF_BLK) + 0 ] = val1;
138 144 //wf_cont_f3[ (i* NB_WORDS_SWF_BLK) + 1 ] = val2;
139 145 //wf_cont_f3[ (i* NB_WORDS_SWF_BLK) + 2 ] = 0xaaaa0000;
140 146 }
141
142 delta_phi = delta_phi + 10;
143
144 147 }
145 148
146 149 void init_waveform_header( ExtendedTMHeader_t * header, unsigned int sid )
147 150 {
148 151
149 152 header->targetLogicalAddress = CCSDS_DESTINATION_ID;
150 153 header->protocolIdentifier = CCSDS_PROTOCOLE_ID;
151 154 header->reserved = 0x00;
152 155 header->userApplication = CCSDS_USER_APP;
153 156 header->packetID[0] = 0x0c;
154 157 header->packetID[1] = 0xcc;
155 158 header->packetSequenceControl[0] = 0x00;
156 159 header->packetSequenceControl[1] = 0x00;
157 160 header->packetLength[0] = 0x00;
158 161 header->packetLength[1] = 0x00;
159 162 header->dataFieldHeader[0] = 0x10;
160 163 header->dataFieldHeader[1] = TM_TYPE_LFR_SCIENCE; // service type
161 164 header->dataFieldHeader[2] = TM_SUBTYPE_LFR_SCIENCE; // service subtype
162 165 header->dataFieldHeader[3] = CCSDS_DESTINATION_ID_GROUND;
163 166
164 167 header->auxiliaryHeader[0] = sid;
165 168 header->auxiliaryHeader[1] = 0x1f;
166 169 header->auxiliaryHeader[2] = 0x07; // PKT_CNT
167 170 header->auxiliaryHeader[3] = 0x00; // PKT_NR
168 171 header->auxiliaryHeader[4] = 0x00; // BLK_NR MSB
169 172 header->auxiliaryHeader[5] = 0x00; // BLK_NR LSB
170 173 }
171 174
172 175 void reset_waveforms( void )
173 176 {
174 177 int i = 0;
175 178
176 179 for (i=0; i< NB_SAMPLES_PER_SNAPSHOT; i++)
177 180 {
178 181 wf_snap_f0[ (i* NB_WORDS_SWF_BLK) + 0 + TIME_OFFSET] = 0x10002000;
179 182 wf_snap_f0[ (i* NB_WORDS_SWF_BLK) + 1 + TIME_OFFSET] = 0x20001000;
180 183 wf_snap_f0[ (i* NB_WORDS_SWF_BLK) + 2 + TIME_OFFSET] = 0x40008000;
181 184
182 185 //***
183 186 // F1
184 187 wf_snap_f1[ (i* NB_WORDS_SWF_BLK) + 0 + TIME_OFFSET] = 0x1000f000;
185 188 wf_snap_f1[ (i* NB_WORDS_SWF_BLK) + 1 + TIME_OFFSET] = 0xf0001000;
186 189 wf_snap_f1[ (i* NB_WORDS_SWF_BLK) + 2 + TIME_OFFSET] = 0x40008000;
187 190
188 191 //***
189 192 // F2
190 193 wf_snap_f2[ (i* NB_WORDS_SWF_BLK) + 0 + TIME_OFFSET] = 0x40008000;
191 194 wf_snap_f2[ (i* NB_WORDS_SWF_BLK) + 1 + TIME_OFFSET] = 0x20001000;
192 195 wf_snap_f2[ (i* NB_WORDS_SWF_BLK) + 2 + TIME_OFFSET] = 0x10002000;
193 196
194 197 //***
195 198 // F3
196 199 /*wf_cont_f3[ i* NB_WORDS_SWF_BLK + 0 ] = build_value( i, i ); // v and 1
197 200 wf_cont_f3[ i* NB_WORDS_SWF_BLK + 1 ] = build_value( i, i ); // e2 and b1
198 201 wf_cont_f3[ i* NB_WORDS_SWF_BLK + 2 ] = build_value( i, i ); // b2 and b3*/
199 202 }
200 203 }
201 204
202 205 void send_waveform( ExtendedTMHeader_t *header, volatile int *waveform,
203 206 unsigned int sid, spw_ioctl_pkt_send *spw_ioctl_send)
204 207 {
205 208 unsigned int i = 0;
206 209 unsigned int length = 0;
207 210 rtems_status_code status;
208 211
209 212 for (i=0; i<7; i++) // send waveform
210 213 {
211 214 header->auxiliaryHeader[3] = (unsigned char) i+1; // PKT_NR
212 215 // BUILD THE DATA
213 216 if (i==6) {
214 217 spw_ioctl_send->dlen = 8 * NB_BYTES_SWF_BLK;
215 218 length = TM_LEN_SCI_NORM_SWF_8;
216 219 header->auxiliaryHeader[4] = 0x00; // BLK_NR MSB
217 220 header->auxiliaryHeader[5] = 0x08; // BLK_NR LSB
218 221 }
219 222 else {
220 223 spw_ioctl_send->dlen = 340 * NB_BYTES_SWF_BLK;
221 224 length = TM_LEN_SCI_NORM_SWF_340;
222 225 header->auxiliaryHeader[4] = 0x01; // BLK_NR MSB
223 226 header->auxiliaryHeader[5] = 0x54; // BLK_NR LSB
224 227 }
225 228 if (sid == SID_NORM_SWF_F0) {
226 229 spw_ioctl_send->data = (char*) &waveform[ (i * 340 * NB_WORDS_SWF_BLK) + (1 * TIME_OFFSET) ];
227 230 }
228 231 else if (sid == SID_NORM_SWF_F1) {
229 232 spw_ioctl_send->data = (char*) &waveform[ (i * 340 * NB_WORDS_SWF_BLK) + (1 * TIME_OFFSET) ];
230 233 }
231 234 else if (sid == SID_NORM_SWF_F2) {
232 spw_ioctl_send->data = (char*) &waveform[ (i * 340 * NB_WORDS_SWF_BLK) + (0 * TIME_OFFSET) ];
235 spw_ioctl_send->data = (char*) &waveform[ (i * 340 * NB_WORDS_SWF_BLK) + (1 * TIME_OFFSET) ];
233 236 }
234 237 else {
235 238 spw_ioctl_send->data = (char*) &waveform[ (i * 340 * NB_WORDS_SWF_BLK) ];
236 239 }
237 240 // BUILD THE HEADER
238 241 header->packetLength[0] = (unsigned char) (length>>8);
239 242 header->packetLength[1] = (unsigned char) (length);
240 243 header->auxiliaryHeader[0] = sid; // SID
241 244 // SEND PACKET
242 245 status = write_spw(spw_ioctl_send);
243 246 if (status != RTEMS_SUCCESSFUL) {
244 247 while (true) {
245 248 if (status != RTEMS_SUCCESSFUL) {
246 249 status = write_spw(spw_ioctl_send);
247 250 //PRINTF1("%d", i)
248 251 sched_yield();
249 252 }
250 253 else {
251 254 //PRINTF("\n")
252 255 break;
253 256 }
254 257 }
255 258 }
256 259 }
257 260 }
258 261
259 262 int build_value(int value1, int value0)
260 263 {
261 264 int aux = 0;
262 265 int aux1 = 0;
263 266 int aux0 = 0;
264 267 int value1_aux = 0;
265 268 int value0_aux = 0;
266 269
267 270 value1_aux = value1;
268 271 value0_aux = value0;
269 272
270 273 //******
271 274 // B3 B2
272 275 if (value1_aux > 8191) value1_aux = 8191;
273 276 if (value1_aux < -8192) value1_aux = -8192;
274 277 aux1 = ( (int) ( ( (unsigned char) (value1_aux / 256 ) ) << 8 ) )
275 278 + ( (int) ( (unsigned char) (value1_aux ) ) );
276 279
277 280 //******
278 281 // B1 B0
279 282 if (value0_aux > 8191) value0_aux = 8191;
280 283 if (value0_aux < -8192) value0_aux = -8192;
281 284 aux0 = ( (int) ( ( (unsigned char) (value0_aux / 256) ) << 8 ) )
282 285 + ( (int) ( (unsigned char) (value0_aux ) ) );
283 286
284 287 aux = (aux1 << 16) + aux0;
285 288
286 289 return aux;
287 290 }
288 291
289 292 void init_waveform_picker_regs()
290 293 { // 1 1 0 0 0 BW = 0 => BIAS_WORKS
291 294 waveform_picker_regs->data_shaping = 0x18; // R1 R0 SP1 SP0 BW
292 295 waveform_picker_regs->burst_enable = 0x00; // burst f2, f1, f0 enable f3, f2, f1, f0
293 296 waveform_picker_regs->addr_data_f0 = (int) (wf_snap_f0); //
294 297 waveform_picker_regs->addr_data_f1 = (int) (wf_snap_f1); //
295 298 waveform_picker_regs->addr_data_f2 = (int) (wf_snap_f2); //
296 299 waveform_picker_regs->addr_data_f3 = (int) (wf_cont_f3); //
297 300 waveform_picker_regs->status = 0x00; //
298 301 waveform_picker_regs->delta_snapshot = 0x5; // max 2 bytes
299 302 waveform_picker_regs->delta_f2_f1 = 0xffff; // max 4 bytes
300 303 waveform_picker_regs->delta_f2_f0 = 0x17c00; // max 5 bytes
301 304 waveform_picker_regs->nb_burst_available = 0x180; // max 3 bytes, size of the buffer in burst (1 burst = 16 x 4 octets)
302 305 waveform_picker_regs->nb_snapshot_param = 0x7ff; // max 3 octets, 2048 - 1
303 306 //waveform_picker_regs->delta_snapshot = 0x2; // max 2 bytes, = period / 2
304 307 //waveform_picker_regs->delta_f2_f1 = 0x2d00; // max 4 bytes
305 308 //waveform_picker_regs->delta_f2_f0 = 0x2f80; // max 5 bytes
306 309 //waveform_picker_regs->nb_burst_available = 0x30; // max 3 bytes, size of the buffer in burst (1 burst = 16 x 4 octets)
307 310 //waveform_picker_regs->nb_snapshot_param = 0xff; // max 3 octets, 256 - 1
308 311 }
309 312
General Comments 0
You need to be logged in to leave comments. Login now