##// END OF EJS Templates
Bug 912 champ HK_LFR_SC_POTENTIEL_FLAG passe à OFF...
paul -
r335:718b17428d4a R3_plus draft
parent child
Show More
@@ -1,2 +1,2
1 3081d1f9bb20b2b64a192585337a292a9804e0c5 LFR_basic-parameters
1 3081d1f9bb20b2b64a192585337a292a9804e0c5 LFR_basic-parameters
2 7c46de6059673d3239fcc7103e16510727f35923 header/lfr_common_headers
2 a34c50cabb1bc5e778bfc8374242e4683e4defc2 header/lfr_common_headers
@@ -1,988 +1,988
1 /** General usage functions and RTEMS tasks.
1 /** General usage functions and RTEMS tasks.
2 *
2 *
3 * @file
3 * @file
4 * @author P. LEROY
4 * @author P. LEROY
5 *
5 *
6 */
6 */
7
7
8 #include "fsw_misc.h"
8 #include "fsw_misc.h"
9
9
10 void timer_configure(unsigned char timer, unsigned int clock_divider,
10 void timer_configure(unsigned char timer, unsigned int clock_divider,
11 unsigned char interrupt_level, rtems_isr (*timer_isr)() )
11 unsigned char interrupt_level, rtems_isr (*timer_isr)() )
12 {
12 {
13 /** This function configures a GPTIMER timer instantiated in the VHDL design.
13 /** This function configures a GPTIMER timer instantiated in the VHDL design.
14 *
14 *
15 * @param gptimer_regs points to the APB registers of the GPTIMER IP core.
15 * @param gptimer_regs points to the APB registers of the GPTIMER IP core.
16 * @param timer is the number of the timer in the IP core (several timers can be instantiated).
16 * @param timer is the number of the timer in the IP core (several timers can be instantiated).
17 * @param clock_divider is the divider of the 1 MHz clock that will be configured.
17 * @param clock_divider is the divider of the 1 MHz clock that will be configured.
18 * @param interrupt_level is the interrupt level that the timer drives.
18 * @param interrupt_level is the interrupt level that the timer drives.
19 * @param timer_isr is the interrupt subroutine that will be attached to the IRQ driven by the timer.
19 * @param timer_isr is the interrupt subroutine that will be attached to the IRQ driven by the timer.
20 *
20 *
21 * Interrupt levels are described in the SPARC documentation sparcv8.pdf p.76
21 * Interrupt levels are described in the SPARC documentation sparcv8.pdf p.76
22 *
22 *
23 */
23 */
24
24
25 rtems_status_code status;
25 rtems_status_code status;
26 rtems_isr_entry old_isr_handler;
26 rtems_isr_entry old_isr_handler;
27
27
28 old_isr_handler = NULL;
28 old_isr_handler = NULL;
29
29
30 gptimer_regs->timer[timer].ctrl = INIT_CHAR; // reset the control register
30 gptimer_regs->timer[timer].ctrl = INIT_CHAR; // reset the control register
31
31
32 status = rtems_interrupt_catch( timer_isr, interrupt_level, &old_isr_handler) ; // see sparcv8.pdf p.76 for interrupt levels
32 status = rtems_interrupt_catch( timer_isr, interrupt_level, &old_isr_handler) ; // see sparcv8.pdf p.76 for interrupt levels
33 if (status!=RTEMS_SUCCESSFUL)
33 if (status!=RTEMS_SUCCESSFUL)
34 {
34 {
35 PRINTF("in configure_timer *** ERR rtems_interrupt_catch\n")
35 PRINTF("in configure_timer *** ERR rtems_interrupt_catch\n")
36 }
36 }
37
37
38 timer_set_clock_divider( timer, clock_divider);
38 timer_set_clock_divider( timer, clock_divider);
39 }
39 }
40
40
41 void timer_start(unsigned char timer)
41 void timer_start(unsigned char timer)
42 {
42 {
43 /** This function starts a GPTIMER timer.
43 /** This function starts a GPTIMER timer.
44 *
44 *
45 * @param gptimer_regs points to the APB registers of the GPTIMER IP core.
45 * @param gptimer_regs points to the APB registers of the GPTIMER IP core.
46 * @param timer is the number of the timer in the IP core (several timers can be instantiated).
46 * @param timer is the number of the timer in the IP core (several timers can be instantiated).
47 *
47 *
48 */
48 */
49
49
50 gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl | GPTIMER_CLEAR_IRQ;
50 gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl | GPTIMER_CLEAR_IRQ;
51 gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl | GPTIMER_LD;
51 gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl | GPTIMER_LD;
52 gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl | GPTIMER_EN;
52 gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl | GPTIMER_EN;
53 gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl | GPTIMER_RS;
53 gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl | GPTIMER_RS;
54 gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl | GPTIMER_IE;
54 gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl | GPTIMER_IE;
55 }
55 }
56
56
57 void timer_stop(unsigned char timer)
57 void timer_stop(unsigned char timer)
58 {
58 {
59 /** This function stops a GPTIMER timer.
59 /** This function stops a GPTIMER timer.
60 *
60 *
61 * @param gptimer_regs points to the APB registers of the GPTIMER IP core.
61 * @param gptimer_regs points to the APB registers of the GPTIMER IP core.
62 * @param timer is the number of the timer in the IP core (several timers can be instantiated).
62 * @param timer is the number of the timer in the IP core (several timers can be instantiated).
63 *
63 *
64 */
64 */
65
65
66 gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl & GPTIMER_EN_MASK;
66 gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl & GPTIMER_EN_MASK;
67 gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl & GPTIMER_IE_MASK;
67 gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl & GPTIMER_IE_MASK;
68 gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl | GPTIMER_CLEAR_IRQ;
68 gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl | GPTIMER_CLEAR_IRQ;
69 }
69 }
70
70
71 void timer_set_clock_divider(unsigned char timer, unsigned int clock_divider)
71 void timer_set_clock_divider(unsigned char timer, unsigned int clock_divider)
72 {
72 {
73 /** This function sets the clock divider of a GPTIMER timer.
73 /** This function sets the clock divider of a GPTIMER timer.
74 *
74 *
75 * @param gptimer_regs points to the APB registers of the GPTIMER IP core.
75 * @param gptimer_regs points to the APB registers of the GPTIMER IP core.
76 * @param timer is the number of the timer in the IP core (several timers can be instantiated).
76 * @param timer is the number of the timer in the IP core (several timers can be instantiated).
77 * @param clock_divider is the divider of the 1 MHz clock that will be configured.
77 * @param clock_divider is the divider of the 1 MHz clock that will be configured.
78 *
78 *
79 */
79 */
80
80
81 gptimer_regs->timer[timer].reload = clock_divider; // base clock frequency is 1 MHz
81 gptimer_regs->timer[timer].reload = clock_divider; // base clock frequency is 1 MHz
82 }
82 }
83
83
84 // WATCHDOG
84 // WATCHDOG
85
85
86 rtems_isr watchdog_isr( rtems_vector_number vector )
86 rtems_isr watchdog_isr( rtems_vector_number vector )
87 {
87 {
88 rtems_status_code status_code;
88 rtems_status_code status_code;
89
89
90 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_12 );
90 status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_12 );
91
91
92 PRINTF("watchdog_isr *** this is the end, exit(0)\n");
92 PRINTF("watchdog_isr *** this is the end, exit(0)\n");
93
93
94 exit(0);
94 exit(0);
95 }
95 }
96
96
97 void watchdog_configure(void)
97 void watchdog_configure(void)
98 {
98 {
99 /** This function configure the watchdog.
99 /** This function configure the watchdog.
100 *
100 *
101 * @param gptimer_regs points to the APB registers of the GPTIMER IP core.
101 * @param gptimer_regs points to the APB registers of the GPTIMER IP core.
102 * @param timer is the number of the timer in the IP core (several timers can be instantiated).
102 * @param timer is the number of the timer in the IP core (several timers can be instantiated).
103 *
103 *
104 * The watchdog is a timer provided by the GPTIMER IP core of the GRLIB.
104 * The watchdog is a timer provided by the GPTIMER IP core of the GRLIB.
105 *
105 *
106 */
106 */
107
107
108 LEON_Mask_interrupt( IRQ_GPTIMER_WATCHDOG ); // mask gptimer/watchdog interrupt during configuration
108 LEON_Mask_interrupt( IRQ_GPTIMER_WATCHDOG ); // mask gptimer/watchdog interrupt during configuration
109
109
110 timer_configure( TIMER_WATCHDOG, CLKDIV_WATCHDOG, IRQ_SPARC_GPTIMER_WATCHDOG, watchdog_isr );
110 timer_configure( TIMER_WATCHDOG, CLKDIV_WATCHDOG, IRQ_SPARC_GPTIMER_WATCHDOG, watchdog_isr );
111
111
112 LEON_Clear_interrupt( IRQ_GPTIMER_WATCHDOG ); // clear gptimer/watchdog interrupt
112 LEON_Clear_interrupt( IRQ_GPTIMER_WATCHDOG ); // clear gptimer/watchdog interrupt
113 }
113 }
114
114
115 void watchdog_stop(void)
115 void watchdog_stop(void)
116 {
116 {
117 LEON_Mask_interrupt( IRQ_GPTIMER_WATCHDOG ); // mask gptimer/watchdog interrupt line
117 LEON_Mask_interrupt( IRQ_GPTIMER_WATCHDOG ); // mask gptimer/watchdog interrupt line
118 timer_stop( TIMER_WATCHDOG );
118 timer_stop( TIMER_WATCHDOG );
119 LEON_Clear_interrupt( IRQ_GPTIMER_WATCHDOG ); // clear gptimer/watchdog interrupt
119 LEON_Clear_interrupt( IRQ_GPTIMER_WATCHDOG ); // clear gptimer/watchdog interrupt
120 }
120 }
121
121
122 void watchdog_reload(void)
122 void watchdog_reload(void)
123 {
123 {
124 /** This function reloads the watchdog timer counter with the timer reload value.
124 /** This function reloads the watchdog timer counter with the timer reload value.
125 *
125 *
126 * @param void
126 * @param void
127 *
127 *
128 * @return void
128 * @return void
129 *
129 *
130 */
130 */
131
131
132 gptimer_regs->timer[TIMER_WATCHDOG].ctrl = gptimer_regs->timer[TIMER_WATCHDOG].ctrl | GPTIMER_LD;
132 gptimer_regs->timer[TIMER_WATCHDOG].ctrl = gptimer_regs->timer[TIMER_WATCHDOG].ctrl | GPTIMER_LD;
133 }
133 }
134
134
135 void watchdog_start(void)
135 void watchdog_start(void)
136 {
136 {
137 /** This function starts the watchdog timer.
137 /** This function starts the watchdog timer.
138 *
138 *
139 * @param gptimer_regs points to the APB registers of the GPTIMER IP core.
139 * @param gptimer_regs points to the APB registers of the GPTIMER IP core.
140 * @param timer is the number of the timer in the IP core (several timers can be instantiated).
140 * @param timer is the number of the timer in the IP core (several timers can be instantiated).
141 *
141 *
142 */
142 */
143
143
144 LEON_Clear_interrupt( IRQ_GPTIMER_WATCHDOG );
144 LEON_Clear_interrupt( IRQ_GPTIMER_WATCHDOG );
145
145
146 gptimer_regs->timer[TIMER_WATCHDOG].ctrl = gptimer_regs->timer[TIMER_WATCHDOG].ctrl | GPTIMER_CLEAR_IRQ;
146 gptimer_regs->timer[TIMER_WATCHDOG].ctrl = gptimer_regs->timer[TIMER_WATCHDOG].ctrl | GPTIMER_CLEAR_IRQ;
147 gptimer_regs->timer[TIMER_WATCHDOG].ctrl = gptimer_regs->timer[TIMER_WATCHDOG].ctrl | GPTIMER_LD;
147 gptimer_regs->timer[TIMER_WATCHDOG].ctrl = gptimer_regs->timer[TIMER_WATCHDOG].ctrl | GPTIMER_LD;
148 gptimer_regs->timer[TIMER_WATCHDOG].ctrl = gptimer_regs->timer[TIMER_WATCHDOG].ctrl | GPTIMER_EN;
148 gptimer_regs->timer[TIMER_WATCHDOG].ctrl = gptimer_regs->timer[TIMER_WATCHDOG].ctrl | GPTIMER_EN;
149 gptimer_regs->timer[TIMER_WATCHDOG].ctrl = gptimer_regs->timer[TIMER_WATCHDOG].ctrl | GPTIMER_IE;
149 gptimer_regs->timer[TIMER_WATCHDOG].ctrl = gptimer_regs->timer[TIMER_WATCHDOG].ctrl | GPTIMER_IE;
150
150
151 LEON_Unmask_interrupt( IRQ_GPTIMER_WATCHDOG );
151 LEON_Unmask_interrupt( IRQ_GPTIMER_WATCHDOG );
152
152
153 }
153 }
154
154
155 int enable_apbuart_transmitter( void ) // set the bit 1, TE Transmitter Enable to 1 in the APBUART control register
155 int enable_apbuart_transmitter( void ) // set the bit 1, TE Transmitter Enable to 1 in the APBUART control register
156 {
156 {
157 struct apbuart_regs_str *apbuart_regs = (struct apbuart_regs_str *) REGS_ADDR_APBUART;
157 struct apbuart_regs_str *apbuart_regs = (struct apbuart_regs_str *) REGS_ADDR_APBUART;
158
158
159 apbuart_regs->ctrl = APBUART_CTRL_REG_MASK_TE;
159 apbuart_regs->ctrl = APBUART_CTRL_REG_MASK_TE;
160
160
161 return 0;
161 return 0;
162 }
162 }
163
163
164 void set_apbuart_scaler_reload_register(unsigned int regs, unsigned int value)
164 void set_apbuart_scaler_reload_register(unsigned int regs, unsigned int value)
165 {
165 {
166 /** This function sets the scaler reload register of the apbuart module
166 /** This function sets the scaler reload register of the apbuart module
167 *
167 *
168 * @param regs is the address of the apbuart registers in memory
168 * @param regs is the address of the apbuart registers in memory
169 * @param value is the value that will be stored in the scaler register
169 * @param value is the value that will be stored in the scaler register
170 *
170 *
171 * The value shall be set by the software to get data on the serial interface.
171 * The value shall be set by the software to get data on the serial interface.
172 *
172 *
173 */
173 */
174
174
175 struct apbuart_regs_str *apbuart_regs = (struct apbuart_regs_str *) regs;
175 struct apbuart_regs_str *apbuart_regs = (struct apbuart_regs_str *) regs;
176
176
177 apbuart_regs->scaler = value;
177 apbuart_regs->scaler = value;
178
178
179 BOOT_PRINTF1("OK *** apbuart port scaler reload register set to 0x%x\n", value)
179 BOOT_PRINTF1("OK *** apbuart port scaler reload register set to 0x%x\n", value)
180 }
180 }
181
181
182 //************
182 //************
183 // RTEMS TASKS
183 // RTEMS TASKS
184
184
185 rtems_task load_task(rtems_task_argument argument)
185 rtems_task load_task(rtems_task_argument argument)
186 {
186 {
187 BOOT_PRINTF("in LOAD *** \n")
187 BOOT_PRINTF("in LOAD *** \n")
188
188
189 rtems_status_code status;
189 rtems_status_code status;
190 unsigned int i;
190 unsigned int i;
191 unsigned int j;
191 unsigned int j;
192 rtems_name name_watchdog_rate_monotonic; // name of the watchdog rate monotonic
192 rtems_name name_watchdog_rate_monotonic; // name of the watchdog rate monotonic
193 rtems_id watchdog_period_id; // id of the watchdog rate monotonic period
193 rtems_id watchdog_period_id; // id of the watchdog rate monotonic period
194
194
195 watchdog_period_id = RTEMS_ID_NONE;
195 watchdog_period_id = RTEMS_ID_NONE;
196
196
197 name_watchdog_rate_monotonic = rtems_build_name( 'L', 'O', 'A', 'D' );
197 name_watchdog_rate_monotonic = rtems_build_name( 'L', 'O', 'A', 'D' );
198
198
199 status = rtems_rate_monotonic_create( name_watchdog_rate_monotonic, &watchdog_period_id );
199 status = rtems_rate_monotonic_create( name_watchdog_rate_monotonic, &watchdog_period_id );
200 if( status != RTEMS_SUCCESSFUL ) {
200 if( status != RTEMS_SUCCESSFUL ) {
201 PRINTF1( "in LOAD *** rtems_rate_monotonic_create failed with status of %d\n", status )
201 PRINTF1( "in LOAD *** rtems_rate_monotonic_create failed with status of %d\n", status )
202 }
202 }
203
203
204 i = 0;
204 i = 0;
205 j = 0;
205 j = 0;
206
206
207 watchdog_configure();
207 watchdog_configure();
208
208
209 watchdog_start();
209 watchdog_start();
210
210
211 set_sy_lfr_watchdog_enabled( true );
211 set_sy_lfr_watchdog_enabled( true );
212
212
213 while(1){
213 while(1){
214 status = rtems_rate_monotonic_period( watchdog_period_id, WATCHDOG_PERIOD );
214 status = rtems_rate_monotonic_period( watchdog_period_id, WATCHDOG_PERIOD );
215 watchdog_reload();
215 watchdog_reload();
216 i = i + 1;
216 i = i + 1;
217 if ( i == WATCHDOG_LOOP_PRINTF )
217 if ( i == WATCHDOG_LOOP_PRINTF )
218 {
218 {
219 i = 0;
219 i = 0;
220 j = j + 1;
220 j = j + 1;
221 PRINTF1("%d\n", j)
221 PRINTF1("%d\n", j)
222 }
222 }
223 #ifdef DEBUG_WATCHDOG
223 #ifdef DEBUG_WATCHDOG
224 if (j == WATCHDOG_LOOP_DEBUG )
224 if (j == WATCHDOG_LOOP_DEBUG )
225 {
225 {
226 status = rtems_task_delete(RTEMS_SELF);
226 status = rtems_task_delete(RTEMS_SELF);
227 }
227 }
228 #endif
228 #endif
229 }
229 }
230 }
230 }
231
231
232 rtems_task hous_task(rtems_task_argument argument)
232 rtems_task hous_task(rtems_task_argument argument)
233 {
233 {
234 rtems_status_code status;
234 rtems_status_code status;
235 rtems_status_code spare_status;
235 rtems_status_code spare_status;
236 rtems_id queue_id;
236 rtems_id queue_id;
237 rtems_rate_monotonic_period_status period_status;
237 rtems_rate_monotonic_period_status period_status;
238 bool isSynchronized;
238 bool isSynchronized;
239
239
240 queue_id = RTEMS_ID_NONE;
240 queue_id = RTEMS_ID_NONE;
241 memset(&period_status, 0, sizeof(rtems_rate_monotonic_period_status));
241 memset(&period_status, 0, sizeof(rtems_rate_monotonic_period_status));
242 isSynchronized = false;
242 isSynchronized = false;
243
243
244 status = get_message_queue_id_send( &queue_id );
244 status = get_message_queue_id_send( &queue_id );
245 if (status != RTEMS_SUCCESSFUL)
245 if (status != RTEMS_SUCCESSFUL)
246 {
246 {
247 PRINTF1("in HOUS *** ERR get_message_queue_id_send %d\n", status)
247 PRINTF1("in HOUS *** ERR get_message_queue_id_send %d\n", status)
248 }
248 }
249
249
250 BOOT_PRINTF("in HOUS ***\n");
250 BOOT_PRINTF("in HOUS ***\n");
251
251
252 if (rtems_rate_monotonic_ident( name_hk_rate_monotonic, &HK_id) != RTEMS_SUCCESSFUL) {
252 if (rtems_rate_monotonic_ident( name_hk_rate_monotonic, &HK_id) != RTEMS_SUCCESSFUL) {
253 status = rtems_rate_monotonic_create( name_hk_rate_monotonic, &HK_id );
253 status = rtems_rate_monotonic_create( name_hk_rate_monotonic, &HK_id );
254 if( status != RTEMS_SUCCESSFUL ) {
254 if( status != RTEMS_SUCCESSFUL ) {
255 PRINTF1( "rtems_rate_monotonic_create failed with status of %d\n", status );
255 PRINTF1( "rtems_rate_monotonic_create failed with status of %d\n", status );
256 }
256 }
257 }
257 }
258
258
259 status = rtems_rate_monotonic_cancel(HK_id);
259 status = rtems_rate_monotonic_cancel(HK_id);
260 if( status != RTEMS_SUCCESSFUL ) {
260 if( status != RTEMS_SUCCESSFUL ) {
261 PRINTF1( "ERR *** in HOUS *** rtems_rate_monotonic_cancel(HK_id) ***code: %d\n", status );
261 PRINTF1( "ERR *** in HOUS *** rtems_rate_monotonic_cancel(HK_id) ***code: %d\n", status );
262 }
262 }
263 else {
263 else {
264 DEBUG_PRINTF("OK *** in HOUS *** rtems_rate_monotonic_cancel(HK_id)\n");
264 DEBUG_PRINTF("OK *** in HOUS *** rtems_rate_monotonic_cancel(HK_id)\n");
265 }
265 }
266
266
267 // startup phase
267 // startup phase
268 status = rtems_rate_monotonic_period( HK_id, SY_LFR_TIME_SYN_TIMEOUT_in_ticks );
268 status = rtems_rate_monotonic_period( HK_id, SY_LFR_TIME_SYN_TIMEOUT_in_ticks );
269 status = rtems_rate_monotonic_get_status( HK_id, &period_status );
269 status = rtems_rate_monotonic_get_status( HK_id, &period_status );
270 DEBUG_PRINTF1("startup HK, HK_id status = %d\n", period_status.state)
270 DEBUG_PRINTF1("startup HK, HK_id status = %d\n", period_status.state)
271 while( (period_status.state != RATE_MONOTONIC_EXPIRED)
271 while( (period_status.state != RATE_MONOTONIC_EXPIRED)
272 && (isSynchronized == false) ) // after SY_LFR_TIME_SYN_TIMEOUT ms, starts HK anyway
272 && (isSynchronized == false) ) // after SY_LFR_TIME_SYN_TIMEOUT ms, starts HK anyway
273 {
273 {
274 if ((time_management_regs->coarse_time & VAL_LFR_SYNCHRONIZED) == INT32_ALL_0) // check time synchronization
274 if ((time_management_regs->coarse_time & VAL_LFR_SYNCHRONIZED) == INT32_ALL_0) // check time synchronization
275 {
275 {
276 isSynchronized = true;
276 isSynchronized = true;
277 }
277 }
278 else
278 else
279 {
279 {
280 status = rtems_rate_monotonic_get_status( HK_id, &period_status );
280 status = rtems_rate_monotonic_get_status( HK_id, &period_status );
281
281
282 status = rtems_task_wake_after( HK_SYNC_WAIT ); // wait HK_SYNCH_WAIT 100 ms = 10 * 10 ms
282 status = rtems_task_wake_after( HK_SYNC_WAIT ); // wait HK_SYNCH_WAIT 100 ms = 10 * 10 ms
283 }
283 }
284 }
284 }
285 status = rtems_rate_monotonic_cancel(HK_id);
285 status = rtems_rate_monotonic_cancel(HK_id);
286 DEBUG_PRINTF1("startup HK, HK_id status = %d\n", period_status.state)
286 DEBUG_PRINTF1("startup HK, HK_id status = %d\n", period_status.state)
287
287
288 set_hk_lfr_reset_cause( POWER_ON );
288 set_hk_lfr_reset_cause( POWER_ON );
289
289
290 while(1){ // launch the rate monotonic task
290 while(1){ // launch the rate monotonic task
291 status = rtems_rate_monotonic_period( HK_id, HK_PERIOD );
291 status = rtems_rate_monotonic_period( HK_id, HK_PERIOD );
292 if ( status != RTEMS_SUCCESSFUL ) {
292 if ( status != RTEMS_SUCCESSFUL ) {
293 PRINTF1( "in HOUS *** ERR period: %d\n", status);
293 PRINTF1( "in HOUS *** ERR period: %d\n", status);
294 spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_6 );
294 spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_6 );
295 }
295 }
296 else {
296 else {
297 housekeeping_packet.packetSequenceControl[BYTE_0] = (unsigned char) (sequenceCounterHK >> SHIFT_1_BYTE);
297 housekeeping_packet.packetSequenceControl[BYTE_0] = (unsigned char) (sequenceCounterHK >> SHIFT_1_BYTE);
298 housekeeping_packet.packetSequenceControl[BYTE_1] = (unsigned char) (sequenceCounterHK );
298 housekeeping_packet.packetSequenceControl[BYTE_1] = (unsigned char) (sequenceCounterHK );
299 increment_seq_counter( &sequenceCounterHK );
299 increment_seq_counter( &sequenceCounterHK );
300
300
301 housekeeping_packet.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
301 housekeeping_packet.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
302 housekeeping_packet.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
302 housekeeping_packet.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
303 housekeeping_packet.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
303 housekeeping_packet.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
304 housekeeping_packet.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
304 housekeeping_packet.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
305 housekeeping_packet.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
305 housekeeping_packet.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
306 housekeeping_packet.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
306 housekeeping_packet.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
307
307
308 spacewire_update_hk_lfr_link_state( &housekeeping_packet.lfr_status_word[0] );
308 spacewire_update_hk_lfr_link_state( &housekeeping_packet.lfr_status_word[0] );
309
309
310 spacewire_read_statistics();
310 spacewire_read_statistics();
311
311
312 update_hk_with_grspw_stats();
312 update_hk_with_grspw_stats();
313
313
314 set_hk_lfr_time_not_synchro();
314 set_hk_lfr_time_not_synchro();
315
315
316 housekeeping_packet.hk_lfr_q_sd_fifo_size_max = hk_lfr_q_sd_fifo_size_max;
316 housekeeping_packet.hk_lfr_q_sd_fifo_size_max = hk_lfr_q_sd_fifo_size_max;
317 housekeeping_packet.hk_lfr_q_rv_fifo_size_max = hk_lfr_q_rv_fifo_size_max;
317 housekeeping_packet.hk_lfr_q_rv_fifo_size_max = hk_lfr_q_rv_fifo_size_max;
318 housekeeping_packet.hk_lfr_q_p0_fifo_size_max = hk_lfr_q_p0_fifo_size_max;
318 housekeeping_packet.hk_lfr_q_p0_fifo_size_max = hk_lfr_q_p0_fifo_size_max;
319 housekeeping_packet.hk_lfr_q_p1_fifo_size_max = hk_lfr_q_p1_fifo_size_max;
319 housekeeping_packet.hk_lfr_q_p1_fifo_size_max = hk_lfr_q_p1_fifo_size_max;
320 housekeeping_packet.hk_lfr_q_p2_fifo_size_max = hk_lfr_q_p2_fifo_size_max;
320 housekeeping_packet.hk_lfr_q_p2_fifo_size_max = hk_lfr_q_p2_fifo_size_max;
321
321
322 housekeeping_packet.sy_lfr_common_parameters_spare = parameter_dump_packet.sy_lfr_common_parameters_spare;
322 housekeeping_packet.sy_lfr_common_parameters_spare = parameter_dump_packet.sy_lfr_common_parameters_spare;
323 housekeeping_packet.sy_lfr_common_parameters = parameter_dump_packet.sy_lfr_common_parameters;
323 housekeeping_packet.sy_lfr_common_parameters = parameter_dump_packet.sy_lfr_common_parameters;
324 get_temperatures( housekeeping_packet.hk_lfr_temp_scm );
324 get_temperatures( housekeeping_packet.hk_lfr_temp_scm );
325 get_v_e1_e2_f3( housekeeping_packet.hk_lfr_sc_v_f3 );
325 get_v_e1_e2_f3( housekeeping_packet.hk_lfr_sc_v_f3 );
326 get_cpu_load( (unsigned char *) &housekeeping_packet.hk_lfr_cpu_load );
326 get_cpu_load( (unsigned char *) &housekeeping_packet.hk_lfr_cpu_load );
327
327
328 hk_lfr_le_me_he_update();
328 hk_lfr_le_me_he_update();
329
329
330 housekeeping_packet.hk_lfr_sc_rw_f_flags = cp_rpw_sc_rw_f_flags;
330 housekeeping_packet.hk_lfr_sc_rw_f_flags = cp_rpw_sc_rw_f_flags;
331
331
332 // SEND PACKET
332 // SEND PACKET
333 status = rtems_message_queue_send( queue_id, &housekeeping_packet,
333 status = rtems_message_queue_send( queue_id, &housekeeping_packet,
334 PACKET_LENGTH_HK + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES);
334 PACKET_LENGTH_HK + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES);
335 if (status != RTEMS_SUCCESSFUL) {
335 if (status != RTEMS_SUCCESSFUL) {
336 PRINTF1("in HOUS *** ERR send: %d\n", status)
336 PRINTF1("in HOUS *** ERR send: %d\n", status)
337 }
337 }
338 }
338 }
339 }
339 }
340
340
341 PRINTF("in HOUS *** deleting task\n")
341 PRINTF("in HOUS *** deleting task\n")
342
342
343 status = rtems_task_delete( RTEMS_SELF ); // should not return
343 status = rtems_task_delete( RTEMS_SELF ); // should not return
344
344
345 return;
345 return;
346 }
346 }
347
347
348 rtems_task avgv_task(rtems_task_argument argument)
348 rtems_task avgv_task(rtems_task_argument argument)
349 {
349 {
350 #define MOVING_AVERAGE 16
350 #define MOVING_AVERAGE 16
351 rtems_status_code status;
351 rtems_status_code status;
352 static unsigned int v[MOVING_AVERAGE] = {0};
352 static unsigned int v[MOVING_AVERAGE] = {0};
353 static unsigned int e1[MOVING_AVERAGE] = {0};
353 static unsigned int e1[MOVING_AVERAGE] = {0};
354 static unsigned int e2[MOVING_AVERAGE] = {0};
354 static unsigned int e2[MOVING_AVERAGE] = {0};
355 float average_v;
355 float average_v;
356 float average_e1;
356 float average_e1;
357 float average_e2;
357 float average_e2;
358 unsigned char k;
358 unsigned char k;
359 unsigned char indexOfOldValue;
359 unsigned char indexOfOldValue;
360
360
361 BOOT_PRINTF("in AVGV ***\n");
361 BOOT_PRINTF("in AVGV ***\n");
362
362
363 if (rtems_rate_monotonic_ident( name_avgv_rate_monotonic, &HK_id) != RTEMS_SUCCESSFUL) {
363 if (rtems_rate_monotonic_ident( name_avgv_rate_monotonic, &HK_id) != RTEMS_SUCCESSFUL) {
364 status = rtems_rate_monotonic_create( name_avgv_rate_monotonic, &AVGV_id );
364 status = rtems_rate_monotonic_create( name_avgv_rate_monotonic, &AVGV_id );
365 if( status != RTEMS_SUCCESSFUL ) {
365 if( status != RTEMS_SUCCESSFUL ) {
366 PRINTF1( "rtems_rate_monotonic_create failed with status of %d\n", status );
366 PRINTF1( "rtems_rate_monotonic_create failed with status of %d\n", status );
367 }
367 }
368 }
368 }
369
369
370 status = rtems_rate_monotonic_cancel(AVGV_id);
370 status = rtems_rate_monotonic_cancel(AVGV_id);
371 if( status != RTEMS_SUCCESSFUL ) {
371 if( status != RTEMS_SUCCESSFUL ) {
372 PRINTF1( "ERR *** in AVGV *** rtems_rate_monotonic_cancel(AVGV_id) ***code: %d\n", status );
372 PRINTF1( "ERR *** in AVGV *** rtems_rate_monotonic_cancel(AVGV_id) ***code: %d\n", status );
373 }
373 }
374 else {
374 else {
375 DEBUG_PRINTF("OK *** in AVGV *** rtems_rate_monotonic_cancel(AVGV_id)\n");
375 DEBUG_PRINTF("OK *** in AVGV *** rtems_rate_monotonic_cancel(AVGV_id)\n");
376 }
376 }
377
377
378 // initialize values
378 // initialize values
379 indexOfOldValue = MOVING_AVERAGE - 1;
379 indexOfOldValue = MOVING_AVERAGE - 1;
380 average_v = 0.;
380 average_v = 0.;
381 average_e1 = 0.;
381 average_e1 = 0.;
382 average_e2 = 0.;
382 average_e2 = 0.;
383
383
384 k = 0;
384 k = 0;
385
385
386 while(1){ // launch the rate monotonic task
386 while(1){ // launch the rate monotonic task
387 status = rtems_rate_monotonic_period( AVGV_id, AVGV_PERIOD );
387 status = rtems_rate_monotonic_period( AVGV_id, AVGV_PERIOD );
388 if ( status != RTEMS_SUCCESSFUL ) {
388 if ( status != RTEMS_SUCCESSFUL ) {
389 PRINTF1( "in AVGV *** ERR period: %d\n", status);
389 PRINTF1( "in AVGV *** ERR period: %d\n", status);
390 }
390 }
391 else {
391 else {
392 // store new value in buffer
392 // store new value in buffer
393 v[k] = waveform_picker_regs->v;
393 v[k] = waveform_picker_regs->v;
394 e1[k] = waveform_picker_regs->e1;
394 e1[k] = waveform_picker_regs->e1;
395 e2[k] = waveform_picker_regs->e2;
395 e2[k] = waveform_picker_regs->e2;
396 if (k == (MOVING_AVERAGE - 1))
396 if (k == (MOVING_AVERAGE - 1))
397 {
397 {
398 indexOfOldValue = 0;
398 indexOfOldValue = 0;
399 }
399 }
400 else
400 else
401 {
401 {
402 indexOfOldValue = k + 1;
402 indexOfOldValue = k + 1;
403 }
403 }
404 average_v = average_v + v[k] - v[indexOfOldValue];
404 average_v = average_v + v[k] - v[indexOfOldValue];
405 average_e1 = average_e1 + e1[k] - e1[indexOfOldValue];
405 average_e1 = average_e1 + e1[k] - e1[indexOfOldValue];
406 average_e2 = average_e2 + e2[k] - e2[indexOfOldValue];
406 average_e2 = average_e2 + e2[k] - e2[indexOfOldValue];
407 }
407 }
408 if (k == (MOVING_AVERAGE-1))
408 if (k == (MOVING_AVERAGE-1))
409 {
409 {
410 k = 0;
410 k = 0;
411 PRINTF("tick\n");
411 PRINTF("tick\n");
412 }
412 }
413 else
413 else
414 {
414 {
415 k++;
415 k++;
416 }
416 }
417 }
417 }
418
418
419 PRINTF("in AVGV *** deleting task\n")
419 PRINTF("in AVGV *** deleting task\n")
420
420
421 status = rtems_task_delete( RTEMS_SELF ); // should not return
421 status = rtems_task_delete( RTEMS_SELF ); // should not return
422
422
423 return;
423 return;
424 }
424 }
425
425
426 rtems_task dumb_task( rtems_task_argument unused )
426 rtems_task dumb_task( rtems_task_argument unused )
427 {
427 {
428 /** This RTEMS taks is used to print messages without affecting the general behaviour of the software.
428 /** This RTEMS taks is used to print messages without affecting the general behaviour of the software.
429 *
429 *
430 * @param unused is the starting argument of the RTEMS task
430 * @param unused is the starting argument of the RTEMS task
431 *
431 *
432 * The DUMB taks waits for RTEMS events and print messages depending on the incoming events.
432 * The DUMB taks waits for RTEMS events and print messages depending on the incoming events.
433 *
433 *
434 */
434 */
435
435
436 unsigned int i;
436 unsigned int i;
437 unsigned int intEventOut;
437 unsigned int intEventOut;
438 unsigned int coarse_time = 0;
438 unsigned int coarse_time = 0;
439 unsigned int fine_time = 0;
439 unsigned int fine_time = 0;
440 rtems_event_set event_out;
440 rtems_event_set event_out;
441
441
442 event_out = EVENT_SETS_NONE_PENDING;
442 event_out = EVENT_SETS_NONE_PENDING;
443
443
444 BOOT_PRINTF("in DUMB *** \n")
444 BOOT_PRINTF("in DUMB *** \n")
445
445
446 while(1){
446 while(1){
447 rtems_event_receive(RTEMS_EVENT_0 | RTEMS_EVENT_1 | RTEMS_EVENT_2 | RTEMS_EVENT_3
447 rtems_event_receive(RTEMS_EVENT_0 | RTEMS_EVENT_1 | RTEMS_EVENT_2 | RTEMS_EVENT_3
448 | RTEMS_EVENT_4 | RTEMS_EVENT_5 | RTEMS_EVENT_6 | RTEMS_EVENT_7
448 | RTEMS_EVENT_4 | RTEMS_EVENT_5 | RTEMS_EVENT_6 | RTEMS_EVENT_7
449 | RTEMS_EVENT_8 | RTEMS_EVENT_9 | RTEMS_EVENT_12 | RTEMS_EVENT_13
449 | RTEMS_EVENT_8 | RTEMS_EVENT_9 | RTEMS_EVENT_12 | RTEMS_EVENT_13
450 | RTEMS_EVENT_14,
450 | RTEMS_EVENT_14,
451 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT
451 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT
452 intEventOut = (unsigned int) event_out;
452 intEventOut = (unsigned int) event_out;
453 for ( i=0; i<NB_RTEMS_EVENTS; i++)
453 for ( i=0; i<NB_RTEMS_EVENTS; i++)
454 {
454 {
455 if ( ((intEventOut >> i) & 1) != 0)
455 if ( ((intEventOut >> i) & 1) != 0)
456 {
456 {
457 coarse_time = time_management_regs->coarse_time;
457 coarse_time = time_management_regs->coarse_time;
458 fine_time = time_management_regs->fine_time;
458 fine_time = time_management_regs->fine_time;
459 if (i==EVENT_12)
459 if (i==EVENT_12)
460 {
460 {
461 PRINTF1("%s\n", DUMB_MESSAGE_12)
461 PRINTF1("%s\n", DUMB_MESSAGE_12)
462 }
462 }
463 if (i==EVENT_13)
463 if (i==EVENT_13)
464 {
464 {
465 PRINTF1("%s\n", DUMB_MESSAGE_13)
465 PRINTF1("%s\n", DUMB_MESSAGE_13)
466 }
466 }
467 if (i==EVENT_14)
467 if (i==EVENT_14)
468 {
468 {
469 PRINTF1("%s\n", DUMB_MESSAGE_1)
469 PRINTF1("%s\n", DUMB_MESSAGE_1)
470 }
470 }
471 }
471 }
472 }
472 }
473 }
473 }
474 }
474 }
475
475
476 //*****************************
476 //*****************************
477 // init housekeeping parameters
477 // init housekeeping parameters
478
478
479 void init_housekeeping_parameters( void )
479 void init_housekeeping_parameters( void )
480 {
480 {
481 /** This function initialize the housekeeping_packet global variable with default values.
481 /** This function initialize the housekeeping_packet global variable with default values.
482 *
482 *
483 */
483 */
484
484
485 unsigned int i = 0;
485 unsigned int i = 0;
486 unsigned char *parameters;
486 unsigned char *parameters;
487 unsigned char sizeOfHK;
487 unsigned char sizeOfHK;
488
488
489 sizeOfHK = sizeof( Packet_TM_LFR_HK_t );
489 sizeOfHK = sizeof( Packet_TM_LFR_HK_t );
490
490
491 parameters = (unsigned char*) &housekeeping_packet;
491 parameters = (unsigned char*) &housekeeping_packet;
492
492
493 for(i = 0; i< sizeOfHK; i++)
493 for(i = 0; i< sizeOfHK; i++)
494 {
494 {
495 parameters[i] = INIT_CHAR;
495 parameters[i] = INIT_CHAR;
496 }
496 }
497
497
498 housekeeping_packet.targetLogicalAddress = CCSDS_DESTINATION_ID;
498 housekeeping_packet.targetLogicalAddress = CCSDS_DESTINATION_ID;
499 housekeeping_packet.protocolIdentifier = CCSDS_PROTOCOLE_ID;
499 housekeeping_packet.protocolIdentifier = CCSDS_PROTOCOLE_ID;
500 housekeeping_packet.reserved = DEFAULT_RESERVED;
500 housekeeping_packet.reserved = DEFAULT_RESERVED;
501 housekeeping_packet.userApplication = CCSDS_USER_APP;
501 housekeeping_packet.userApplication = CCSDS_USER_APP;
502 housekeeping_packet.packetID[0] = (unsigned char) (APID_TM_HK >> SHIFT_1_BYTE);
502 housekeeping_packet.packetID[0] = (unsigned char) (APID_TM_HK >> SHIFT_1_BYTE);
503 housekeeping_packet.packetID[1] = (unsigned char) (APID_TM_HK);
503 housekeeping_packet.packetID[1] = (unsigned char) (APID_TM_HK);
504 housekeeping_packet.packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
504 housekeeping_packet.packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
505 housekeeping_packet.packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT;
505 housekeeping_packet.packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT;
506 housekeeping_packet.packetLength[0] = (unsigned char) (PACKET_LENGTH_HK >> SHIFT_1_BYTE);
506 housekeeping_packet.packetLength[0] = (unsigned char) (PACKET_LENGTH_HK >> SHIFT_1_BYTE);
507 housekeeping_packet.packetLength[1] = (unsigned char) (PACKET_LENGTH_HK );
507 housekeeping_packet.packetLength[1] = (unsigned char) (PACKET_LENGTH_HK );
508 housekeeping_packet.spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
508 housekeeping_packet.spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
509 housekeeping_packet.serviceType = TM_TYPE_HK;
509 housekeeping_packet.serviceType = TM_TYPE_HK;
510 housekeeping_packet.serviceSubType = TM_SUBTYPE_HK;
510 housekeeping_packet.serviceSubType = TM_SUBTYPE_HK;
511 housekeeping_packet.destinationID = TM_DESTINATION_ID_GROUND;
511 housekeeping_packet.destinationID = TM_DESTINATION_ID_GROUND;
512 housekeeping_packet.sid = SID_HK;
512 housekeeping_packet.sid = SID_HK;
513
513
514 // init status word
514 // init status word
515 housekeeping_packet.lfr_status_word[0] = DEFAULT_STATUS_WORD_BYTE0;
515 housekeeping_packet.lfr_status_word[0] = DEFAULT_STATUS_WORD_BYTE0;
516 housekeeping_packet.lfr_status_word[1] = DEFAULT_STATUS_WORD_BYTE1;
516 housekeeping_packet.lfr_status_word[1] = DEFAULT_STATUS_WORD_BYTE1;
517 // init software version
517 // init software version
518 housekeeping_packet.lfr_sw_version[0] = SW_VERSION_N1;
518 housekeeping_packet.lfr_sw_version[0] = SW_VERSION_N1;
519 housekeeping_packet.lfr_sw_version[1] = SW_VERSION_N2;
519 housekeeping_packet.lfr_sw_version[1] = SW_VERSION_N2;
520 housekeeping_packet.lfr_sw_version[BYTE_2] = SW_VERSION_N3;
520 housekeeping_packet.lfr_sw_version[BYTE_2] = SW_VERSION_N3;
521 housekeeping_packet.lfr_sw_version[BYTE_3] = SW_VERSION_N4;
521 housekeeping_packet.lfr_sw_version[BYTE_3] = SW_VERSION_N4;
522 // init fpga version
522 // init fpga version
523 parameters = (unsigned char *) (REGS_ADDR_VHDL_VERSION);
523 parameters = (unsigned char *) (REGS_ADDR_VHDL_VERSION);
524 housekeeping_packet.lfr_fpga_version[BYTE_0] = parameters[BYTE_1]; // n1
524 housekeeping_packet.lfr_fpga_version[BYTE_0] = parameters[BYTE_1]; // n1
525 housekeeping_packet.lfr_fpga_version[BYTE_1] = parameters[BYTE_2]; // n2
525 housekeeping_packet.lfr_fpga_version[BYTE_1] = parameters[BYTE_2]; // n2
526 housekeeping_packet.lfr_fpga_version[BYTE_2] = parameters[BYTE_3]; // n3
526 housekeeping_packet.lfr_fpga_version[BYTE_2] = parameters[BYTE_3]; // n3
527
527
528 housekeeping_packet.hk_lfr_q_sd_fifo_size = MSG_QUEUE_COUNT_SEND;
528 housekeeping_packet.hk_lfr_q_sd_fifo_size = MSG_QUEUE_COUNT_SEND;
529 housekeeping_packet.hk_lfr_q_rv_fifo_size = MSG_QUEUE_COUNT_RECV;
529 housekeeping_packet.hk_lfr_q_rv_fifo_size = MSG_QUEUE_COUNT_RECV;
530 housekeeping_packet.hk_lfr_q_p0_fifo_size = MSG_QUEUE_COUNT_PRC0;
530 housekeeping_packet.hk_lfr_q_p0_fifo_size = MSG_QUEUE_COUNT_PRC0;
531 housekeeping_packet.hk_lfr_q_p1_fifo_size = MSG_QUEUE_COUNT_PRC1;
531 housekeeping_packet.hk_lfr_q_p1_fifo_size = MSG_QUEUE_COUNT_PRC1;
532 housekeeping_packet.hk_lfr_q_p2_fifo_size = MSG_QUEUE_COUNT_PRC2;
532 housekeeping_packet.hk_lfr_q_p2_fifo_size = MSG_QUEUE_COUNT_PRC2;
533 }
533 }
534
534
535 void increment_seq_counter( unsigned short *packetSequenceControl )
535 void increment_seq_counter( unsigned short *packetSequenceControl )
536 {
536 {
537 /** This function increment the sequence counter passes in argument.
537 /** This function increment the sequence counter passes in argument.
538 *
538 *
539 * The increment does not affect the grouping flag. In case of an overflow, the counter is reset to 0.
539 * The increment does not affect the grouping flag. In case of an overflow, the counter is reset to 0.
540 *
540 *
541 */
541 */
542
542
543 unsigned short segmentation_grouping_flag;
543 unsigned short segmentation_grouping_flag;
544 unsigned short sequence_cnt;
544 unsigned short sequence_cnt;
545
545
546 segmentation_grouping_flag = TM_PACKET_SEQ_CTRL_STANDALONE << SHIFT_1_BYTE; // keep bits 7 downto 6
546 segmentation_grouping_flag = TM_PACKET_SEQ_CTRL_STANDALONE << SHIFT_1_BYTE; // keep bits 7 downto 6
547 sequence_cnt = (*packetSequenceControl) & SEQ_CNT_MASK; // [0011 1111 1111 1111]
547 sequence_cnt = (*packetSequenceControl) & SEQ_CNT_MASK; // [0011 1111 1111 1111]
548
548
549 if ( sequence_cnt < SEQ_CNT_MAX)
549 if ( sequence_cnt < SEQ_CNT_MAX)
550 {
550 {
551 sequence_cnt = sequence_cnt + 1;
551 sequence_cnt = sequence_cnt + 1;
552 }
552 }
553 else
553 else
554 {
554 {
555 sequence_cnt = 0;
555 sequence_cnt = 0;
556 }
556 }
557
557
558 *packetSequenceControl = segmentation_grouping_flag | sequence_cnt ;
558 *packetSequenceControl = segmentation_grouping_flag | sequence_cnt ;
559 }
559 }
560
560
561 void getTime( unsigned char *time)
561 void getTime( unsigned char *time)
562 {
562 {
563 /** This function write the current local time in the time buffer passed in argument.
563 /** This function write the current local time in the time buffer passed in argument.
564 *
564 *
565 */
565 */
566
566
567 time[0] = (unsigned char) (time_management_regs->coarse_time>>SHIFT_3_BYTES);
567 time[0] = (unsigned char) (time_management_regs->coarse_time>>SHIFT_3_BYTES);
568 time[1] = (unsigned char) (time_management_regs->coarse_time>>SHIFT_2_BYTES);
568 time[1] = (unsigned char) (time_management_regs->coarse_time>>SHIFT_2_BYTES);
569 time[2] = (unsigned char) (time_management_regs->coarse_time>>SHIFT_1_BYTE);
569 time[2] = (unsigned char) (time_management_regs->coarse_time>>SHIFT_1_BYTE);
570 time[3] = (unsigned char) (time_management_regs->coarse_time);
570 time[3] = (unsigned char) (time_management_regs->coarse_time);
571 time[4] = (unsigned char) (time_management_regs->fine_time>>SHIFT_1_BYTE);
571 time[4] = (unsigned char) (time_management_regs->fine_time>>SHIFT_1_BYTE);
572 time[5] = (unsigned char) (time_management_regs->fine_time);
572 time[5] = (unsigned char) (time_management_regs->fine_time);
573 }
573 }
574
574
575 unsigned long long int getTimeAsUnsignedLongLongInt( )
575 unsigned long long int getTimeAsUnsignedLongLongInt( )
576 {
576 {
577 /** This function write the current local time in the time buffer passed in argument.
577 /** This function write the current local time in the time buffer passed in argument.
578 *
578 *
579 */
579 */
580 unsigned long long int time;
580 unsigned long long int time;
581
581
582 time = ( (unsigned long long int) (time_management_regs->coarse_time & COARSE_TIME_MASK) << SHIFT_2_BYTES )
582 time = ( (unsigned long long int) (time_management_regs->coarse_time & COARSE_TIME_MASK) << SHIFT_2_BYTES )
583 + time_management_regs->fine_time;
583 + time_management_regs->fine_time;
584
584
585 return time;
585 return time;
586 }
586 }
587
587
588 void send_dumb_hk( void )
588 void send_dumb_hk( void )
589 {
589 {
590 Packet_TM_LFR_HK_t dummy_hk_packet;
590 Packet_TM_LFR_HK_t dummy_hk_packet;
591 unsigned char *parameters;
591 unsigned char *parameters;
592 unsigned int i;
592 unsigned int i;
593 rtems_id queue_id;
593 rtems_id queue_id;
594
594
595 queue_id = RTEMS_ID_NONE;
595 queue_id = RTEMS_ID_NONE;
596
596
597 dummy_hk_packet.targetLogicalAddress = CCSDS_DESTINATION_ID;
597 dummy_hk_packet.targetLogicalAddress = CCSDS_DESTINATION_ID;
598 dummy_hk_packet.protocolIdentifier = CCSDS_PROTOCOLE_ID;
598 dummy_hk_packet.protocolIdentifier = CCSDS_PROTOCOLE_ID;
599 dummy_hk_packet.reserved = DEFAULT_RESERVED;
599 dummy_hk_packet.reserved = DEFAULT_RESERVED;
600 dummy_hk_packet.userApplication = CCSDS_USER_APP;
600 dummy_hk_packet.userApplication = CCSDS_USER_APP;
601 dummy_hk_packet.packetID[0] = (unsigned char) (APID_TM_HK >> SHIFT_1_BYTE);
601 dummy_hk_packet.packetID[0] = (unsigned char) (APID_TM_HK >> SHIFT_1_BYTE);
602 dummy_hk_packet.packetID[1] = (unsigned char) (APID_TM_HK);
602 dummy_hk_packet.packetID[1] = (unsigned char) (APID_TM_HK);
603 dummy_hk_packet.packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
603 dummy_hk_packet.packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
604 dummy_hk_packet.packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT;
604 dummy_hk_packet.packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT;
605 dummy_hk_packet.packetLength[0] = (unsigned char) (PACKET_LENGTH_HK >> SHIFT_1_BYTE);
605 dummy_hk_packet.packetLength[0] = (unsigned char) (PACKET_LENGTH_HK >> SHIFT_1_BYTE);
606 dummy_hk_packet.packetLength[1] = (unsigned char) (PACKET_LENGTH_HK );
606 dummy_hk_packet.packetLength[1] = (unsigned char) (PACKET_LENGTH_HK );
607 dummy_hk_packet.spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
607 dummy_hk_packet.spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
608 dummy_hk_packet.serviceType = TM_TYPE_HK;
608 dummy_hk_packet.serviceType = TM_TYPE_HK;
609 dummy_hk_packet.serviceSubType = TM_SUBTYPE_HK;
609 dummy_hk_packet.serviceSubType = TM_SUBTYPE_HK;
610 dummy_hk_packet.destinationID = TM_DESTINATION_ID_GROUND;
610 dummy_hk_packet.destinationID = TM_DESTINATION_ID_GROUND;
611 dummy_hk_packet.time[0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
611 dummy_hk_packet.time[0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
612 dummy_hk_packet.time[1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
612 dummy_hk_packet.time[1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
613 dummy_hk_packet.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
613 dummy_hk_packet.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
614 dummy_hk_packet.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
614 dummy_hk_packet.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
615 dummy_hk_packet.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
615 dummy_hk_packet.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
616 dummy_hk_packet.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
616 dummy_hk_packet.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
617 dummy_hk_packet.sid = SID_HK;
617 dummy_hk_packet.sid = SID_HK;
618
618
619 // init status word
619 // init status word
620 dummy_hk_packet.lfr_status_word[0] = INT8_ALL_F;
620 dummy_hk_packet.lfr_status_word[0] = INT8_ALL_F;
621 dummy_hk_packet.lfr_status_word[1] = INT8_ALL_F;
621 dummy_hk_packet.lfr_status_word[1] = INT8_ALL_F;
622 // init software version
622 // init software version
623 dummy_hk_packet.lfr_sw_version[0] = SW_VERSION_N1;
623 dummy_hk_packet.lfr_sw_version[0] = SW_VERSION_N1;
624 dummy_hk_packet.lfr_sw_version[1] = SW_VERSION_N2;
624 dummy_hk_packet.lfr_sw_version[1] = SW_VERSION_N2;
625 dummy_hk_packet.lfr_sw_version[BYTE_2] = SW_VERSION_N3;
625 dummy_hk_packet.lfr_sw_version[BYTE_2] = SW_VERSION_N3;
626 dummy_hk_packet.lfr_sw_version[BYTE_3] = SW_VERSION_N4;
626 dummy_hk_packet.lfr_sw_version[BYTE_3] = SW_VERSION_N4;
627 // init fpga version
627 // init fpga version
628 parameters = (unsigned char *) (REGS_ADDR_WAVEFORM_PICKER + APB_OFFSET_VHDL_REV);
628 parameters = (unsigned char *) (REGS_ADDR_WAVEFORM_PICKER + APB_OFFSET_VHDL_REV);
629 dummy_hk_packet.lfr_fpga_version[BYTE_0] = parameters[BYTE_1]; // n1
629 dummy_hk_packet.lfr_fpga_version[BYTE_0] = parameters[BYTE_1]; // n1
630 dummy_hk_packet.lfr_fpga_version[BYTE_1] = parameters[BYTE_2]; // n2
630 dummy_hk_packet.lfr_fpga_version[BYTE_1] = parameters[BYTE_2]; // n2
631 dummy_hk_packet.lfr_fpga_version[BYTE_2] = parameters[BYTE_3]; // n3
631 dummy_hk_packet.lfr_fpga_version[BYTE_2] = parameters[BYTE_3]; // n3
632
632
633 parameters = (unsigned char *) &dummy_hk_packet.hk_lfr_cpu_load;
633 parameters = (unsigned char *) &dummy_hk_packet.hk_lfr_cpu_load;
634
634
635 for (i=0; i<(BYTE_POS_HK_REACTION_WHEELS_FREQUENCY - BYTE_POS_HK_LFR_CPU_LOAD); i++)
635 for (i=0; i<(BYTE_POS_HK_REACTION_WHEELS_FREQUENCY - BYTE_POS_HK_LFR_CPU_LOAD); i++)
636 {
636 {
637 parameters[i] = INT8_ALL_F;
637 parameters[i] = INT8_ALL_F;
638 }
638 }
639
639
640 get_message_queue_id_send( &queue_id );
640 get_message_queue_id_send( &queue_id );
641
641
642 rtems_message_queue_send( queue_id, &dummy_hk_packet,
642 rtems_message_queue_send( queue_id, &dummy_hk_packet,
643 PACKET_LENGTH_HK + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES);
643 PACKET_LENGTH_HK + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES);
644 }
644 }
645
645
646 void get_temperatures( unsigned char *temperatures )
646 void get_temperatures( unsigned char *temperatures )
647 {
647 {
648 unsigned char* temp_scm_ptr;
648 unsigned char* temp_scm_ptr;
649 unsigned char* temp_pcb_ptr;
649 unsigned char* temp_pcb_ptr;
650 unsigned char* temp_fpga_ptr;
650 unsigned char* temp_fpga_ptr;
651
651
652 // SEL1 SEL0
652 // SEL1 SEL0
653 // 0 0 => PCB
653 // 0 0 => PCB
654 // 0 1 => FPGA
654 // 0 1 => FPGA
655 // 1 0 => SCM
655 // 1 0 => SCM
656
656
657 temp_scm_ptr = (unsigned char *) &time_management_regs->temp_scm;
657 temp_scm_ptr = (unsigned char *) &time_management_regs->temp_scm;
658 temp_pcb_ptr = (unsigned char *) &time_management_regs->temp_pcb;
658 temp_pcb_ptr = (unsigned char *) &time_management_regs->temp_pcb;
659 temp_fpga_ptr = (unsigned char *) &time_management_regs->temp_fpga;
659 temp_fpga_ptr = (unsigned char *) &time_management_regs->temp_fpga;
660
660
661 temperatures[ BYTE_0 ] = temp_scm_ptr[ BYTE_2 ];
661 temperatures[ BYTE_0 ] = temp_scm_ptr[ BYTE_2 ];
662 temperatures[ BYTE_1 ] = temp_scm_ptr[ BYTE_3 ];
662 temperatures[ BYTE_1 ] = temp_scm_ptr[ BYTE_3 ];
663 temperatures[ BYTE_2 ] = temp_pcb_ptr[ BYTE_2 ];
663 temperatures[ BYTE_2 ] = temp_pcb_ptr[ BYTE_2 ];
664 temperatures[ BYTE_3 ] = temp_pcb_ptr[ BYTE_3 ];
664 temperatures[ BYTE_3 ] = temp_pcb_ptr[ BYTE_3 ];
665 temperatures[ BYTE_4 ] = temp_fpga_ptr[ BYTE_2 ];
665 temperatures[ BYTE_4 ] = temp_fpga_ptr[ BYTE_2 ];
666 temperatures[ BYTE_5 ] = temp_fpga_ptr[ BYTE_3 ];
666 temperatures[ BYTE_5 ] = temp_fpga_ptr[ BYTE_3 ];
667 }
667 }
668
668
669 void get_v_e1_e2_f3( unsigned char *spacecraft_potential )
669 void get_v_e1_e2_f3( unsigned char *spacecraft_potential )
670 {
670 {
671 unsigned char* v_ptr;
671 unsigned char* v_ptr;
672 unsigned char* e1_ptr;
672 unsigned char* e1_ptr;
673 unsigned char* e2_ptr;
673 unsigned char* e2_ptr;
674
674
675 v_ptr = (unsigned char *) &waveform_picker_regs->v;
675 v_ptr = (unsigned char *) &waveform_picker_regs->v;
676 e1_ptr = (unsigned char *) &waveform_picker_regs->e1;
676 e1_ptr = (unsigned char *) &waveform_picker_regs->e1;
677 e2_ptr = (unsigned char *) &waveform_picker_regs->e2;
677 e2_ptr = (unsigned char *) &waveform_picker_regs->e2;
678
678
679 spacecraft_potential[ BYTE_0 ] = v_ptr[ BYTE_2 ];
679 spacecraft_potential[ BYTE_0 ] = v_ptr[ BYTE_2 ];
680 spacecraft_potential[ BYTE_1 ] = v_ptr[ BYTE_3 ];
680 spacecraft_potential[ BYTE_1 ] = v_ptr[ BYTE_3 ];
681 spacecraft_potential[ BYTE_2 ] = e1_ptr[ BYTE_2 ];
681 spacecraft_potential[ BYTE_2 ] = e1_ptr[ BYTE_2 ];
682 spacecraft_potential[ BYTE_3 ] = e1_ptr[ BYTE_3 ];
682 spacecraft_potential[ BYTE_3 ] = e1_ptr[ BYTE_3 ];
683 spacecraft_potential[ BYTE_4 ] = e2_ptr[ BYTE_2 ];
683 spacecraft_potential[ BYTE_4 ] = e2_ptr[ BYTE_2 ];
684 spacecraft_potential[ BYTE_5 ] = e2_ptr[ BYTE_3 ];
684 spacecraft_potential[ BYTE_5 ] = e2_ptr[ BYTE_3 ];
685 }
685 }
686
686
687 void get_cpu_load( unsigned char *resource_statistics )
687 void get_cpu_load( unsigned char *resource_statistics )
688 {
688 {
689 unsigned char cpu_load;
689 unsigned char cpu_load;
690
690
691 cpu_load = lfr_rtems_cpu_usage_report();
691 cpu_load = lfr_rtems_cpu_usage_report();
692
692
693 // HK_LFR_CPU_LOAD
693 // HK_LFR_CPU_LOAD
694 resource_statistics[0] = cpu_load;
694 resource_statistics[0] = cpu_load;
695
695
696 // HK_LFR_CPU_LOAD_MAX
696 // HK_LFR_CPU_LOAD_MAX
697 if (cpu_load > resource_statistics[1])
697 if (cpu_load > resource_statistics[1])
698 {
698 {
699 resource_statistics[1] = cpu_load;
699 resource_statistics[1] = cpu_load;
700 }
700 }
701
701
702 // CPU_LOAD_AVE
702 // CPU_LOAD_AVE
703 resource_statistics[BYTE_2] = 0;
703 resource_statistics[BYTE_2] = 0;
704
704
705 #ifndef PRINT_TASK_STATISTICS
705 #ifndef PRINT_TASK_STATISTICS
706 rtems_cpu_usage_reset();
706 rtems_cpu_usage_reset();
707 #endif
707 #endif
708
708
709 }
709 }
710
710
711 void set_hk_lfr_sc_potential_flag( bool state )
711 void set_hk_lfr_sc_potential_flag( bool state )
712 {
712 {
713 if (state == true)
713 if (state == true)
714 {
714 {
715 housekeeping_packet.lfr_status_word[1] =
715 housekeeping_packet.lfr_status_word[1] =
716 housekeeping_packet.lfr_status_word[1] | STATUS_WORD_SC_POTENTIAL_FLAG_BIT; // [0100 0000]
716 housekeeping_packet.lfr_status_word[1] | STATUS_WORD_SC_POTENTIAL_FLAG_BIT; // [0100 0000]
717 }
717 }
718 else
718 else
719 {
719 {
720 housekeeping_packet.lfr_status_word[1] =
720 housekeeping_packet.lfr_status_word[1] =
721 housekeeping_packet.lfr_status_word[1] & STATUS_WORD_SC_POTENTIAL_FLAG_MASK; // [1011 1111]
721 housekeeping_packet.lfr_status_word[1] & STATUS_WORD_SC_POTENTIAL_FLAG_MASK; // [1011 1111]
722 }
722 }
723 }
723 }
724
724
725 void set_sy_lfr_pas_filter_enabled( bool state )
725 void set_sy_lfr_pas_filter_enabled( bool state )
726 {
726 {
727 if (state == true)
727 if (state == true)
728 {
728 {
729 housekeeping_packet.lfr_status_word[1] =
729 housekeeping_packet.lfr_status_word[1] =
730 housekeeping_packet.lfr_status_word[1] | STATUS_WORD_SC_POTENTIAL_FLAG_BIT; // [0010 0000]
730 housekeeping_packet.lfr_status_word[1] | STATUS_WORD_PAS_FILTER_ENABLED_BIT; // [0010 0000]
731 }
731 }
732 else
732 else
733 {
733 {
734 housekeeping_packet.lfr_status_word[1] =
734 housekeeping_packet.lfr_status_word[1] =
735 housekeeping_packet.lfr_status_word[1] & STATUS_WORD_SC_POTENTIAL_FLAG_MASK; // [1101 1111]
735 housekeeping_packet.lfr_status_word[1] & STATUS_WORD_PAS_FILTER_ENABLED_MASK; // [1101 1111]
736 }
736 }
737 }
737 }
738
738
739 void set_sy_lfr_watchdog_enabled( bool state )
739 void set_sy_lfr_watchdog_enabled( bool state )
740 {
740 {
741 if (state == true)
741 if (state == true)
742 {
742 {
743 housekeeping_packet.lfr_status_word[1] =
743 housekeeping_packet.lfr_status_word[1] =
744 housekeeping_packet.lfr_status_word[1] | STATUS_WORD_WATCHDOG_BIT; // [0001 0000]
744 housekeeping_packet.lfr_status_word[1] | STATUS_WORD_WATCHDOG_BIT; // [0001 0000]
745 }
745 }
746 else
746 else
747 {
747 {
748 housekeeping_packet.lfr_status_word[1] =
748 housekeeping_packet.lfr_status_word[1] =
749 housekeeping_packet.lfr_status_word[1] & STATUS_WORD_WATCHDOG_MASK; // [1110 1111]
749 housekeeping_packet.lfr_status_word[1] & STATUS_WORD_WATCHDOG_MASK; // [1110 1111]
750 }
750 }
751 }
751 }
752
752
753 void set_hk_lfr_calib_enable( bool state )
753 void set_hk_lfr_calib_enable( bool state )
754 {
754 {
755 if (state == true)
755 if (state == true)
756 {
756 {
757 housekeeping_packet.lfr_status_word[1] =
757 housekeeping_packet.lfr_status_word[1] =
758 housekeeping_packet.lfr_status_word[1] | STATUS_WORD_CALIB_BIT; // [0000 1000]
758 housekeeping_packet.lfr_status_word[1] | STATUS_WORD_CALIB_BIT; // [0000 1000]
759 }
759 }
760 else
760 else
761 {
761 {
762 housekeeping_packet.lfr_status_word[1] =
762 housekeeping_packet.lfr_status_word[1] =
763 housekeeping_packet.lfr_status_word[1] & STATUS_WORD_CALIB_MASK; // [1111 0111]
763 housekeeping_packet.lfr_status_word[1] & STATUS_WORD_CALIB_MASK; // [1111 0111]
764 }
764 }
765 }
765 }
766
766
767 void set_hk_lfr_reset_cause( enum lfr_reset_cause_t lfr_reset_cause )
767 void set_hk_lfr_reset_cause( enum lfr_reset_cause_t lfr_reset_cause )
768 {
768 {
769 housekeeping_packet.lfr_status_word[1] =
769 housekeeping_packet.lfr_status_word[1] =
770 housekeeping_packet.lfr_status_word[1] & STATUS_WORD_RESET_CAUSE_MASK; // [1111 1000]
770 housekeeping_packet.lfr_status_word[1] & STATUS_WORD_RESET_CAUSE_MASK; // [1111 1000]
771
771
772 housekeeping_packet.lfr_status_word[1] = housekeeping_packet.lfr_status_word[1]
772 housekeeping_packet.lfr_status_word[1] = housekeeping_packet.lfr_status_word[1]
773 | (lfr_reset_cause & STATUS_WORD_RESET_CAUSE_BITS ); // [0000 0111]
773 | (lfr_reset_cause & STATUS_WORD_RESET_CAUSE_BITS ); // [0000 0111]
774
774
775 }
775 }
776
776
777 void increment_hk_counter( unsigned char newValue, unsigned char oldValue, unsigned int *counter )
777 void increment_hk_counter( unsigned char newValue, unsigned char oldValue, unsigned int *counter )
778 {
778 {
779 int delta;
779 int delta;
780
780
781 delta = 0;
781 delta = 0;
782
782
783 if (newValue >= oldValue)
783 if (newValue >= oldValue)
784 {
784 {
785 delta = newValue - oldValue;
785 delta = newValue - oldValue;
786 }
786 }
787 else
787 else
788 {
788 {
789 delta = (255 - oldValue) + newValue;
789 delta = (255 - oldValue) + newValue;
790 }
790 }
791
791
792 *counter = *counter + delta;
792 *counter = *counter + delta;
793 }
793 }
794
794
795 void hk_lfr_le_update( void )
795 void hk_lfr_le_update( void )
796 {
796 {
797 static hk_lfr_le_t old_hk_lfr_le = {0};
797 static hk_lfr_le_t old_hk_lfr_le = {0};
798 hk_lfr_le_t new_hk_lfr_le;
798 hk_lfr_le_t new_hk_lfr_le;
799 unsigned int counter;
799 unsigned int counter;
800
800
801 counter = (((unsigned int) housekeeping_packet.hk_lfr_le_cnt[0]) * 256) + housekeeping_packet.hk_lfr_le_cnt[1];
801 counter = (((unsigned int) housekeeping_packet.hk_lfr_le_cnt[0]) * 256) + housekeeping_packet.hk_lfr_le_cnt[1];
802
802
803 // DPU
803 // DPU
804 new_hk_lfr_le.dpu_spw_parity = housekeeping_packet.hk_lfr_dpu_spw_parity;
804 new_hk_lfr_le.dpu_spw_parity = housekeeping_packet.hk_lfr_dpu_spw_parity;
805 new_hk_lfr_le.dpu_spw_disconnect= housekeeping_packet.hk_lfr_dpu_spw_disconnect;
805 new_hk_lfr_le.dpu_spw_disconnect= housekeeping_packet.hk_lfr_dpu_spw_disconnect;
806 new_hk_lfr_le.dpu_spw_escape = housekeeping_packet.hk_lfr_dpu_spw_escape;
806 new_hk_lfr_le.dpu_spw_escape = housekeeping_packet.hk_lfr_dpu_spw_escape;
807 new_hk_lfr_le.dpu_spw_credit = housekeeping_packet.hk_lfr_dpu_spw_credit;
807 new_hk_lfr_le.dpu_spw_credit = housekeeping_packet.hk_lfr_dpu_spw_credit;
808 new_hk_lfr_le.dpu_spw_write_sync= housekeeping_packet.hk_lfr_dpu_spw_write_sync;
808 new_hk_lfr_le.dpu_spw_write_sync= housekeeping_packet.hk_lfr_dpu_spw_write_sync;
809 // TIMECODE
809 // TIMECODE
810 new_hk_lfr_le.timecode_erroneous= housekeeping_packet.hk_lfr_timecode_erroneous;
810 new_hk_lfr_le.timecode_erroneous= housekeeping_packet.hk_lfr_timecode_erroneous;
811 new_hk_lfr_le.timecode_missing = housekeeping_packet.hk_lfr_timecode_missing;
811 new_hk_lfr_le.timecode_missing = housekeeping_packet.hk_lfr_timecode_missing;
812 new_hk_lfr_le.timecode_invalid = housekeeping_packet.hk_lfr_timecode_invalid;
812 new_hk_lfr_le.timecode_invalid = housekeeping_packet.hk_lfr_timecode_invalid;
813 // TIME
813 // TIME
814 new_hk_lfr_le.time_timecode_it = housekeeping_packet.hk_lfr_time_timecode_it;
814 new_hk_lfr_le.time_timecode_it = housekeeping_packet.hk_lfr_time_timecode_it;
815 new_hk_lfr_le.time_not_synchro = housekeeping_packet.hk_lfr_time_not_synchro;
815 new_hk_lfr_le.time_not_synchro = housekeeping_packet.hk_lfr_time_not_synchro;
816 new_hk_lfr_le.time_timecode_ctr = housekeeping_packet.hk_lfr_time_timecode_ctr;
816 new_hk_lfr_le.time_timecode_ctr = housekeeping_packet.hk_lfr_time_timecode_ctr;
817 //AHB
817 //AHB
818 new_hk_lfr_le.ahb_correctable = housekeeping_packet.hk_lfr_ahb_correctable;
818 new_hk_lfr_le.ahb_correctable = housekeeping_packet.hk_lfr_ahb_correctable;
819 // housekeeping_packet.hk_lfr_dpu_spw_rx_ahb => not handled by the grspw driver
819 // housekeeping_packet.hk_lfr_dpu_spw_rx_ahb => not handled by the grspw driver
820 // housekeeping_packet.hk_lfr_dpu_spw_tx_ahb => not handled by the grspw driver
820 // housekeeping_packet.hk_lfr_dpu_spw_tx_ahb => not handled by the grspw driver
821
821
822 // update the le counter
822 // update the le counter
823 // DPU
823 // DPU
824 increment_hk_counter( new_hk_lfr_le.dpu_spw_parity, old_hk_lfr_le.dpu_spw_parity, &counter );
824 increment_hk_counter( new_hk_lfr_le.dpu_spw_parity, old_hk_lfr_le.dpu_spw_parity, &counter );
825 increment_hk_counter( new_hk_lfr_le.dpu_spw_disconnect,old_hk_lfr_le.dpu_spw_disconnect, &counter );
825 increment_hk_counter( new_hk_lfr_le.dpu_spw_disconnect,old_hk_lfr_le.dpu_spw_disconnect, &counter );
826 increment_hk_counter( new_hk_lfr_le.dpu_spw_escape, old_hk_lfr_le.dpu_spw_escape, &counter );
826 increment_hk_counter( new_hk_lfr_le.dpu_spw_escape, old_hk_lfr_le.dpu_spw_escape, &counter );
827 increment_hk_counter( new_hk_lfr_le.dpu_spw_credit, old_hk_lfr_le.dpu_spw_credit, &counter );
827 increment_hk_counter( new_hk_lfr_le.dpu_spw_credit, old_hk_lfr_le.dpu_spw_credit, &counter );
828 increment_hk_counter( new_hk_lfr_le.dpu_spw_write_sync,old_hk_lfr_le.dpu_spw_write_sync, &counter );
828 increment_hk_counter( new_hk_lfr_le.dpu_spw_write_sync,old_hk_lfr_le.dpu_spw_write_sync, &counter );
829 // TIMECODE
829 // TIMECODE
830 increment_hk_counter( new_hk_lfr_le.timecode_erroneous,old_hk_lfr_le.timecode_erroneous, &counter );
830 increment_hk_counter( new_hk_lfr_le.timecode_erroneous,old_hk_lfr_le.timecode_erroneous, &counter );
831 increment_hk_counter( new_hk_lfr_le.timecode_missing, old_hk_lfr_le.timecode_missing, &counter );
831 increment_hk_counter( new_hk_lfr_le.timecode_missing, old_hk_lfr_le.timecode_missing, &counter );
832 increment_hk_counter( new_hk_lfr_le.timecode_invalid, old_hk_lfr_le.timecode_invalid, &counter );
832 increment_hk_counter( new_hk_lfr_le.timecode_invalid, old_hk_lfr_le.timecode_invalid, &counter );
833 // TIME
833 // TIME
834 increment_hk_counter( new_hk_lfr_le.time_timecode_it, old_hk_lfr_le.time_timecode_it, &counter );
834 increment_hk_counter( new_hk_lfr_le.time_timecode_it, old_hk_lfr_le.time_timecode_it, &counter );
835 increment_hk_counter( new_hk_lfr_le.time_not_synchro, old_hk_lfr_le.time_not_synchro, &counter );
835 increment_hk_counter( new_hk_lfr_le.time_not_synchro, old_hk_lfr_le.time_not_synchro, &counter );
836 increment_hk_counter( new_hk_lfr_le.time_timecode_ctr, old_hk_lfr_le.time_timecode_ctr, &counter );
836 increment_hk_counter( new_hk_lfr_le.time_timecode_ctr, old_hk_lfr_le.time_timecode_ctr, &counter );
837 // AHB
837 // AHB
838 increment_hk_counter( new_hk_lfr_le.ahb_correctable, old_hk_lfr_le.ahb_correctable, &counter );
838 increment_hk_counter( new_hk_lfr_le.ahb_correctable, old_hk_lfr_le.ahb_correctable, &counter );
839
839
840 // DPU
840 // DPU
841 old_hk_lfr_le.dpu_spw_parity = new_hk_lfr_le.dpu_spw_parity;
841 old_hk_lfr_le.dpu_spw_parity = new_hk_lfr_le.dpu_spw_parity;
842 old_hk_lfr_le.dpu_spw_disconnect= new_hk_lfr_le.dpu_spw_disconnect;
842 old_hk_lfr_le.dpu_spw_disconnect= new_hk_lfr_le.dpu_spw_disconnect;
843 old_hk_lfr_le.dpu_spw_escape = new_hk_lfr_le.dpu_spw_escape;
843 old_hk_lfr_le.dpu_spw_escape = new_hk_lfr_le.dpu_spw_escape;
844 old_hk_lfr_le.dpu_spw_credit = new_hk_lfr_le.dpu_spw_credit;
844 old_hk_lfr_le.dpu_spw_credit = new_hk_lfr_le.dpu_spw_credit;
845 old_hk_lfr_le.dpu_spw_write_sync= new_hk_lfr_le.dpu_spw_write_sync;
845 old_hk_lfr_le.dpu_spw_write_sync= new_hk_lfr_le.dpu_spw_write_sync;
846 // TIMECODE
846 // TIMECODE
847 old_hk_lfr_le.timecode_erroneous= new_hk_lfr_le.timecode_erroneous;
847 old_hk_lfr_le.timecode_erroneous= new_hk_lfr_le.timecode_erroneous;
848 old_hk_lfr_le.timecode_missing = new_hk_lfr_le.timecode_missing;
848 old_hk_lfr_le.timecode_missing = new_hk_lfr_le.timecode_missing;
849 old_hk_lfr_le.timecode_invalid = new_hk_lfr_le.timecode_invalid;
849 old_hk_lfr_le.timecode_invalid = new_hk_lfr_le.timecode_invalid;
850 // TIME
850 // TIME
851 old_hk_lfr_le.time_timecode_it = new_hk_lfr_le.time_timecode_it;
851 old_hk_lfr_le.time_timecode_it = new_hk_lfr_le.time_timecode_it;
852 old_hk_lfr_le.time_not_synchro = new_hk_lfr_le.time_not_synchro;
852 old_hk_lfr_le.time_not_synchro = new_hk_lfr_le.time_not_synchro;
853 old_hk_lfr_le.time_timecode_ctr = new_hk_lfr_le.time_timecode_ctr;
853 old_hk_lfr_le.time_timecode_ctr = new_hk_lfr_le.time_timecode_ctr;
854 //AHB
854 //AHB
855 old_hk_lfr_le.ahb_correctable = new_hk_lfr_le.ahb_correctable;
855 old_hk_lfr_le.ahb_correctable = new_hk_lfr_le.ahb_correctable;
856 // housekeeping_packet.hk_lfr_dpu_spw_rx_ahb => not handled by the grspw driver
856 // housekeeping_packet.hk_lfr_dpu_spw_rx_ahb => not handled by the grspw driver
857 // housekeeping_packet.hk_lfr_dpu_spw_tx_ahb => not handled by the grspw driver
857 // housekeeping_packet.hk_lfr_dpu_spw_tx_ahb => not handled by the grspw driver
858
858
859 // update housekeeping packet counters, convert unsigned int numbers in 2 bytes numbers
859 // update housekeeping packet counters, convert unsigned int numbers in 2 bytes numbers
860 // LE
860 // LE
861 housekeeping_packet.hk_lfr_le_cnt[0] = (unsigned char) ((counter & BYTE0_MASK) >> SHIFT_1_BYTE);
861 housekeeping_packet.hk_lfr_le_cnt[0] = (unsigned char) ((counter & BYTE0_MASK) >> SHIFT_1_BYTE);
862 housekeeping_packet.hk_lfr_le_cnt[1] = (unsigned char) (counter & BYTE1_MASK);
862 housekeeping_packet.hk_lfr_le_cnt[1] = (unsigned char) (counter & BYTE1_MASK);
863 }
863 }
864
864
865 void hk_lfr_me_update( void )
865 void hk_lfr_me_update( void )
866 {
866 {
867 static hk_lfr_me_t old_hk_lfr_me = {0};
867 static hk_lfr_me_t old_hk_lfr_me = {0};
868 hk_lfr_me_t new_hk_lfr_me;
868 hk_lfr_me_t new_hk_lfr_me;
869 unsigned int counter;
869 unsigned int counter;
870
870
871 counter = (((unsigned int) housekeeping_packet.hk_lfr_me_cnt[0]) * 256) + housekeeping_packet.hk_lfr_me_cnt[1];
871 counter = (((unsigned int) housekeeping_packet.hk_lfr_me_cnt[0]) * 256) + housekeeping_packet.hk_lfr_me_cnt[1];
872
872
873 // get the current values
873 // get the current values
874 new_hk_lfr_me.dpu_spw_early_eop = housekeeping_packet.hk_lfr_dpu_spw_early_eop;
874 new_hk_lfr_me.dpu_spw_early_eop = housekeeping_packet.hk_lfr_dpu_spw_early_eop;
875 new_hk_lfr_me.dpu_spw_invalid_addr = housekeeping_packet.hk_lfr_dpu_spw_invalid_addr;
875 new_hk_lfr_me.dpu_spw_invalid_addr = housekeeping_packet.hk_lfr_dpu_spw_invalid_addr;
876 new_hk_lfr_me.dpu_spw_eep = housekeeping_packet.hk_lfr_dpu_spw_eep;
876 new_hk_lfr_me.dpu_spw_eep = housekeeping_packet.hk_lfr_dpu_spw_eep;
877 new_hk_lfr_me.dpu_spw_rx_too_big = housekeeping_packet.hk_lfr_dpu_spw_rx_too_big;
877 new_hk_lfr_me.dpu_spw_rx_too_big = housekeeping_packet.hk_lfr_dpu_spw_rx_too_big;
878
878
879 // update the me counter
879 // update the me counter
880 increment_hk_counter( new_hk_lfr_me.dpu_spw_early_eop, old_hk_lfr_me.dpu_spw_early_eop, &counter );
880 increment_hk_counter( new_hk_lfr_me.dpu_spw_early_eop, old_hk_lfr_me.dpu_spw_early_eop, &counter );
881 increment_hk_counter( new_hk_lfr_me.dpu_spw_invalid_addr, old_hk_lfr_me.dpu_spw_invalid_addr, &counter );
881 increment_hk_counter( new_hk_lfr_me.dpu_spw_invalid_addr, old_hk_lfr_me.dpu_spw_invalid_addr, &counter );
882 increment_hk_counter( new_hk_lfr_me.dpu_spw_eep, old_hk_lfr_me.dpu_spw_eep, &counter );
882 increment_hk_counter( new_hk_lfr_me.dpu_spw_eep, old_hk_lfr_me.dpu_spw_eep, &counter );
883 increment_hk_counter( new_hk_lfr_me.dpu_spw_rx_too_big, old_hk_lfr_me.dpu_spw_rx_too_big, &counter );
883 increment_hk_counter( new_hk_lfr_me.dpu_spw_rx_too_big, old_hk_lfr_me.dpu_spw_rx_too_big, &counter );
884
884
885 // store the counters for the next time
885 // store the counters for the next time
886 old_hk_lfr_me.dpu_spw_early_eop = new_hk_lfr_me.dpu_spw_early_eop;
886 old_hk_lfr_me.dpu_spw_early_eop = new_hk_lfr_me.dpu_spw_early_eop;
887 old_hk_lfr_me.dpu_spw_invalid_addr = new_hk_lfr_me.dpu_spw_invalid_addr;
887 old_hk_lfr_me.dpu_spw_invalid_addr = new_hk_lfr_me.dpu_spw_invalid_addr;
888 old_hk_lfr_me.dpu_spw_eep = new_hk_lfr_me.dpu_spw_eep;
888 old_hk_lfr_me.dpu_spw_eep = new_hk_lfr_me.dpu_spw_eep;
889 old_hk_lfr_me.dpu_spw_rx_too_big = new_hk_lfr_me.dpu_spw_rx_too_big;
889 old_hk_lfr_me.dpu_spw_rx_too_big = new_hk_lfr_me.dpu_spw_rx_too_big;
890
890
891 // update housekeeping packet counters, convert unsigned int numbers in 2 bytes numbers
891 // update housekeeping packet counters, convert unsigned int numbers in 2 bytes numbers
892 // ME
892 // ME
893 housekeeping_packet.hk_lfr_me_cnt[0] = (unsigned char) ((counter & BYTE0_MASK) >> SHIFT_1_BYTE);
893 housekeeping_packet.hk_lfr_me_cnt[0] = (unsigned char) ((counter & BYTE0_MASK) >> SHIFT_1_BYTE);
894 housekeeping_packet.hk_lfr_me_cnt[1] = (unsigned char) (counter & BYTE1_MASK);
894 housekeeping_packet.hk_lfr_me_cnt[1] = (unsigned char) (counter & BYTE1_MASK);
895 }
895 }
896
896
897 void hk_lfr_le_me_he_update()
897 void hk_lfr_le_me_he_update()
898 {
898 {
899
899
900 unsigned int hk_lfr_he_cnt;
900 unsigned int hk_lfr_he_cnt;
901
901
902 hk_lfr_he_cnt = (((unsigned int) housekeeping_packet.hk_lfr_he_cnt[0]) * 256) + housekeeping_packet.hk_lfr_he_cnt[1];
902 hk_lfr_he_cnt = (((unsigned int) housekeeping_packet.hk_lfr_he_cnt[0]) * 256) + housekeeping_packet.hk_lfr_he_cnt[1];
903
903
904 //update the low severity error counter
904 //update the low severity error counter
905 hk_lfr_le_update( );
905 hk_lfr_le_update( );
906
906
907 //update the medium severity error counter
907 //update the medium severity error counter
908 hk_lfr_me_update();
908 hk_lfr_me_update();
909
909
910 //update the high severity error counter
910 //update the high severity error counter
911 hk_lfr_he_cnt = 0;
911 hk_lfr_he_cnt = 0;
912
912
913 // update housekeeping packet counters, convert unsigned int numbers in 2 bytes numbers
913 // update housekeeping packet counters, convert unsigned int numbers in 2 bytes numbers
914 // HE
914 // HE
915 housekeeping_packet.hk_lfr_he_cnt[0] = (unsigned char) ((hk_lfr_he_cnt & BYTE0_MASK) >> SHIFT_1_BYTE);
915 housekeeping_packet.hk_lfr_he_cnt[0] = (unsigned char) ((hk_lfr_he_cnt & BYTE0_MASK) >> SHIFT_1_BYTE);
916 housekeeping_packet.hk_lfr_he_cnt[1] = (unsigned char) (hk_lfr_he_cnt & BYTE1_MASK);
916 housekeeping_packet.hk_lfr_he_cnt[1] = (unsigned char) (hk_lfr_he_cnt & BYTE1_MASK);
917
917
918 }
918 }
919
919
920 void set_hk_lfr_time_not_synchro()
920 void set_hk_lfr_time_not_synchro()
921 {
921 {
922 static unsigned char synchroLost = 1;
922 static unsigned char synchroLost = 1;
923 int synchronizationBit;
923 int synchronizationBit;
924
924
925 // get the synchronization bit
925 // get the synchronization bit
926 synchronizationBit =
926 synchronizationBit =
927 (time_management_regs->coarse_time & VAL_LFR_SYNCHRONIZED) >> BIT_SYNCHRONIZATION; // 1000 0000 0000 0000
927 (time_management_regs->coarse_time & VAL_LFR_SYNCHRONIZED) >> BIT_SYNCHRONIZATION; // 1000 0000 0000 0000
928
928
929 switch (synchronizationBit)
929 switch (synchronizationBit)
930 {
930 {
931 case 0:
931 case 0:
932 if (synchroLost == 1)
932 if (synchroLost == 1)
933 {
933 {
934 synchroLost = 0;
934 synchroLost = 0;
935 }
935 }
936 break;
936 break;
937 case 1:
937 case 1:
938 if (synchroLost == 0 )
938 if (synchroLost == 0 )
939 {
939 {
940 synchroLost = 1;
940 synchroLost = 1;
941 increase_unsigned_char_counter(&housekeeping_packet.hk_lfr_time_not_synchro);
941 increase_unsigned_char_counter(&housekeeping_packet.hk_lfr_time_not_synchro);
942 update_hk_lfr_last_er_fields( RID_LE_LFR_TIME, CODE_NOT_SYNCHRO );
942 update_hk_lfr_last_er_fields( RID_LE_LFR_TIME, CODE_NOT_SYNCHRO );
943 }
943 }
944 break;
944 break;
945 default:
945 default:
946 PRINTF1("in hk_lfr_time_not_synchro *** unexpected value for synchronizationBit = %d\n", synchronizationBit);
946 PRINTF1("in hk_lfr_time_not_synchro *** unexpected value for synchronizationBit = %d\n", synchronizationBit);
947 break;
947 break;
948 }
948 }
949
949
950 }
950 }
951
951
952 void set_hk_lfr_ahb_correctable() // CRITICITY L
952 void set_hk_lfr_ahb_correctable() // CRITICITY L
953 {
953 {
954 /** This function builds the error counter hk_lfr_ahb_correctable using the statistics provided
954 /** This function builds the error counter hk_lfr_ahb_correctable using the statistics provided
955 * by the Cache Control Register (ASI 2, offset 0) and in the Register Protection Control Register (ASR16) on the
955 * by the Cache Control Register (ASI 2, offset 0) and in the Register Protection Control Register (ASR16) on the
956 * detected errors in the cache, in the integer unit and in the floating point unit.
956 * detected errors in the cache, in the integer unit and in the floating point unit.
957 *
957 *
958 * @param void
958 * @param void
959 *
959 *
960 * @return void
960 * @return void
961 *
961 *
962 * All errors are summed to set the value of the hk_lfr_ahb_correctable counter.
962 * All errors are summed to set the value of the hk_lfr_ahb_correctable counter.
963 *
963 *
964 */
964 */
965
965
966 unsigned int ahb_correctable;
966 unsigned int ahb_correctable;
967 unsigned int instructionErrorCounter;
967 unsigned int instructionErrorCounter;
968 unsigned int dataErrorCounter;
968 unsigned int dataErrorCounter;
969 unsigned int fprfErrorCounter;
969 unsigned int fprfErrorCounter;
970 unsigned int iurfErrorCounter;
970 unsigned int iurfErrorCounter;
971
971
972 instructionErrorCounter = 0;
972 instructionErrorCounter = 0;
973 dataErrorCounter = 0;
973 dataErrorCounter = 0;
974 fprfErrorCounter = 0;
974 fprfErrorCounter = 0;
975 iurfErrorCounter = 0;
975 iurfErrorCounter = 0;
976
976
977 CCR_getInstructionAndDataErrorCounters( &instructionErrorCounter, &dataErrorCounter);
977 CCR_getInstructionAndDataErrorCounters( &instructionErrorCounter, &dataErrorCounter);
978 ASR16_get_FPRF_IURF_ErrorCounters( &fprfErrorCounter, &iurfErrorCounter);
978 ASR16_get_FPRF_IURF_ErrorCounters( &fprfErrorCounter, &iurfErrorCounter);
979
979
980 ahb_correctable = instructionErrorCounter
980 ahb_correctable = instructionErrorCounter
981 + dataErrorCounter
981 + dataErrorCounter
982 + fprfErrorCounter
982 + fprfErrorCounter
983 + iurfErrorCounter
983 + iurfErrorCounter
984 + housekeeping_packet.hk_lfr_ahb_correctable;
984 + housekeeping_packet.hk_lfr_ahb_correctable;
985
985
986 housekeeping_packet.hk_lfr_ahb_correctable = (unsigned char) (ahb_correctable & INT8_ALL_F); // [1111 1111]
986 housekeeping_packet.hk_lfr_ahb_correctable = (unsigned char) (ahb_correctable & INT8_ALL_F); // [1111 1111]
987
987
988 }
988 }
@@ -1,1688 +1,1671
1 /** Functions to load and dump parameters in the LFR registers.
1 /** Functions to load and dump parameters in the LFR registers.
2 *
2 *
3 * @file
3 * @file
4 * @author P. LEROY
4 * @author P. LEROY
5 *
5 *
6 * A group of functions to handle TC related to parameter loading and dumping.\n
6 * A group of functions to handle TC related to parameter loading and dumping.\n
7 * TC_LFR_LOAD_COMMON_PAR\n
7 * TC_LFR_LOAD_COMMON_PAR\n
8 * TC_LFR_LOAD_NORMAL_PAR\n
8 * TC_LFR_LOAD_NORMAL_PAR\n
9 * TC_LFR_LOAD_BURST_PAR\n
9 * TC_LFR_LOAD_BURST_PAR\n
10 * TC_LFR_LOAD_SBM1_PAR\n
10 * TC_LFR_LOAD_SBM1_PAR\n
11 * TC_LFR_LOAD_SBM2_PAR\n
11 * TC_LFR_LOAD_SBM2_PAR\n
12 *
12 *
13 */
13 */
14
14
15 #include "tc_load_dump_parameters.h"
15 #include "tc_load_dump_parameters.h"
16
16
17 Packet_TM_LFR_KCOEFFICIENTS_DUMP_t kcoefficients_dump_1 = {0};
17 Packet_TM_LFR_KCOEFFICIENTS_DUMP_t kcoefficients_dump_1 = {0};
18 Packet_TM_LFR_KCOEFFICIENTS_DUMP_t kcoefficients_dump_2 = {0};
18 Packet_TM_LFR_KCOEFFICIENTS_DUMP_t kcoefficients_dump_2 = {0};
19 ring_node kcoefficient_node_1 = {0};
19 ring_node kcoefficient_node_1 = {0};
20 ring_node kcoefficient_node_2 = {0};
20 ring_node kcoefficient_node_2 = {0};
21
21
22 int action_load_common_par(ccsdsTelecommandPacket_t *TC)
22 int action_load_common_par(ccsdsTelecommandPacket_t *TC)
23 {
23 {
24 /** This function updates the LFR registers with the incoming common parameters.
24 /** This function updates the LFR registers with the incoming common parameters.
25 *
25 *
26 * @param TC points to the TeleCommand packet that is being processed
26 * @param TC points to the TeleCommand packet that is being processed
27 *
27 *
28 *
28 *
29 */
29 */
30
30
31 parameter_dump_packet.sy_lfr_common_parameters_spare = TC->dataAndCRC[0];
31 parameter_dump_packet.sy_lfr_common_parameters_spare = TC->dataAndCRC[0];
32 parameter_dump_packet.sy_lfr_common_parameters = TC->dataAndCRC[1];
32 parameter_dump_packet.sy_lfr_common_parameters = TC->dataAndCRC[1];
33 set_wfp_data_shaping( );
33 set_wfp_data_shaping( );
34 return LFR_SUCCESSFUL;
34 return LFR_SUCCESSFUL;
35 }
35 }
36
36
37 int action_load_normal_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
37 int action_load_normal_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
38 {
38 {
39 /** This function updates the LFR registers with the incoming normal parameters.
39 /** This function updates the LFR registers with the incoming normal parameters.
40 *
40 *
41 * @param TC points to the TeleCommand packet that is being processed
41 * @param TC points to the TeleCommand packet that is being processed
42 * @param queue_id is the id of the queue which handles TM related to this execution step
42 * @param queue_id is the id of the queue which handles TM related to this execution step
43 *
43 *
44 */
44 */
45
45
46 int result;
46 int result;
47 int flag;
47 int flag;
48 rtems_status_code status;
48 rtems_status_code status;
49
49
50 flag = LFR_SUCCESSFUL;
50 flag = LFR_SUCCESSFUL;
51
51
52 if ( (lfrCurrentMode == LFR_MODE_NORMAL) ||
52 if ( (lfrCurrentMode == LFR_MODE_NORMAL) ||
53 (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) ) {
53 (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) ) {
54 status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
54 status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
55 flag = LFR_DEFAULT;
55 flag = LFR_DEFAULT;
56 }
56 }
57
57
58 // CHECK THE PARAMETERS SET CONSISTENCY
58 // CHECK THE PARAMETERS SET CONSISTENCY
59 if (flag == LFR_SUCCESSFUL)
59 if (flag == LFR_SUCCESSFUL)
60 {
60 {
61 flag = check_normal_par_consistency( TC, queue_id );
61 flag = check_normal_par_consistency( TC, queue_id );
62 }
62 }
63
63
64 // SET THE PARAMETERS IF THEY ARE CONSISTENT
64 // SET THE PARAMETERS IF THEY ARE CONSISTENT
65 if (flag == LFR_SUCCESSFUL)
65 if (flag == LFR_SUCCESSFUL)
66 {
66 {
67 result = set_sy_lfr_n_swf_l( TC );
67 result = set_sy_lfr_n_swf_l( TC );
68 result = set_sy_lfr_n_swf_p( TC );
68 result = set_sy_lfr_n_swf_p( TC );
69 result = set_sy_lfr_n_bp_p0( TC );
69 result = set_sy_lfr_n_bp_p0( TC );
70 result = set_sy_lfr_n_bp_p1( TC );
70 result = set_sy_lfr_n_bp_p1( TC );
71 result = set_sy_lfr_n_asm_p( TC );
71 result = set_sy_lfr_n_asm_p( TC );
72 result = set_sy_lfr_n_cwf_long_f3( TC );
72 result = set_sy_lfr_n_cwf_long_f3( TC );
73 }
73 }
74
74
75 return flag;
75 return flag;
76 }
76 }
77
77
78 int action_load_burst_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
78 int action_load_burst_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
79 {
79 {
80 /** This function updates the LFR registers with the incoming burst parameters.
80 /** This function updates the LFR registers with the incoming burst parameters.
81 *
81 *
82 * @param TC points to the TeleCommand packet that is being processed
82 * @param TC points to the TeleCommand packet that is being processed
83 * @param queue_id is the id of the queue which handles TM related to this execution step
83 * @param queue_id is the id of the queue which handles TM related to this execution step
84 *
84 *
85 */
85 */
86
86
87 int flag;
87 int flag;
88 rtems_status_code status;
88 rtems_status_code status;
89 unsigned char sy_lfr_b_bp_p0;
89 unsigned char sy_lfr_b_bp_p0;
90 unsigned char sy_lfr_b_bp_p1;
90 unsigned char sy_lfr_b_bp_p1;
91 float aux;
91 float aux;
92
92
93 flag = LFR_SUCCESSFUL;
93 flag = LFR_SUCCESSFUL;
94
94
95 if ( lfrCurrentMode == LFR_MODE_BURST ) {
95 if ( lfrCurrentMode == LFR_MODE_BURST ) {
96 status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
96 status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
97 flag = LFR_DEFAULT;
97 flag = LFR_DEFAULT;
98 }
98 }
99
99
100 sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ];
100 sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ];
101 sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ];
101 sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ];
102
102
103 // sy_lfr_b_bp_p0 shall not be lower than its default value
103 // sy_lfr_b_bp_p0 shall not be lower than its default value
104 if (flag == LFR_SUCCESSFUL)
104 if (flag == LFR_SUCCESSFUL)
105 {
105 {
106 if (sy_lfr_b_bp_p0 < DEFAULT_SY_LFR_B_BP_P0 )
106 if (sy_lfr_b_bp_p0 < DEFAULT_SY_LFR_B_BP_P0 )
107 {
107 {
108 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_B_BP_P0 + DATAFIELD_OFFSET, sy_lfr_b_bp_p0 );
108 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_B_BP_P0 + DATAFIELD_OFFSET, sy_lfr_b_bp_p0 );
109 flag = WRONG_APP_DATA;
109 flag = WRONG_APP_DATA;
110 }
110 }
111 }
111 }
112 // sy_lfr_b_bp_p1 shall not be lower than its default value
112 // sy_lfr_b_bp_p1 shall not be lower than its default value
113 if (flag == LFR_SUCCESSFUL)
113 if (flag == LFR_SUCCESSFUL)
114 {
114 {
115 if (sy_lfr_b_bp_p1 < DEFAULT_SY_LFR_B_BP_P1 )
115 if (sy_lfr_b_bp_p1 < DEFAULT_SY_LFR_B_BP_P1 )
116 {
116 {
117 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_B_BP_P1 + DATAFIELD_OFFSET, sy_lfr_b_bp_p1 );
117 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_B_BP_P1 + DATAFIELD_OFFSET, sy_lfr_b_bp_p1 );
118 flag = WRONG_APP_DATA;
118 flag = WRONG_APP_DATA;
119 }
119 }
120 }
120 }
121 //****************************************************************
121 //****************************************************************
122 // check the consistency between sy_lfr_b_bp_p0 and sy_lfr_b_bp_p1
122 // check the consistency between sy_lfr_b_bp_p0 and sy_lfr_b_bp_p1
123 if (flag == LFR_SUCCESSFUL)
123 if (flag == LFR_SUCCESSFUL)
124 {
124 {
125 sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ];
125 sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ];
126 sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ];
126 sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ];
127 aux = ( (float ) sy_lfr_b_bp_p1 / sy_lfr_b_bp_p0 ) - floor(sy_lfr_b_bp_p1 / sy_lfr_b_bp_p0);
127 aux = ( (float ) sy_lfr_b_bp_p1 / sy_lfr_b_bp_p0 ) - floor(sy_lfr_b_bp_p1 / sy_lfr_b_bp_p0);
128 if (aux > FLOAT_EQUAL_ZERO)
128 if (aux > FLOAT_EQUAL_ZERO)
129 {
129 {
130 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_B_BP_P0 + DATAFIELD_OFFSET, sy_lfr_b_bp_p0 );
130 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_B_BP_P0 + DATAFIELD_OFFSET, sy_lfr_b_bp_p0 );
131 flag = LFR_DEFAULT;
131 flag = LFR_DEFAULT;
132 }
132 }
133 }
133 }
134
134
135 // SET THE PARAMETERS
135 // SET THE PARAMETERS
136 if (flag == LFR_SUCCESSFUL)
136 if (flag == LFR_SUCCESSFUL)
137 {
137 {
138 flag = set_sy_lfr_b_bp_p0( TC );
138 flag = set_sy_lfr_b_bp_p0( TC );
139 flag = set_sy_lfr_b_bp_p1( TC );
139 flag = set_sy_lfr_b_bp_p1( TC );
140 }
140 }
141
141
142 return flag;
142 return flag;
143 }
143 }
144
144
145 int action_load_sbm1_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
145 int action_load_sbm1_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
146 {
146 {
147 /** This function updates the LFR registers with the incoming sbm1 parameters.
147 /** This function updates the LFR registers with the incoming sbm1 parameters.
148 *
148 *
149 * @param TC points to the TeleCommand packet that is being processed
149 * @param TC points to the TeleCommand packet that is being processed
150 * @param queue_id is the id of the queue which handles TM related to this execution step
150 * @param queue_id is the id of the queue which handles TM related to this execution step
151 *
151 *
152 */
152 */
153
153
154 int flag;
154 int flag;
155 rtems_status_code status;
155 rtems_status_code status;
156 unsigned char sy_lfr_s1_bp_p0;
156 unsigned char sy_lfr_s1_bp_p0;
157 unsigned char sy_lfr_s1_bp_p1;
157 unsigned char sy_lfr_s1_bp_p1;
158 float aux;
158 float aux;
159
159
160 flag = LFR_SUCCESSFUL;
160 flag = LFR_SUCCESSFUL;
161
161
162 if ( lfrCurrentMode == LFR_MODE_SBM1 ) {
162 if ( lfrCurrentMode == LFR_MODE_SBM1 ) {
163 status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
163 status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
164 flag = LFR_DEFAULT;
164 flag = LFR_DEFAULT;
165 }
165 }
166
166
167 sy_lfr_s1_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P0 ];
167 sy_lfr_s1_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P0 ];
168 sy_lfr_s1_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P1 ];
168 sy_lfr_s1_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P1 ];
169
169
170 // sy_lfr_s1_bp_p0
170 // sy_lfr_s1_bp_p0
171 if (flag == LFR_SUCCESSFUL)
171 if (flag == LFR_SUCCESSFUL)
172 {
172 {
173 if (sy_lfr_s1_bp_p0 < DEFAULT_SY_LFR_S1_BP_P0 )
173 if (sy_lfr_s1_bp_p0 < DEFAULT_SY_LFR_S1_BP_P0 )
174 {
174 {
175 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S1_BP_P0 + DATAFIELD_OFFSET, sy_lfr_s1_bp_p0 );
175 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S1_BP_P0 + DATAFIELD_OFFSET, sy_lfr_s1_bp_p0 );
176 flag = WRONG_APP_DATA;
176 flag = WRONG_APP_DATA;
177 }
177 }
178 }
178 }
179 // sy_lfr_s1_bp_p1
179 // sy_lfr_s1_bp_p1
180 if (flag == LFR_SUCCESSFUL)
180 if (flag == LFR_SUCCESSFUL)
181 {
181 {
182 if (sy_lfr_s1_bp_p1 < DEFAULT_SY_LFR_S1_BP_P1 )
182 if (sy_lfr_s1_bp_p1 < DEFAULT_SY_LFR_S1_BP_P1 )
183 {
183 {
184 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S1_BP_P1 + DATAFIELD_OFFSET, sy_lfr_s1_bp_p1 );
184 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S1_BP_P1 + DATAFIELD_OFFSET, sy_lfr_s1_bp_p1 );
185 flag = WRONG_APP_DATA;
185 flag = WRONG_APP_DATA;
186 }
186 }
187 }
187 }
188 //******************************************************************
188 //******************************************************************
189 // check the consistency between sy_lfr_s1_bp_p0 and sy_lfr_s1_bp_p1
189 // check the consistency between sy_lfr_s1_bp_p0 and sy_lfr_s1_bp_p1
190 if (flag == LFR_SUCCESSFUL)
190 if (flag == LFR_SUCCESSFUL)
191 {
191 {
192 aux = ( (float ) sy_lfr_s1_bp_p1 / (sy_lfr_s1_bp_p0 * S1_BP_P0_SCALE) )
192 aux = ( (float ) sy_lfr_s1_bp_p1 / (sy_lfr_s1_bp_p0 * S1_BP_P0_SCALE) )
193 - floor(sy_lfr_s1_bp_p1 / (sy_lfr_s1_bp_p0 * S1_BP_P0_SCALE));
193 - floor(sy_lfr_s1_bp_p1 / (sy_lfr_s1_bp_p0 * S1_BP_P0_SCALE));
194 if (aux > FLOAT_EQUAL_ZERO)
194 if (aux > FLOAT_EQUAL_ZERO)
195 {
195 {
196 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S1_BP_P0 + DATAFIELD_OFFSET, sy_lfr_s1_bp_p0 );
196 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S1_BP_P0 + DATAFIELD_OFFSET, sy_lfr_s1_bp_p0 );
197 flag = LFR_DEFAULT;
197 flag = LFR_DEFAULT;
198 }
198 }
199 }
199 }
200
200
201 // SET THE PARAMETERS
201 // SET THE PARAMETERS
202 if (flag == LFR_SUCCESSFUL)
202 if (flag == LFR_SUCCESSFUL)
203 {
203 {
204 flag = set_sy_lfr_s1_bp_p0( TC );
204 flag = set_sy_lfr_s1_bp_p0( TC );
205 flag = set_sy_lfr_s1_bp_p1( TC );
205 flag = set_sy_lfr_s1_bp_p1( TC );
206 }
206 }
207
207
208 return flag;
208 return flag;
209 }
209 }
210
210
211 int action_load_sbm2_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
211 int action_load_sbm2_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
212 {
212 {
213 /** This function updates the LFR registers with the incoming sbm2 parameters.
213 /** This function updates the LFR registers with the incoming sbm2 parameters.
214 *
214 *
215 * @param TC points to the TeleCommand packet that is being processed
215 * @param TC points to the TeleCommand packet that is being processed
216 * @param queue_id is the id of the queue which handles TM related to this execution step
216 * @param queue_id is the id of the queue which handles TM related to this execution step
217 *
217 *
218 */
218 */
219
219
220 int flag;
220 int flag;
221 rtems_status_code status;
221 rtems_status_code status;
222 unsigned char sy_lfr_s2_bp_p0;
222 unsigned char sy_lfr_s2_bp_p0;
223 unsigned char sy_lfr_s2_bp_p1;
223 unsigned char sy_lfr_s2_bp_p1;
224 float aux;
224 float aux;
225
225
226 flag = LFR_SUCCESSFUL;
226 flag = LFR_SUCCESSFUL;
227
227
228 if ( lfrCurrentMode == LFR_MODE_SBM2 ) {
228 if ( lfrCurrentMode == LFR_MODE_SBM2 ) {
229 status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
229 status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
230 flag = LFR_DEFAULT;
230 flag = LFR_DEFAULT;
231 }
231 }
232
232
233 sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ];
233 sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ];
234 sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ];
234 sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ];
235
235
236 // sy_lfr_s2_bp_p0
236 // sy_lfr_s2_bp_p0
237 if (flag == LFR_SUCCESSFUL)
237 if (flag == LFR_SUCCESSFUL)
238 {
238 {
239 if (sy_lfr_s2_bp_p0 < DEFAULT_SY_LFR_S2_BP_P0 )
239 if (sy_lfr_s2_bp_p0 < DEFAULT_SY_LFR_S2_BP_P0 )
240 {
240 {
241 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S2_BP_P0 + DATAFIELD_OFFSET, sy_lfr_s2_bp_p0 );
241 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S2_BP_P0 + DATAFIELD_OFFSET, sy_lfr_s2_bp_p0 );
242 flag = WRONG_APP_DATA;
242 flag = WRONG_APP_DATA;
243 }
243 }
244 }
244 }
245 // sy_lfr_s2_bp_p1
245 // sy_lfr_s2_bp_p1
246 if (flag == LFR_SUCCESSFUL)
246 if (flag == LFR_SUCCESSFUL)
247 {
247 {
248 if (sy_lfr_s2_bp_p1 < DEFAULT_SY_LFR_S2_BP_P1 )
248 if (sy_lfr_s2_bp_p1 < DEFAULT_SY_LFR_S2_BP_P1 )
249 {
249 {
250 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S2_BP_P1 + DATAFIELD_OFFSET, sy_lfr_s2_bp_p1 );
250 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S2_BP_P1 + DATAFIELD_OFFSET, sy_lfr_s2_bp_p1 );
251 flag = WRONG_APP_DATA;
251 flag = WRONG_APP_DATA;
252 }
252 }
253 }
253 }
254 //******************************************************************
254 //******************************************************************
255 // check the consistency between sy_lfr_s2_bp_p0 and sy_lfr_s2_bp_p1
255 // check the consistency between sy_lfr_s2_bp_p0 and sy_lfr_s2_bp_p1
256 if (flag == LFR_SUCCESSFUL)
256 if (flag == LFR_SUCCESSFUL)
257 {
257 {
258 sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ];
258 sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ];
259 sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ];
259 sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ];
260 aux = ( (float ) sy_lfr_s2_bp_p1 / sy_lfr_s2_bp_p0 ) - floor(sy_lfr_s2_bp_p1 / sy_lfr_s2_bp_p0);
260 aux = ( (float ) sy_lfr_s2_bp_p1 / sy_lfr_s2_bp_p0 ) - floor(sy_lfr_s2_bp_p1 / sy_lfr_s2_bp_p0);
261 if (aux > FLOAT_EQUAL_ZERO)
261 if (aux > FLOAT_EQUAL_ZERO)
262 {
262 {
263 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S2_BP_P0 + DATAFIELD_OFFSET, sy_lfr_s2_bp_p0 );
263 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S2_BP_P0 + DATAFIELD_OFFSET, sy_lfr_s2_bp_p0 );
264 flag = LFR_DEFAULT;
264 flag = LFR_DEFAULT;
265 }
265 }
266 }
266 }
267
267
268 // SET THE PARAMETERS
268 // SET THE PARAMETERS
269 if (flag == LFR_SUCCESSFUL)
269 if (flag == LFR_SUCCESSFUL)
270 {
270 {
271 flag = set_sy_lfr_s2_bp_p0( TC );
271 flag = set_sy_lfr_s2_bp_p0( TC );
272 flag = set_sy_lfr_s2_bp_p1( TC );
272 flag = set_sy_lfr_s2_bp_p1( TC );
273 }
273 }
274
274
275 return flag;
275 return flag;
276 }
276 }
277
277
278 int action_load_kcoefficients(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
278 int action_load_kcoefficients(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
279 {
279 {
280 /** This function updates the LFR registers with the incoming sbm2 parameters.
280 /** This function updates the LFR registers with the incoming sbm2 parameters.
281 *
281 *
282 * @param TC points to the TeleCommand packet that is being processed
282 * @param TC points to the TeleCommand packet that is being processed
283 * @param queue_id is the id of the queue which handles TM related to this execution step
283 * @param queue_id is the id of the queue which handles TM related to this execution step
284 *
284 *
285 */
285 */
286
286
287 int flag;
287 int flag;
288
288
289 flag = LFR_DEFAULT;
289 flag = LFR_DEFAULT;
290
290
291 flag = set_sy_lfr_kcoeff( TC, queue_id );
291 flag = set_sy_lfr_kcoeff( TC, queue_id );
292
292
293 return flag;
293 return flag;
294 }
294 }
295
295
296 int action_load_fbins_mask(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
296 int action_load_fbins_mask(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
297 {
297 {
298 /** This function updates the LFR registers with the incoming sbm2 parameters.
298 /** This function updates the LFR registers with the incoming sbm2 parameters.
299 *
299 *
300 * @param TC points to the TeleCommand packet that is being processed
300 * @param TC points to the TeleCommand packet that is being processed
301 * @param queue_id is the id of the queue which handles TM related to this execution step
301 * @param queue_id is the id of the queue which handles TM related to this execution step
302 *
302 *
303 */
303 */
304
304
305 int flag;
305 int flag;
306
306
307 flag = LFR_DEFAULT;
307 flag = LFR_DEFAULT;
308
308
309 flag = set_sy_lfr_fbins( TC );
309 flag = set_sy_lfr_fbins( TC );
310
310
311 // once the fbins masks have been stored, they have to be merged with the masks which handle the reaction wheels frequencies filtering
311 // once the fbins masks have been stored, they have to be merged with the masks which handle the reaction wheels frequencies filtering
312 merge_fbins_masks();
312 merge_fbins_masks();
313
313
314 return flag;
314 return flag;
315 }
315 }
316
316
317 int action_load_filter_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
317 int action_load_filter_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
318 {
318 {
319 /** This function updates the LFR registers with the incoming sbm2 parameters.
319 /** This function updates the LFR registers with the incoming sbm2 parameters.
320 *
320 *
321 * @param TC points to the TeleCommand packet that is being processed
321 * @param TC points to the TeleCommand packet that is being processed
322 * @param queue_id is the id of the queue which handles TM related to this execution step
322 * @param queue_id is the id of the queue which handles TM related to this execution step
323 *
323 *
324 */
324 */
325
325
326 int flag;
326 int flag;
327
327
328 flag = LFR_DEFAULT;
328 flag = LFR_DEFAULT;
329
329
330 flag = check_sy_lfr_filter_parameters( TC, queue_id );
330 flag = check_sy_lfr_filter_parameters( TC, queue_id );
331
331
332 if (flag == LFR_SUCCESSFUL)
332 if (flag == LFR_SUCCESSFUL)
333 {
333 {
334 parameter_dump_packet.spare_sy_lfr_pas_filter_enabled = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_ENABLED ];
334 parameter_dump_packet.spare_sy_lfr_pas_filter_enabled = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_ENABLED ];
335 parameter_dump_packet.sy_lfr_pas_filter_modulus = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_MODULUS ];
335 parameter_dump_packet.sy_lfr_pas_filter_modulus = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_MODULUS ];
336 parameter_dump_packet.sy_lfr_pas_filter_tbad[BYTE_0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + BYTE_0 ];
336 parameter_dump_packet.sy_lfr_pas_filter_tbad[BYTE_0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + BYTE_0 ];
337 parameter_dump_packet.sy_lfr_pas_filter_tbad[BYTE_1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + BYTE_1 ];
337 parameter_dump_packet.sy_lfr_pas_filter_tbad[BYTE_1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + BYTE_1 ];
338 parameter_dump_packet.sy_lfr_pas_filter_tbad[BYTE_2] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + BYTE_2 ];
338 parameter_dump_packet.sy_lfr_pas_filter_tbad[BYTE_2] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + BYTE_2 ];
339 parameter_dump_packet.sy_lfr_pas_filter_tbad[BYTE_3] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + BYTE_3 ];
339 parameter_dump_packet.sy_lfr_pas_filter_tbad[BYTE_3] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + BYTE_3 ];
340 parameter_dump_packet.sy_lfr_pas_filter_offset = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_OFFSET ];
340 parameter_dump_packet.sy_lfr_pas_filter_offset = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_OFFSET ];
341 parameter_dump_packet.sy_lfr_pas_filter_shift[BYTE_0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + BYTE_0 ];
341 parameter_dump_packet.sy_lfr_pas_filter_shift[BYTE_0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + BYTE_0 ];
342 parameter_dump_packet.sy_lfr_pas_filter_shift[BYTE_1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + BYTE_1 ];
342 parameter_dump_packet.sy_lfr_pas_filter_shift[BYTE_1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + BYTE_1 ];
343 parameter_dump_packet.sy_lfr_pas_filter_shift[BYTE_2] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + BYTE_2 ];
343 parameter_dump_packet.sy_lfr_pas_filter_shift[BYTE_2] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + BYTE_2 ];
344 parameter_dump_packet.sy_lfr_pas_filter_shift[BYTE_3] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + BYTE_3 ];
344 parameter_dump_packet.sy_lfr_pas_filter_shift[BYTE_3] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + BYTE_3 ];
345 parameter_dump_packet.sy_lfr_sc_rw_delta_f[BYTE_0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + BYTE_0 ];
345 parameter_dump_packet.sy_lfr_sc_rw_delta_f[BYTE_0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + BYTE_0 ];
346 parameter_dump_packet.sy_lfr_sc_rw_delta_f[BYTE_1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + BYTE_1 ];
346 parameter_dump_packet.sy_lfr_sc_rw_delta_f[BYTE_1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + BYTE_1 ];
347 parameter_dump_packet.sy_lfr_sc_rw_delta_f[BYTE_2] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + BYTE_2 ];
347 parameter_dump_packet.sy_lfr_sc_rw_delta_f[BYTE_2] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + BYTE_2 ];
348 parameter_dump_packet.sy_lfr_sc_rw_delta_f[BYTE_3] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + BYTE_3 ];
348 parameter_dump_packet.sy_lfr_sc_rw_delta_f[BYTE_3] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F + BYTE_3 ];
349
349
350 //****************************
350 //****************************
351 // store PAS filter parameters
351 // store PAS filter parameters
352 // sy_lfr_pas_filter_enabled
352 // sy_lfr_pas_filter_enabled
353 filterPar.spare_sy_lfr_pas_filter_enabled = parameter_dump_packet.spare_sy_lfr_pas_filter_enabled;
353 filterPar.spare_sy_lfr_pas_filter_enabled = parameter_dump_packet.spare_sy_lfr_pas_filter_enabled;
354 set_sy_lfr_pas_filter_enabled( parameter_dump_packet.spare_sy_lfr_pas_filter_enabled & BIT_PAS_FILTER_ENABLED );
354 set_sy_lfr_pas_filter_enabled( parameter_dump_packet.spare_sy_lfr_pas_filter_enabled & BIT_PAS_FILTER_ENABLED );
355 // sy_lfr_pas_filter_modulus
355 // sy_lfr_pas_filter_modulus
356 filterPar.sy_lfr_pas_filter_modulus = parameter_dump_packet.sy_lfr_pas_filter_modulus;
356 filterPar.sy_lfr_pas_filter_modulus = parameter_dump_packet.sy_lfr_pas_filter_modulus;
357 // sy_lfr_pas_filter_tbad
357 // sy_lfr_pas_filter_tbad
358 copyFloatByChar( (unsigned char*) &filterPar.sy_lfr_pas_filter_tbad,
358 copyFloatByChar( (unsigned char*) &filterPar.sy_lfr_pas_filter_tbad,
359 parameter_dump_packet.sy_lfr_pas_filter_tbad );
359 parameter_dump_packet.sy_lfr_pas_filter_tbad );
360 // sy_lfr_pas_filter_offset
360 // sy_lfr_pas_filter_offset
361 filterPar.sy_lfr_pas_filter_offset = parameter_dump_packet.sy_lfr_pas_filter_offset;
361 filterPar.sy_lfr_pas_filter_offset = parameter_dump_packet.sy_lfr_pas_filter_offset;
362 // sy_lfr_pas_filter_shift
362 // sy_lfr_pas_filter_shift
363 copyFloatByChar( (unsigned char*) &filterPar.sy_lfr_pas_filter_shift,
363 copyFloatByChar( (unsigned char*) &filterPar.sy_lfr_pas_filter_shift,
364 parameter_dump_packet.sy_lfr_pas_filter_shift );
364 parameter_dump_packet.sy_lfr_pas_filter_shift );
365
365
366 //****************************************************
366 //****************************************************
367 // store the parameter sy_lfr_sc_rw_delta_f as a float
367 // store the parameter sy_lfr_sc_rw_delta_f as a float
368 copyFloatByChar( (unsigned char*) &filterPar.sy_lfr_sc_rw_delta_f,
368 copyFloatByChar( (unsigned char*) &filterPar.sy_lfr_sc_rw_delta_f,
369 parameter_dump_packet.sy_lfr_sc_rw_delta_f );
369 parameter_dump_packet.sy_lfr_sc_rw_delta_f );
370 }
370 }
371
371
372 return flag;
372 return flag;
373 }
373 }
374
374
375 int action_dump_kcoefficients(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
375 int action_dump_kcoefficients(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time)
376 {
376 {
377 /** This function updates the LFR registers with the incoming sbm2 parameters.
377 /** This function updates the LFR registers with the incoming sbm2 parameters.
378 *
378 *
379 * @param TC points to the TeleCommand packet that is being processed
379 * @param TC points to the TeleCommand packet that is being processed
380 * @param queue_id is the id of the queue which handles TM related to this execution step
380 * @param queue_id is the id of the queue which handles TM related to this execution step
381 *
381 *
382 */
382 */
383
383
384 unsigned int address;
384 unsigned int address;
385 rtems_status_code status;
385 rtems_status_code status;
386 unsigned int freq;
386 unsigned int freq;
387 unsigned int bin;
387 unsigned int bin;
388 unsigned int coeff;
388 unsigned int coeff;
389 unsigned char *kCoeffPtr;
389 unsigned char *kCoeffPtr;
390 unsigned char *kCoeffDumpPtr;
390 unsigned char *kCoeffDumpPtr;
391
391
392 // for each sy_lfr_kcoeff_frequency there is 32 kcoeff
392 // for each sy_lfr_kcoeff_frequency there is 32 kcoeff
393 // F0 => 11 bins
393 // F0 => 11 bins
394 // F1 => 13 bins
394 // F1 => 13 bins
395 // F2 => 12 bins
395 // F2 => 12 bins
396 // 36 bins to dump in two packets (30 bins max per packet)
396 // 36 bins to dump in two packets (30 bins max per packet)
397
397
398 //*********
398 //*********
399 // PACKET 1
399 // PACKET 1
400 // 11 F0 bins, 13 F1 bins and 6 F2 bins
400 // 11 F0 bins, 13 F1 bins and 6 F2 bins
401 kcoefficients_dump_1.destinationID = TC->sourceID;
401 kcoefficients_dump_1.destinationID = TC->sourceID;
402 increment_seq_counter_destination_id_dump( kcoefficients_dump_1.packetSequenceControl, TC->sourceID );
402 increment_seq_counter_destination_id_dump( kcoefficients_dump_1.packetSequenceControl, TC->sourceID );
403 for( freq = 0;
403 for( freq = 0;
404 freq < NB_BINS_COMPRESSED_SM_F0;
404 freq < NB_BINS_COMPRESSED_SM_F0;
405 freq++ )
405 freq++ )
406 {
406 {
407 kcoefficients_dump_1.kcoeff_blks[ (freq*KCOEFF_BLK_SIZE) + 1] = freq;
407 kcoefficients_dump_1.kcoeff_blks[ (freq*KCOEFF_BLK_SIZE) + 1] = freq;
408 bin = freq;
408 bin = freq;
409 // printKCoefficients( freq, bin, k_coeff_intercalib_f0_norm);
409 // printKCoefficients( freq, bin, k_coeff_intercalib_f0_norm);
410 for ( coeff=0; coeff<NB_K_COEFF_PER_BIN; coeff++ )
410 for ( coeff=0; coeff<NB_K_COEFF_PER_BIN; coeff++ )
411 {
411 {
412 kCoeffDumpPtr = (unsigned char*) &kcoefficients_dump_1.kcoeff_blks[
412 kCoeffDumpPtr = (unsigned char*) &kcoefficients_dump_1.kcoeff_blks[
413 (freq*KCOEFF_BLK_SIZE) + (coeff*NB_BYTES_PER_FLOAT) + KCOEFF_FREQ
413 (freq*KCOEFF_BLK_SIZE) + (coeff*NB_BYTES_PER_FLOAT) + KCOEFF_FREQ
414 ]; // 2 for the kcoeff_frequency
414 ]; // 2 for the kcoeff_frequency
415 kCoeffPtr = (unsigned char*) &k_coeff_intercalib_f0_norm[ (bin*NB_K_COEFF_PER_BIN) + coeff ];
415 kCoeffPtr = (unsigned char*) &k_coeff_intercalib_f0_norm[ (bin*NB_K_COEFF_PER_BIN) + coeff ];
416 copyFloatByChar( kCoeffDumpPtr, kCoeffPtr );
416 copyFloatByChar( kCoeffDumpPtr, kCoeffPtr );
417 }
417 }
418 }
418 }
419 for( freq = NB_BINS_COMPRESSED_SM_F0;
419 for( freq = NB_BINS_COMPRESSED_SM_F0;
420 freq < ( NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1 );
420 freq < ( NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1 );
421 freq++ )
421 freq++ )
422 {
422 {
423 kcoefficients_dump_1.kcoeff_blks[ (freq*KCOEFF_BLK_SIZE) + 1 ] = freq;
423 kcoefficients_dump_1.kcoeff_blks[ (freq*KCOEFF_BLK_SIZE) + 1 ] = freq;
424 bin = freq - NB_BINS_COMPRESSED_SM_F0;
424 bin = freq - NB_BINS_COMPRESSED_SM_F0;
425 // printKCoefficients( freq, bin, k_coeff_intercalib_f1_norm);
425 // printKCoefficients( freq, bin, k_coeff_intercalib_f1_norm);
426 for ( coeff=0; coeff<NB_K_COEFF_PER_BIN; coeff++ )
426 for ( coeff=0; coeff<NB_K_COEFF_PER_BIN; coeff++ )
427 {
427 {
428 kCoeffDumpPtr = (unsigned char*) &kcoefficients_dump_1.kcoeff_blks[
428 kCoeffDumpPtr = (unsigned char*) &kcoefficients_dump_1.kcoeff_blks[
429 (freq*KCOEFF_BLK_SIZE) + (coeff*NB_BYTES_PER_FLOAT) + KCOEFF_FREQ
429 (freq*KCOEFF_BLK_SIZE) + (coeff*NB_BYTES_PER_FLOAT) + KCOEFF_FREQ
430 ]; // 2 for the kcoeff_frequency
430 ]; // 2 for the kcoeff_frequency
431 kCoeffPtr = (unsigned char*) &k_coeff_intercalib_f1_norm[ (bin*NB_K_COEFF_PER_BIN) + coeff ];
431 kCoeffPtr = (unsigned char*) &k_coeff_intercalib_f1_norm[ (bin*NB_K_COEFF_PER_BIN) + coeff ];
432 copyFloatByChar( kCoeffDumpPtr, kCoeffPtr );
432 copyFloatByChar( kCoeffDumpPtr, kCoeffPtr );
433 }
433 }
434 }
434 }
435 for( freq = ( NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1 );
435 for( freq = ( NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1 );
436 freq < KCOEFF_BLK_NR_PKT1 ;
436 freq < KCOEFF_BLK_NR_PKT1 ;
437 freq++ )
437 freq++ )
438 {
438 {
439 kcoefficients_dump_1.kcoeff_blks[ (freq * KCOEFF_BLK_SIZE) + 1 ] = freq;
439 kcoefficients_dump_1.kcoeff_blks[ (freq * KCOEFF_BLK_SIZE) + 1 ] = freq;
440 bin = freq - (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1);
440 bin = freq - (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1);
441 // printKCoefficients( freq, bin, k_coeff_intercalib_f2);
441 // printKCoefficients( freq, bin, k_coeff_intercalib_f2);
442 for ( coeff = 0; coeff <NB_K_COEFF_PER_BIN; coeff++ )
442 for ( coeff = 0; coeff <NB_K_COEFF_PER_BIN; coeff++ )
443 {
443 {
444 kCoeffDumpPtr = (unsigned char*) &kcoefficients_dump_1.kcoeff_blks[
444 kCoeffDumpPtr = (unsigned char*) &kcoefficients_dump_1.kcoeff_blks[
445 (freq * KCOEFF_BLK_SIZE) + (coeff * NB_BYTES_PER_FLOAT) + KCOEFF_FREQ
445 (freq * KCOEFF_BLK_SIZE) + (coeff * NB_BYTES_PER_FLOAT) + KCOEFF_FREQ
446 ]; // 2 for the kcoeff_frequency
446 ]; // 2 for the kcoeff_frequency
447 kCoeffPtr = (unsigned char*) &k_coeff_intercalib_f2[ (bin*NB_K_COEFF_PER_BIN) + coeff ];
447 kCoeffPtr = (unsigned char*) &k_coeff_intercalib_f2[ (bin*NB_K_COEFF_PER_BIN) + coeff ];
448 copyFloatByChar( kCoeffDumpPtr, kCoeffPtr );
448 copyFloatByChar( kCoeffDumpPtr, kCoeffPtr );
449 }
449 }
450 }
450 }
451 kcoefficients_dump_1.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
451 kcoefficients_dump_1.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
452 kcoefficients_dump_1.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
452 kcoefficients_dump_1.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
453 kcoefficients_dump_1.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
453 kcoefficients_dump_1.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
454 kcoefficients_dump_1.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
454 kcoefficients_dump_1.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
455 kcoefficients_dump_1.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
455 kcoefficients_dump_1.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
456 kcoefficients_dump_1.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
456 kcoefficients_dump_1.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
457 // SEND DATA
457 // SEND DATA
458 kcoefficient_node_1.status = 1;
458 kcoefficient_node_1.status = 1;
459 address = (unsigned int) &kcoefficient_node_1;
459 address = (unsigned int) &kcoefficient_node_1;
460 status = rtems_message_queue_send( queue_id, &address, sizeof( ring_node* ) );
460 status = rtems_message_queue_send( queue_id, &address, sizeof( ring_node* ) );
461 if (status != RTEMS_SUCCESSFUL) {
461 if (status != RTEMS_SUCCESSFUL) {
462 PRINTF1("in action_dump_kcoefficients *** ERR sending packet 1 , code %d", status)
462 PRINTF1("in action_dump_kcoefficients *** ERR sending packet 1 , code %d", status)
463 }
463 }
464
464
465 //********
465 //********
466 // PACKET 2
466 // PACKET 2
467 // 6 F2 bins
467 // 6 F2 bins
468 kcoefficients_dump_2.destinationID = TC->sourceID;
468 kcoefficients_dump_2.destinationID = TC->sourceID;
469 increment_seq_counter_destination_id_dump( kcoefficients_dump_2.packetSequenceControl, TC->sourceID );
469 increment_seq_counter_destination_id_dump( kcoefficients_dump_2.packetSequenceControl, TC->sourceID );
470 for( freq = 0;
470 for( freq = 0;
471 freq < KCOEFF_BLK_NR_PKT2;
471 freq < KCOEFF_BLK_NR_PKT2;
472 freq++ )
472 freq++ )
473 {
473 {
474 kcoefficients_dump_2.kcoeff_blks[ (freq*KCOEFF_BLK_SIZE) + 1 ] = KCOEFF_BLK_NR_PKT1 + freq;
474 kcoefficients_dump_2.kcoeff_blks[ (freq*KCOEFF_BLK_SIZE) + 1 ] = KCOEFF_BLK_NR_PKT1 + freq;
475 bin = freq + KCOEFF_BLK_NR_PKT2;
475 bin = freq + KCOEFF_BLK_NR_PKT2;
476 // printKCoefficients( freq, bin, k_coeff_intercalib_f2);
476 // printKCoefficients( freq, bin, k_coeff_intercalib_f2);
477 for ( coeff=0; coeff<NB_K_COEFF_PER_BIN; coeff++ )
477 for ( coeff=0; coeff<NB_K_COEFF_PER_BIN; coeff++ )
478 {
478 {
479 kCoeffDumpPtr = (unsigned char*) &kcoefficients_dump_2.kcoeff_blks[
479 kCoeffDumpPtr = (unsigned char*) &kcoefficients_dump_2.kcoeff_blks[
480 (freq*KCOEFF_BLK_SIZE) + (coeff*NB_BYTES_PER_FLOAT) + KCOEFF_FREQ ]; // 2 for the kcoeff_frequency
480 (freq*KCOEFF_BLK_SIZE) + (coeff*NB_BYTES_PER_FLOAT) + KCOEFF_FREQ ]; // 2 for the kcoeff_frequency
481 kCoeffPtr = (unsigned char*) &k_coeff_intercalib_f2[ (bin*NB_K_COEFF_PER_BIN) + coeff ];
481 kCoeffPtr = (unsigned char*) &k_coeff_intercalib_f2[ (bin*NB_K_COEFF_PER_BIN) + coeff ];
482 copyFloatByChar( kCoeffDumpPtr, kCoeffPtr );
482 copyFloatByChar( kCoeffDumpPtr, kCoeffPtr );
483 }
483 }
484 }
484 }
485 kcoefficients_dump_2.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
485 kcoefficients_dump_2.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
486 kcoefficients_dump_2.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
486 kcoefficients_dump_2.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
487 kcoefficients_dump_2.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
487 kcoefficients_dump_2.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
488 kcoefficients_dump_2.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
488 kcoefficients_dump_2.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
489 kcoefficients_dump_2.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
489 kcoefficients_dump_2.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
490 kcoefficients_dump_2.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
490 kcoefficients_dump_2.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
491 // SEND DATA
491 // SEND DATA
492 kcoefficient_node_2.status = 1;
492 kcoefficient_node_2.status = 1;
493 address = (unsigned int) &kcoefficient_node_2;
493 address = (unsigned int) &kcoefficient_node_2;
494 status = rtems_message_queue_send( queue_id, &address, sizeof( ring_node* ) );
494 status = rtems_message_queue_send( queue_id, &address, sizeof( ring_node* ) );
495 if (status != RTEMS_SUCCESSFUL) {
495 if (status != RTEMS_SUCCESSFUL) {
496 PRINTF1("in action_dump_kcoefficients *** ERR sending packet 2, code %d", status)
496 PRINTF1("in action_dump_kcoefficients *** ERR sending packet 2, code %d", status)
497 }
497 }
498
498
499 return status;
499 return status;
500 }
500 }
501
501
502 int action_dump_par( ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
502 int action_dump_par( ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
503 {
503 {
504 /** This function dumps the LFR parameters by sending the appropriate TM packet to the dedicated RTEMS message queue.
504 /** This function dumps the LFR parameters by sending the appropriate TM packet to the dedicated RTEMS message queue.
505 *
505 *
506 * @param queue_id is the id of the queue which handles TM related to this execution step.
506 * @param queue_id is the id of the queue which handles TM related to this execution step.
507 *
507 *
508 * @return RTEMS directive status codes:
508 * @return RTEMS directive status codes:
509 * - RTEMS_SUCCESSFUL - message sent successfully
509 * - RTEMS_SUCCESSFUL - message sent successfully
510 * - RTEMS_INVALID_ID - invalid queue id
510 * - RTEMS_INVALID_ID - invalid queue id
511 * - RTEMS_INVALID_SIZE - invalid message size
511 * - RTEMS_INVALID_SIZE - invalid message size
512 * - RTEMS_INVALID_ADDRESS - buffer is NULL
512 * - RTEMS_INVALID_ADDRESS - buffer is NULL
513 * - RTEMS_UNSATISFIED - out of message buffers
513 * - RTEMS_UNSATISFIED - out of message buffers
514 * - RTEMS_TOO_MANY - queue s limit has been reached
514 * - RTEMS_TOO_MANY - queue s limit has been reached
515 *
515 *
516 */
516 */
517
517
518 int status;
518 int status;
519
519
520 increment_seq_counter_destination_id_dump( parameter_dump_packet.packetSequenceControl, TC->sourceID );
520 increment_seq_counter_destination_id_dump( parameter_dump_packet.packetSequenceControl, TC->sourceID );
521 parameter_dump_packet.destinationID = TC->sourceID;
521 parameter_dump_packet.destinationID = TC->sourceID;
522
522
523 // UPDATE TIME
523 // UPDATE TIME
524 parameter_dump_packet.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
524 parameter_dump_packet.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
525 parameter_dump_packet.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
525 parameter_dump_packet.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
526 parameter_dump_packet.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
526 parameter_dump_packet.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
527 parameter_dump_packet.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
527 parameter_dump_packet.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
528 parameter_dump_packet.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
528 parameter_dump_packet.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
529 parameter_dump_packet.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
529 parameter_dump_packet.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
530 // SEND DATA
530 // SEND DATA
531 status = rtems_message_queue_send( queue_id, &parameter_dump_packet,
531 status = rtems_message_queue_send( queue_id, &parameter_dump_packet,
532 PACKET_LENGTH_PARAMETER_DUMP + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES);
532 PACKET_LENGTH_PARAMETER_DUMP + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES);
533 if (status != RTEMS_SUCCESSFUL) {
533 if (status != RTEMS_SUCCESSFUL) {
534 PRINTF1("in action_dump *** ERR sending packet, code %d", status)
534 PRINTF1("in action_dump *** ERR sending packet, code %d", status)
535 }
535 }
536
536
537 return status;
537 return status;
538 }
538 }
539
539
540 //***********************
540 //***********************
541 // NORMAL MODE PARAMETERS
541 // NORMAL MODE PARAMETERS
542
542
543 int check_normal_par_consistency( ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
543 int check_normal_par_consistency( ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
544 {
544 {
545 unsigned char msb;
545 unsigned char msb;
546 unsigned char lsb;
546 unsigned char lsb;
547 int flag;
547 int flag;
548 float aux;
548 float aux;
549 rtems_status_code status;
549 rtems_status_code status;
550
550
551 unsigned int sy_lfr_n_swf_l;
551 unsigned int sy_lfr_n_swf_l;
552 unsigned int sy_lfr_n_swf_p;
552 unsigned int sy_lfr_n_swf_p;
553 unsigned int sy_lfr_n_asm_p;
553 unsigned int sy_lfr_n_asm_p;
554 unsigned char sy_lfr_n_bp_p0;
554 unsigned char sy_lfr_n_bp_p0;
555 unsigned char sy_lfr_n_bp_p1;
555 unsigned char sy_lfr_n_bp_p1;
556 unsigned char sy_lfr_n_cwf_long_f3;
556 unsigned char sy_lfr_n_cwf_long_f3;
557
557
558 flag = LFR_SUCCESSFUL;
558 flag = LFR_SUCCESSFUL;
559
559
560 //***************
560 //***************
561 // get parameters
561 // get parameters
562 msb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L ];
562 msb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L ];
563 lsb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L+1 ];
563 lsb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L+1 ];
564 sy_lfr_n_swf_l = (msb * CONST_256) + lsb;
564 sy_lfr_n_swf_l = (msb * CONST_256) + lsb;
565
565
566 msb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P ];
566 msb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P ];
567 lsb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P+1 ];
567 lsb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P+1 ];
568 sy_lfr_n_swf_p = (msb * CONST_256) + lsb;
568 sy_lfr_n_swf_p = (msb * CONST_256) + lsb;
569
569
570 msb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P ];
570 msb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P ];
571 lsb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P+1 ];
571 lsb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P+1 ];
572 sy_lfr_n_asm_p = (msb * CONST_256) + lsb;
572 sy_lfr_n_asm_p = (msb * CONST_256) + lsb;
573
573
574 sy_lfr_n_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P0 ];
574 sy_lfr_n_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P0 ];
575
575
576 sy_lfr_n_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P1 ];
576 sy_lfr_n_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P1 ];
577
577
578 sy_lfr_n_cwf_long_f3 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_CWF_LONG_F3 ];
578 sy_lfr_n_cwf_long_f3 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_CWF_LONG_F3 ];
579
579
580 //******************
580 //******************
581 // check consistency
581 // check consistency
582 // sy_lfr_n_swf_l
582 // sy_lfr_n_swf_l
583 if (sy_lfr_n_swf_l != DFLT_SY_LFR_N_SWF_L)
583 if (sy_lfr_n_swf_l != DFLT_SY_LFR_N_SWF_L)
584 {
584 {
585 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_SWF_L + DATAFIELD_OFFSET, sy_lfr_n_swf_l );
585 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_SWF_L + DATAFIELD_OFFSET, sy_lfr_n_swf_l );
586 flag = WRONG_APP_DATA;
586 flag = WRONG_APP_DATA;
587 }
587 }
588 // sy_lfr_n_swf_p
588 // sy_lfr_n_swf_p
589 if (flag == LFR_SUCCESSFUL)
589 if (flag == LFR_SUCCESSFUL)
590 {
590 {
591 if ( sy_lfr_n_swf_p < MIN_SY_LFR_N_SWF_P )
591 if ( sy_lfr_n_swf_p < MIN_SY_LFR_N_SWF_P )
592 {
592 {
593 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_SWF_P + DATAFIELD_OFFSET, sy_lfr_n_swf_p );
593 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_SWF_P + DATAFIELD_OFFSET, sy_lfr_n_swf_p );
594 flag = WRONG_APP_DATA;
594 flag = WRONG_APP_DATA;
595 }
595 }
596 }
596 }
597 // sy_lfr_n_bp_p0
597 // sy_lfr_n_bp_p0
598 if (flag == LFR_SUCCESSFUL)
598 if (flag == LFR_SUCCESSFUL)
599 {
599 {
600 if (sy_lfr_n_bp_p0 < DFLT_SY_LFR_N_BP_P0)
600 if (sy_lfr_n_bp_p0 < DFLT_SY_LFR_N_BP_P0)
601 {
601 {
602 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_BP_P0 + DATAFIELD_OFFSET, sy_lfr_n_bp_p0 );
602 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_BP_P0 + DATAFIELD_OFFSET, sy_lfr_n_bp_p0 );
603 flag = WRONG_APP_DATA;
603 flag = WRONG_APP_DATA;
604 }
604 }
605 }
605 }
606 // sy_lfr_n_asm_p
606 // sy_lfr_n_asm_p
607 if (flag == LFR_SUCCESSFUL)
607 if (flag == LFR_SUCCESSFUL)
608 {
608 {
609 if (sy_lfr_n_asm_p == 0)
609 if (sy_lfr_n_asm_p == 0)
610 {
610 {
611 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_ASM_P + DATAFIELD_OFFSET, sy_lfr_n_asm_p );
611 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_ASM_P + DATAFIELD_OFFSET, sy_lfr_n_asm_p );
612 flag = WRONG_APP_DATA;
612 flag = WRONG_APP_DATA;
613 }
613 }
614 }
614 }
615 // sy_lfr_n_asm_p shall be a whole multiple of sy_lfr_n_bp_p0
615 // sy_lfr_n_asm_p shall be a whole multiple of sy_lfr_n_bp_p0
616 if (flag == LFR_SUCCESSFUL)
616 if (flag == LFR_SUCCESSFUL)
617 {
617 {
618 aux = ( (float ) sy_lfr_n_asm_p / sy_lfr_n_bp_p0 ) - floor(sy_lfr_n_asm_p / sy_lfr_n_bp_p0);
618 aux = ( (float ) sy_lfr_n_asm_p / sy_lfr_n_bp_p0 ) - floor(sy_lfr_n_asm_p / sy_lfr_n_bp_p0);
619 if (aux > FLOAT_EQUAL_ZERO)
619 if (aux > FLOAT_EQUAL_ZERO)
620 {
620 {
621 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_ASM_P + DATAFIELD_OFFSET, sy_lfr_n_asm_p );
621 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_ASM_P + DATAFIELD_OFFSET, sy_lfr_n_asm_p );
622 flag = WRONG_APP_DATA;
622 flag = WRONG_APP_DATA;
623 }
623 }
624 }
624 }
625 // sy_lfr_n_bp_p1
625 // sy_lfr_n_bp_p1
626 if (flag == LFR_SUCCESSFUL)
626 if (flag == LFR_SUCCESSFUL)
627 {
627 {
628 if (sy_lfr_n_bp_p1 < DFLT_SY_LFR_N_BP_P1)
628 if (sy_lfr_n_bp_p1 < DFLT_SY_LFR_N_BP_P1)
629 {
629 {
630 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_BP_P1 + DATAFIELD_OFFSET, sy_lfr_n_bp_p1 );
630 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_BP_P1 + DATAFIELD_OFFSET, sy_lfr_n_bp_p1 );
631 flag = WRONG_APP_DATA;
631 flag = WRONG_APP_DATA;
632 }
632 }
633 }
633 }
634 // sy_lfr_n_bp_p1 shall be a whole multiple of sy_lfr_n_bp_p0
634 // sy_lfr_n_bp_p1 shall be a whole multiple of sy_lfr_n_bp_p0
635 if (flag == LFR_SUCCESSFUL)
635 if (flag == LFR_SUCCESSFUL)
636 {
636 {
637 aux = ( (float ) sy_lfr_n_bp_p1 / sy_lfr_n_bp_p0 ) - floor(sy_lfr_n_bp_p1 / sy_lfr_n_bp_p0);
637 aux = ( (float ) sy_lfr_n_bp_p1 / sy_lfr_n_bp_p0 ) - floor(sy_lfr_n_bp_p1 / sy_lfr_n_bp_p0);
638 if (aux > FLOAT_EQUAL_ZERO)
638 if (aux > FLOAT_EQUAL_ZERO)
639 {
639 {
640 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_BP_P1 + DATAFIELD_OFFSET, sy_lfr_n_bp_p1 );
640 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_BP_P1 + DATAFIELD_OFFSET, sy_lfr_n_bp_p1 );
641 flag = LFR_DEFAULT;
641 flag = LFR_DEFAULT;
642 }
642 }
643 }
643 }
644 // sy_lfr_n_cwf_long_f3
644 // sy_lfr_n_cwf_long_f3
645
645
646 return flag;
646 return flag;
647 }
647 }
648
648
649 int set_sy_lfr_n_swf_l( ccsdsTelecommandPacket_t *TC )
649 int set_sy_lfr_n_swf_l( ccsdsTelecommandPacket_t *TC )
650 {
650 {
651 /** This function sets the number of points of a snapshot (sy_lfr_n_swf_l).
651 /** This function sets the number of points of a snapshot (sy_lfr_n_swf_l).
652 *
652 *
653 * @param TC points to the TeleCommand packet that is being processed
653 * @param TC points to the TeleCommand packet that is being processed
654 * @param queue_id is the id of the queue which handles TM related to this execution step
654 * @param queue_id is the id of the queue which handles TM related to this execution step
655 *
655 *
656 */
656 */
657
657
658 int result;
658 int result;
659
659
660 result = LFR_SUCCESSFUL;
660 result = LFR_SUCCESSFUL;
661
661
662 parameter_dump_packet.sy_lfr_n_swf_l[0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L ];
662 parameter_dump_packet.sy_lfr_n_swf_l[0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L ];
663 parameter_dump_packet.sy_lfr_n_swf_l[1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L+1 ];
663 parameter_dump_packet.sy_lfr_n_swf_l[1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L+1 ];
664
664
665 return result;
665 return result;
666 }
666 }
667
667
668 int set_sy_lfr_n_swf_p(ccsdsTelecommandPacket_t *TC )
668 int set_sy_lfr_n_swf_p(ccsdsTelecommandPacket_t *TC )
669 {
669 {
670 /** This function sets the time between two snapshots, in s (sy_lfr_n_swf_p).
670 /** This function sets the time between two snapshots, in s (sy_lfr_n_swf_p).
671 *
671 *
672 * @param TC points to the TeleCommand packet that is being processed
672 * @param TC points to the TeleCommand packet that is being processed
673 * @param queue_id is the id of the queue which handles TM related to this execution step
673 * @param queue_id is the id of the queue which handles TM related to this execution step
674 *
674 *
675 */
675 */
676
676
677 int result;
677 int result;
678
678
679 result = LFR_SUCCESSFUL;
679 result = LFR_SUCCESSFUL;
680
680
681 parameter_dump_packet.sy_lfr_n_swf_p[0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P ];
681 parameter_dump_packet.sy_lfr_n_swf_p[0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P ];
682 parameter_dump_packet.sy_lfr_n_swf_p[1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P+1 ];
682 parameter_dump_packet.sy_lfr_n_swf_p[1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P+1 ];
683
683
684 return result;
684 return result;
685 }
685 }
686
686
687 int set_sy_lfr_n_asm_p( ccsdsTelecommandPacket_t *TC )
687 int set_sy_lfr_n_asm_p( ccsdsTelecommandPacket_t *TC )
688 {
688 {
689 /** This function sets the time between two full spectral matrices transmission, in s (SY_LFR_N_ASM_P).
689 /** This function sets the time between two full spectral matrices transmission, in s (SY_LFR_N_ASM_P).
690 *
690 *
691 * @param TC points to the TeleCommand packet that is being processed
691 * @param TC points to the TeleCommand packet that is being processed
692 * @param queue_id is the id of the queue which handles TM related to this execution step
692 * @param queue_id is the id of the queue which handles TM related to this execution step
693 *
693 *
694 */
694 */
695
695
696 int result;
696 int result;
697
697
698 result = LFR_SUCCESSFUL;
698 result = LFR_SUCCESSFUL;
699
699
700 parameter_dump_packet.sy_lfr_n_asm_p[0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P ];
700 parameter_dump_packet.sy_lfr_n_asm_p[0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P ];
701 parameter_dump_packet.sy_lfr_n_asm_p[1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P+1 ];
701 parameter_dump_packet.sy_lfr_n_asm_p[1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P+1 ];
702
702
703 return result;
703 return result;
704 }
704 }
705
705
706 int set_sy_lfr_n_bp_p0( ccsdsTelecommandPacket_t *TC )
706 int set_sy_lfr_n_bp_p0( ccsdsTelecommandPacket_t *TC )
707 {
707 {
708 /** This function sets the time between two basic parameter sets, in s (DFLT_SY_LFR_N_BP_P0).
708 /** This function sets the time between two basic parameter sets, in s (DFLT_SY_LFR_N_BP_P0).
709 *
709 *
710 * @param TC points to the TeleCommand packet that is being processed
710 * @param TC points to the TeleCommand packet that is being processed
711 * @param queue_id is the id of the queue which handles TM related to this execution step
711 * @param queue_id is the id of the queue which handles TM related to this execution step
712 *
712 *
713 */
713 */
714
714
715 int status;
715 int status;
716
716
717 status = LFR_SUCCESSFUL;
717 status = LFR_SUCCESSFUL;
718
718
719 parameter_dump_packet.sy_lfr_n_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P0 ];
719 parameter_dump_packet.sy_lfr_n_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P0 ];
720
720
721 return status;
721 return status;
722 }
722 }
723
723
724 int set_sy_lfr_n_bp_p1(ccsdsTelecommandPacket_t *TC )
724 int set_sy_lfr_n_bp_p1(ccsdsTelecommandPacket_t *TC )
725 {
725 {
726 /** This function sets the time between two basic parameter sets (autocorrelation + crosscorrelation), in s (sy_lfr_n_bp_p1).
726 /** This function sets the time between two basic parameter sets (autocorrelation + crosscorrelation), in s (sy_lfr_n_bp_p1).
727 *
727 *
728 * @param TC points to the TeleCommand packet that is being processed
728 * @param TC points to the TeleCommand packet that is being processed
729 * @param queue_id is the id of the queue which handles TM related to this execution step
729 * @param queue_id is the id of the queue which handles TM related to this execution step
730 *
730 *
731 */
731 */
732
732
733 int status;
733 int status;
734
734
735 status = LFR_SUCCESSFUL;
735 status = LFR_SUCCESSFUL;
736
736
737 parameter_dump_packet.sy_lfr_n_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P1 ];
737 parameter_dump_packet.sy_lfr_n_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P1 ];
738
738
739 return status;
739 return status;
740 }
740 }
741
741
742 int set_sy_lfr_n_cwf_long_f3(ccsdsTelecommandPacket_t *TC )
742 int set_sy_lfr_n_cwf_long_f3(ccsdsTelecommandPacket_t *TC )
743 {
743 {
744 /** This function allows to switch from CWF_F3 packets to CWF_LONG_F3 packets.
744 /** This function allows to switch from CWF_F3 packets to CWF_LONG_F3 packets.
745 *
745 *
746 * @param TC points to the TeleCommand packet that is being processed
746 * @param TC points to the TeleCommand packet that is being processed
747 * @param queue_id is the id of the queue which handles TM related to this execution step
747 * @param queue_id is the id of the queue which handles TM related to this execution step
748 *
748 *
749 */
749 */
750
750
751 int status;
751 int status;
752
752
753 status = LFR_SUCCESSFUL;
753 status = LFR_SUCCESSFUL;
754
754
755 parameter_dump_packet.sy_lfr_n_cwf_long_f3 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_CWF_LONG_F3 ];
755 parameter_dump_packet.sy_lfr_n_cwf_long_f3 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_CWF_LONG_F3 ];
756
756
757 return status;
757 return status;
758 }
758 }
759
759
760 //**********************
760 //**********************
761 // BURST MODE PARAMETERS
761 // BURST MODE PARAMETERS
762 int set_sy_lfr_b_bp_p0(ccsdsTelecommandPacket_t *TC)
762 int set_sy_lfr_b_bp_p0(ccsdsTelecommandPacket_t *TC)
763 {
763 {
764 /** This function sets the time between two basic parameter sets, in s (SY_LFR_B_BP_P0).
764 /** This function sets the time between two basic parameter sets, in s (SY_LFR_B_BP_P0).
765 *
765 *
766 * @param TC points to the TeleCommand packet that is being processed
766 * @param TC points to the TeleCommand packet that is being processed
767 * @param queue_id is the id of the queue which handles TM related to this execution step
767 * @param queue_id is the id of the queue which handles TM related to this execution step
768 *
768 *
769 */
769 */
770
770
771 int status;
771 int status;
772
772
773 status = LFR_SUCCESSFUL;
773 status = LFR_SUCCESSFUL;
774
774
775 parameter_dump_packet.sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ];
775 parameter_dump_packet.sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ];
776
776
777 return status;
777 return status;
778 }
778 }
779
779
780 int set_sy_lfr_b_bp_p1( ccsdsTelecommandPacket_t *TC )
780 int set_sy_lfr_b_bp_p1( ccsdsTelecommandPacket_t *TC )
781 {
781 {
782 /** This function sets the time between two basic parameter sets, in s (SY_LFR_B_BP_P1).
782 /** This function sets the time between two basic parameter sets, in s (SY_LFR_B_BP_P1).
783 *
783 *
784 * @param TC points to the TeleCommand packet that is being processed
784 * @param TC points to the TeleCommand packet that is being processed
785 * @param queue_id is the id of the queue which handles TM related to this execution step
785 * @param queue_id is the id of the queue which handles TM related to this execution step
786 *
786 *
787 */
787 */
788
788
789 int status;
789 int status;
790
790
791 status = LFR_SUCCESSFUL;
791 status = LFR_SUCCESSFUL;
792
792
793 parameter_dump_packet.sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ];
793 parameter_dump_packet.sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ];
794
794
795 return status;
795 return status;
796 }
796 }
797
797
798 //*********************
798 //*********************
799 // SBM1 MODE PARAMETERS
799 // SBM1 MODE PARAMETERS
800 int set_sy_lfr_s1_bp_p0( ccsdsTelecommandPacket_t *TC )
800 int set_sy_lfr_s1_bp_p0( ccsdsTelecommandPacket_t *TC )
801 {
801 {
802 /** This function sets the time between two basic parameter sets, in s (SY_LFR_S1_BP_P0).
802 /** This function sets the time between two basic parameter sets, in s (SY_LFR_S1_BP_P0).
803 *
803 *
804 * @param TC points to the TeleCommand packet that is being processed
804 * @param TC points to the TeleCommand packet that is being processed
805 * @param queue_id is the id of the queue which handles TM related to this execution step
805 * @param queue_id is the id of the queue which handles TM related to this execution step
806 *
806 *
807 */
807 */
808
808
809 int status;
809 int status;
810
810
811 status = LFR_SUCCESSFUL;
811 status = LFR_SUCCESSFUL;
812
812
813 parameter_dump_packet.sy_lfr_s1_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P0 ];
813 parameter_dump_packet.sy_lfr_s1_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P0 ];
814
814
815 return status;
815 return status;
816 }
816 }
817
817
818 int set_sy_lfr_s1_bp_p1( ccsdsTelecommandPacket_t *TC )
818 int set_sy_lfr_s1_bp_p1( ccsdsTelecommandPacket_t *TC )
819 {
819 {
820 /** This function sets the time between two basic parameter sets, in s (SY_LFR_S1_BP_P1).
820 /** This function sets the time between two basic parameter sets, in s (SY_LFR_S1_BP_P1).
821 *
821 *
822 * @param TC points to the TeleCommand packet that is being processed
822 * @param TC points to the TeleCommand packet that is being processed
823 * @param queue_id is the id of the queue which handles TM related to this execution step
823 * @param queue_id is the id of the queue which handles TM related to this execution step
824 *
824 *
825 */
825 */
826
826
827 int status;
827 int status;
828
828
829 status = LFR_SUCCESSFUL;
829 status = LFR_SUCCESSFUL;
830
830
831 parameter_dump_packet.sy_lfr_s1_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P1 ];
831 parameter_dump_packet.sy_lfr_s1_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P1 ];
832
832
833 return status;
833 return status;
834 }
834 }
835
835
836 //*********************
836 //*********************
837 // SBM2 MODE PARAMETERS
837 // SBM2 MODE PARAMETERS
838 int set_sy_lfr_s2_bp_p0( ccsdsTelecommandPacket_t *TC )
838 int set_sy_lfr_s2_bp_p0( ccsdsTelecommandPacket_t *TC )
839 {
839 {
840 /** This function sets the time between two basic parameter sets, in s (SY_LFR_S2_BP_P0).
840 /** This function sets the time between two basic parameter sets, in s (SY_LFR_S2_BP_P0).
841 *
841 *
842 * @param TC points to the TeleCommand packet that is being processed
842 * @param TC points to the TeleCommand packet that is being processed
843 * @param queue_id is the id of the queue which handles TM related to this execution step
843 * @param queue_id is the id of the queue which handles TM related to this execution step
844 *
844 *
845 */
845 */
846
846
847 int status;
847 int status;
848
848
849 status = LFR_SUCCESSFUL;
849 status = LFR_SUCCESSFUL;
850
850
851 parameter_dump_packet.sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ];
851 parameter_dump_packet.sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ];
852
852
853 return status;
853 return status;
854 }
854 }
855
855
856 int set_sy_lfr_s2_bp_p1( ccsdsTelecommandPacket_t *TC )
856 int set_sy_lfr_s2_bp_p1( ccsdsTelecommandPacket_t *TC )
857 {
857 {
858 /** This function sets the time between two basic parameter sets, in s (SY_LFR_S2_BP_P1).
858 /** This function sets the time between two basic parameter sets, in s (SY_LFR_S2_BP_P1).
859 *
859 *
860 * @param TC points to the TeleCommand packet that is being processed
860 * @param TC points to the TeleCommand packet that is being processed
861 * @param queue_id is the id of the queue which handles TM related to this execution step
861 * @param queue_id is the id of the queue which handles TM related to this execution step
862 *
862 *
863 */
863 */
864
864
865 int status;
865 int status;
866
866
867 status = LFR_SUCCESSFUL;
867 status = LFR_SUCCESSFUL;
868
868
869 parameter_dump_packet.sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ];
869 parameter_dump_packet.sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ];
870
870
871 return status;
871 return status;
872 }
872 }
873
873
874 //*******************
874 //*******************
875 // TC_LFR_UPDATE_INFO
875 // TC_LFR_UPDATE_INFO
876 unsigned int check_update_info_hk_lfr_mode( unsigned char mode )
876 unsigned int check_update_info_hk_lfr_mode( unsigned char mode )
877 {
877 {
878 unsigned int status;
878 unsigned int status;
879
879
880 status = LFR_DEFAULT;
880 status = LFR_DEFAULT;
881
881
882 if ( (mode == LFR_MODE_STANDBY) || (mode == LFR_MODE_NORMAL)
882 if ( (mode == LFR_MODE_STANDBY) || (mode == LFR_MODE_NORMAL)
883 || (mode == LFR_MODE_BURST)
883 || (mode == LFR_MODE_BURST)
884 || (mode == LFR_MODE_SBM1) || (mode == LFR_MODE_SBM2))
884 || (mode == LFR_MODE_SBM1) || (mode == LFR_MODE_SBM2))
885 {
885 {
886 status = LFR_SUCCESSFUL;
886 status = LFR_SUCCESSFUL;
887 }
887 }
888 else
888 else
889 {
889 {
890 status = LFR_DEFAULT;
890 status = LFR_DEFAULT;
891 }
891 }
892
892
893 return status;
893 return status;
894 }
894 }
895
895
896 unsigned int check_update_info_hk_tds_mode( unsigned char mode )
896 unsigned int check_update_info_hk_tds_mode( unsigned char mode )
897 {
897 {
898 unsigned int status;
898 unsigned int status;
899
899
900 status = LFR_DEFAULT;
900 status = LFR_DEFAULT;
901
901
902 if ( (mode == TDS_MODE_STANDBY) || (mode == TDS_MODE_NORMAL)
902 if ( (mode == TDS_MODE_STANDBY) || (mode == TDS_MODE_NORMAL)
903 || (mode == TDS_MODE_BURST)
903 || (mode == TDS_MODE_BURST)
904 || (mode == TDS_MODE_SBM1) || (mode == TDS_MODE_SBM2)
904 || (mode == TDS_MODE_SBM1) || (mode == TDS_MODE_SBM2)
905 || (mode == TDS_MODE_LFM))
905 || (mode == TDS_MODE_LFM))
906 {
906 {
907 status = LFR_SUCCESSFUL;
907 status = LFR_SUCCESSFUL;
908 }
908 }
909 else
909 else
910 {
910 {
911 status = LFR_DEFAULT;
911 status = LFR_DEFAULT;
912 }
912 }
913
913
914 return status;
914 return status;
915 }
915 }
916
916
917 unsigned int check_update_info_hk_thr_mode( unsigned char mode )
917 unsigned int check_update_info_hk_thr_mode( unsigned char mode )
918 {
918 {
919 unsigned int status;
919 unsigned int status;
920
920
921 status = LFR_DEFAULT;
921 status = LFR_DEFAULT;
922
922
923 if ( (mode == THR_MODE_STANDBY) || (mode == THR_MODE_NORMAL)
923 if ( (mode == THR_MODE_STANDBY) || (mode == THR_MODE_NORMAL)
924 || (mode == THR_MODE_BURST))
924 || (mode == THR_MODE_BURST))
925 {
925 {
926 status = LFR_SUCCESSFUL;
926 status = LFR_SUCCESSFUL;
927 }
927 }
928 else
928 else
929 {
929 {
930 status = LFR_DEFAULT;
930 status = LFR_DEFAULT;
931 }
931 }
932
932
933 return status;
933 return status;
934 }
934 }
935
935
936 void getReactionWheelsFrequencies( ccsdsTelecommandPacket_t *TC )
936 void getReactionWheelsFrequencies( ccsdsTelecommandPacket_t *TC )
937 {
937 {
938 /** This function get the reaction wheels frequencies in the incoming TC_LFR_UPDATE_INFO and copy the values locally.
938 /** This function get the reaction wheels frequencies in the incoming TC_LFR_UPDATE_INFO and copy the values locally.
939 *
939 *
940 * @param TC points to the TeleCommand packet that is being processed
940 * @param TC points to the TeleCommand packet that is being processed
941 *
941 *
942 */
942 */
943
943
944 unsigned char * bytePosPtr; // pointer to the beginning of the incoming TC packet
944 unsigned char * bytePosPtr; // pointer to the beginning of the incoming TC packet
945
945
946 bytePosPtr = (unsigned char *) &TC->packetID;
946 bytePosPtr = (unsigned char *) &TC->packetID;
947
947
948 // cp_rpw_sc_rw1_f1
948 // cp_rpw_sc_rw1_f1
949 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw1_f1,
949 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw1_f1,
950 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW1_F1 ] );
950 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW1_F1 ] );
951
951
952 // cp_rpw_sc_rw1_f2
952 // cp_rpw_sc_rw1_f2
953 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw1_f2,
953 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw1_f2,
954 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW1_F2 ] );
954 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW1_F2 ] );
955
955
956 // cp_rpw_sc_rw2_f1
956 // cp_rpw_sc_rw2_f1
957 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw2_f1,
957 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw2_f1,
958 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW2_F1 ] );
958 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW2_F1 ] );
959
959
960 // cp_rpw_sc_rw2_f2
960 // cp_rpw_sc_rw2_f2
961 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw2_f2,
961 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw2_f2,
962 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW2_F2 ] );
962 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW2_F2 ] );
963
963
964 // cp_rpw_sc_rw3_f1
964 // cp_rpw_sc_rw3_f1
965 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw3_f1,
965 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw3_f1,
966 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW3_F1 ] );
966 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW3_F1 ] );
967
967
968 // cp_rpw_sc_rw3_f2
968 // cp_rpw_sc_rw3_f2
969 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw3_f2,
969 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw3_f2,
970 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW3_F2 ] );
970 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW3_F2 ] );
971
971
972 // cp_rpw_sc_rw4_f1
972 // cp_rpw_sc_rw4_f1
973 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw4_f1,
973 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw4_f1,
974 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW4_F1 ] );
974 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW4_F1 ] );
975
975
976 // cp_rpw_sc_rw4_f2
976 // cp_rpw_sc_rw4_f2
977 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw4_f2,
977 copyFloatByChar( (unsigned char*) &cp_rpw_sc_rw4_f2,
978 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW4_F2 ] );
978 (unsigned char*) &bytePosPtr[ BYTE_POS_UPDATE_INFO_CP_RPW_SC_RW4_F2 ] );
979 }
979 }
980
980
981 void setFBinMask( unsigned char *fbins_mask, float rw_f, unsigned char deltaFreq, unsigned char flag )
981 void setFBinMask( unsigned char *fbins_mask, float rw_f, unsigned char deltaFreq, unsigned char flag )
982 {
982 {
983 /** This function executes specific actions when a TC_LFR_UPDATE_INFO TeleCommand has been received.
983 /** This function executes specific actions when a TC_LFR_UPDATE_INFO TeleCommand has been received.
984 *
984 *
985 * @param fbins_mask
985 * @param fbins_mask
986 * @param rw_f is the reaction wheel frequency to filter
986 * @param rw_f is the reaction wheel frequency to filter
987 * @param delta_f is the frequency step between the frequency bins, it depends on the frequency channel
987 * @param delta_f is the frequency step between the frequency bins, it depends on the frequency channel
988 * @param flag [true] filtering enabled [false] filtering disabled
988 * @param flag [true] filtering enabled [false] filtering disabled
989 *
989 *
990 * @return void
990 * @return void
991 *
991 *
992 */
992 */
993
993
994 float f_RW_min;
994 float f_RW_min;
995 float f_RW_MAX;
995 float f_RW_MAX;
996 float fi_min;
996 float fi_min;
997 float fi_MAX;
997 float fi_MAX;
998 float fi;
998 float fi;
999 float deltaBelow;
999 float deltaBelow;
1000 float deltaAbove;
1000 float deltaAbove;
1001 int binBelow;
1001 int binBelow;
1002 int binAbove;
1002 int binAbove;
1003 int closestBin;
1003 int closestBin;
1004 unsigned int whichByte;
1004 unsigned int whichByte;
1005 int selectedByte;
1005 int selectedByte;
1006 int bin;
1006 int bin;
1007 int binToRemove[NB_BINS_TO_REMOVE];
1007 int binToRemove[NB_BINS_TO_REMOVE];
1008 int k;
1008 int k;
1009
1009
1010 closestBin = 0;
1010 closestBin = 0;
1011 whichByte = 0;
1011 whichByte = 0;
1012 bin = 0;
1012 bin = 0;
1013
1013
1014 for (k = 0; k < NB_BINS_TO_REMOVE; k++)
1014 for (k = 0; k < NB_BINS_TO_REMOVE; k++)
1015 {
1015 {
1016 binToRemove[k] = -1;
1016 binToRemove[k] = -1;
1017 }
1017 }
1018
1018
1019 // compute the frequency range to filter [ rw_f - delta_f/2; rw_f + delta_f/2 ]
1019 // compute the frequency range to filter [ rw_f - delta_f/2; rw_f + delta_f/2 ]
1020 f_RW_min = rw_f - (filterPar.sy_lfr_sc_rw_delta_f / 2.);
1020 f_RW_min = rw_f - (filterPar.sy_lfr_sc_rw_delta_f / 2.);
1021 f_RW_MAX = rw_f + (filterPar.sy_lfr_sc_rw_delta_f / 2.);
1021 f_RW_MAX = rw_f + (filterPar.sy_lfr_sc_rw_delta_f / 2.);
1022
1022
1023 // compute the index of the frequency bin immediately below rw_f
1023 // compute the index of the frequency bin immediately below rw_f
1024 binBelow = (int) ( floor( ((double) rw_f) / ((double) deltaFreq)) );
1024 binBelow = (int) ( floor( ((double) rw_f) / ((double) deltaFreq)) );
1025 deltaBelow = rw_f - binBelow * deltaFreq;
1025 deltaBelow = rw_f - binBelow * deltaFreq;
1026
1026
1027 // compute the index of the frequency bin immediately above rw_f
1027 // compute the index of the frequency bin immediately above rw_f
1028 binAbove = (int) ( ceil( ((double) rw_f) / ((double) deltaFreq)) );
1028 binAbove = (int) ( ceil( ((double) rw_f) / ((double) deltaFreq)) );
1029 deltaAbove = binAbove * deltaFreq - rw_f;
1029 deltaAbove = binAbove * deltaFreq - rw_f;
1030
1030
1031 // search the closest bin
1031 // search the closest bin
1032 if (deltaAbove > deltaBelow)
1032 if (deltaAbove > deltaBelow)
1033 {
1033 {
1034 closestBin = binBelow;
1034 closestBin = binBelow;
1035 }
1035 }
1036 else
1036 else
1037 {
1037 {
1038 closestBin = binAbove;
1038 closestBin = binAbove;
1039 }
1039 }
1040
1040
1041 // compute the fi interval [fi - deltaFreq * 0.285, fi + deltaFreq * 0.285]
1041 // compute the fi interval [fi - deltaFreq * 0.285, fi + deltaFreq * 0.285]
1042 fi = closestBin * deltaFreq;
1042 fi = closestBin * deltaFreq;
1043 fi_min = fi - (deltaFreq * FI_INTERVAL_COEFF);
1043 fi_min = fi - (deltaFreq * FI_INTERVAL_COEFF);
1044 fi_MAX = fi + (deltaFreq * FI_INTERVAL_COEFF);
1044 fi_MAX = fi + (deltaFreq * FI_INTERVAL_COEFF);
1045
1045
1046 //**************************************************************************************
1046 //**************************************************************************************
1047 // be careful here, one shall take into account that the bin 0 IS DROPPED in the spectra
1047 // be careful here, one shall take into account that the bin 0 IS DROPPED in the spectra
1048 // thus, the index 0 in a mask corresponds to the bin 1 of the spectrum
1048 // thus, the index 0 in a mask corresponds to the bin 1 of the spectrum
1049 //**************************************************************************************
1049 //**************************************************************************************
1050
1050
1051 // 1. IF [ f_RW_min, f_RW_MAX] is included in [ fi_min; fi_MAX ]
1051 // 1. IF [ f_RW_min, f_RW_MAX] is included in [ fi_min; fi_MAX ]
1052 // => remove f_(i), f_(i-1) and f_(i+1)
1052 // => remove f_(i), f_(i-1) and f_(i+1)
1053 if ( ( f_RW_min > fi_min ) && ( f_RW_MAX < fi_MAX ) )
1053 if ( ( f_RW_min > fi_min ) && ( f_RW_MAX < fi_MAX ) )
1054 {
1054 {
1055 binToRemove[0] = (closestBin - 1) - 1;
1055 binToRemove[0] = (closestBin - 1) - 1;
1056 binToRemove[1] = (closestBin) - 1;
1056 binToRemove[1] = (closestBin) - 1;
1057 binToRemove[2] = (closestBin + 1) - 1;
1057 binToRemove[2] = (closestBin + 1) - 1;
1058 }
1058 }
1059 // 2. ELSE
1059 // 2. ELSE
1060 // => remove the two f_(i) which are around f_RW
1060 // => remove the two f_(i) which are around f_RW
1061 else
1061 else
1062 {
1062 {
1063 binToRemove[0] = (binBelow) - 1;
1063 binToRemove[0] = (binBelow) - 1;
1064 binToRemove[1] = (binAbove) - 1;
1064 binToRemove[1] = (binAbove) - 1;
1065 binToRemove[2] = (-1);
1065 binToRemove[2] = (-1);
1066 }
1066 }
1067
1067
1068 for (k = 0; k < NB_BINS_TO_REMOVE; k++)
1068 for (k = 0; k < NB_BINS_TO_REMOVE; k++)
1069 {
1069 {
1070 bin = binToRemove[k];
1070 bin = binToRemove[k];
1071 if ( (bin >= BIN_MIN) && (bin <= BIN_MAX) )
1071 if ( (bin >= BIN_MIN) && (bin <= BIN_MAX) )
1072 {
1072 {
1073 if (flag == 1)
1073 if (flag == 1)
1074 {
1074 {
1075 whichByte = (bin >> SHIFT_3_BITS); // division by 8
1075 whichByte = (bin >> SHIFT_3_BITS); // division by 8
1076 selectedByte = ( 1 << (bin - (whichByte * BITS_PER_BYTE)) );
1076 selectedByte = ( 1 << (bin - (whichByte * BITS_PER_BYTE)) );
1077 fbins_mask[BYTES_PER_MASK - 1 - whichByte] =
1077 fbins_mask[BYTES_PER_MASK - 1 - whichByte] =
1078 fbins_mask[BYTES_PER_MASK - 1 - whichByte] & ((unsigned char) (~selectedByte)); // bytes are ordered MSB first in the packets
1078 fbins_mask[BYTES_PER_MASK - 1 - whichByte] & ((unsigned char) (~selectedByte)); // bytes are ordered MSB first in the packets
1079 }
1079 }
1080 }
1080 }
1081 }
1081 }
1082 }
1082 }
1083
1083
1084 void build_sy_lfr_rw_mask( unsigned int channel )
1084 void build_sy_lfr_rw_mask( unsigned int channel )
1085 {
1085 {
1086 unsigned char local_rw_fbins_mask[BYTES_PER_MASK];
1086 unsigned char local_rw_fbins_mask[BYTES_PER_MASK];
1087 unsigned char *maskPtr;
1087 unsigned char *maskPtr;
1088 double deltaF;
1088 double deltaF;
1089 unsigned k;
1089 unsigned k;
1090
1090
1091 k = 0;
1091 k = 0;
1092
1092
1093 maskPtr = NULL;
1093 maskPtr = NULL;
1094 deltaF = DELTAF_F2;
1094 deltaF = DELTAF_F2;
1095
1095
1096 switch (channel)
1096 switch (channel)
1097 {
1097 {
1098 case CHANNELF0:
1098 case CHANNELF0:
1099 maskPtr = parameter_dump_packet.sy_lfr_rw_mask_f0_word1;
1099 maskPtr = parameter_dump_packet.sy_lfr_rw_mask_f0_word1;
1100 deltaF = DELTAF_F0;
1100 deltaF = DELTAF_F0;
1101 break;
1101 break;
1102 case CHANNELF1:
1102 case CHANNELF1:
1103 maskPtr = parameter_dump_packet.sy_lfr_rw_mask_f1_word1;
1103 maskPtr = parameter_dump_packet.sy_lfr_rw_mask_f1_word1;
1104 deltaF = DELTAF_F1;
1104 deltaF = DELTAF_F1;
1105 break;
1105 break;
1106 case CHANNELF2:
1106 case CHANNELF2:
1107 maskPtr = parameter_dump_packet.sy_lfr_rw_mask_f2_word1;
1107 maskPtr = parameter_dump_packet.sy_lfr_rw_mask_f2_word1;
1108 deltaF = DELTAF_F2;
1108 deltaF = DELTAF_F2;
1109 break;
1109 break;
1110 default:
1110 default:
1111 break;
1111 break;
1112 }
1112 }
1113
1113
1114 for (k = 0; k < BYTES_PER_MASK; k++)
1114 for (k = 0; k < BYTES_PER_MASK; k++)
1115 {
1115 {
1116 local_rw_fbins_mask[k] = INT8_ALL_F;
1116 local_rw_fbins_mask[k] = INT8_ALL_F;
1117 }
1117 }
1118
1118
1119 // RW1 F1
1119 // RW1 F1
1120 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw1_f1, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW1_F1) >> SHIFT_7_BITS ); // [1000 0000]
1120 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw1_f1, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW1_F1) >> SHIFT_7_BITS ); // [1000 0000]
1121
1121
1122 // RW1 F2
1122 // RW1 F2
1123 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw1_f2, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW1_F2) >> SHIFT_6_BITS ); // [0100 0000]
1123 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw1_f2, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW1_F2) >> SHIFT_6_BITS ); // [0100 0000]
1124
1124
1125 // RW2 F1
1125 // RW2 F1
1126 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw2_f1, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW2_F1) >> SHIFT_5_BITS ); // [0010 0000]
1126 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw2_f1, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW2_F1) >> SHIFT_5_BITS ); // [0010 0000]
1127
1127
1128 // RW2 F2
1128 // RW2 F2
1129 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw2_f2, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW2_F2) >> SHIFT_4_BITS ); // [0001 0000]
1129 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw2_f2, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW2_F2) >> SHIFT_4_BITS ); // [0001 0000]
1130
1130
1131 // RW3 F1
1131 // RW3 F1
1132 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw3_f1, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW3_F1) >> SHIFT_3_BITS ); // [0000 1000]
1132 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw3_f1, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW3_F1) >> SHIFT_3_BITS ); // [0000 1000]
1133
1133
1134 // RW3 F2
1134 // RW3 F2
1135 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw3_f2, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW3_F2) >> SHIFT_2_BITS ); // [0000 0100]
1135 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw3_f2, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW3_F2) >> SHIFT_2_BITS ); // [0000 0100]
1136
1136
1137 // RW4 F1
1137 // RW4 F1
1138 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw4_f1, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW4_F1) >> 1 ); // [0000 0010]
1138 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw4_f1, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW4_F1) >> 1 ); // [0000 0010]
1139
1139
1140 // RW4 F2
1140 // RW4 F2
1141 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw4_f2, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW4_F2) ); // [0000 0001]
1141 setFBinMask( local_rw_fbins_mask, cp_rpw_sc_rw4_f2, deltaF, (cp_rpw_sc_rw_f_flags & BIT_RW4_F2) ); // [0000 0001]
1142
1142
1143 // update the value of the fbins related to reaction wheels frequency filtering
1143 // update the value of the fbins related to reaction wheels frequency filtering
1144 if (maskPtr != NULL)
1144 if (maskPtr != NULL)
1145 {
1145 {
1146 for (k = 0; k < BYTES_PER_MASK; k++)
1146 for (k = 0; k < BYTES_PER_MASK; k++)
1147 {
1147 {
1148 maskPtr[k] = local_rw_fbins_mask[k];
1148 maskPtr[k] = local_rw_fbins_mask[k];
1149 }
1149 }
1150 }
1150 }
1151 }
1151 }
1152
1152
1153 void build_sy_lfr_rw_masks( void )
1153 void build_sy_lfr_rw_masks( void )
1154 {
1154 {
1155 build_sy_lfr_rw_mask( CHANNELF0 );
1155 build_sy_lfr_rw_mask( CHANNELF0 );
1156 build_sy_lfr_rw_mask( CHANNELF1 );
1156 build_sy_lfr_rw_mask( CHANNELF1 );
1157 build_sy_lfr_rw_mask( CHANNELF2 );
1157 build_sy_lfr_rw_mask( CHANNELF2 );
1158 }
1158 }
1159
1159
1160 void merge_fbins_masks( void )
1160 void merge_fbins_masks( void )
1161 {
1161 {
1162 unsigned char k;
1162 unsigned char k;
1163
1163
1164 unsigned char *fbins_f0;
1164 unsigned char *fbins_f0;
1165 unsigned char *fbins_f1;
1165 unsigned char *fbins_f1;
1166 unsigned char *fbins_f2;
1166 unsigned char *fbins_f2;
1167 unsigned char *rw_mask_f0;
1167 unsigned char *rw_mask_f0;
1168 unsigned char *rw_mask_f1;
1168 unsigned char *rw_mask_f1;
1169 unsigned char *rw_mask_f2;
1169 unsigned char *rw_mask_f2;
1170
1170
1171 fbins_f0 = parameter_dump_packet.sy_lfr_fbins_f0_word1;
1171 fbins_f0 = parameter_dump_packet.sy_lfr_fbins_f0_word1;
1172 fbins_f1 = parameter_dump_packet.sy_lfr_fbins_f1_word1;
1172 fbins_f1 = parameter_dump_packet.sy_lfr_fbins_f1_word1;
1173 fbins_f2 = parameter_dump_packet.sy_lfr_fbins_f2_word1;
1173 fbins_f2 = parameter_dump_packet.sy_lfr_fbins_f2_word1;
1174 rw_mask_f0 = parameter_dump_packet.sy_lfr_rw_mask_f0_word1;
1174 rw_mask_f0 = parameter_dump_packet.sy_lfr_rw_mask_f0_word1;
1175 rw_mask_f1 = parameter_dump_packet.sy_lfr_rw_mask_f1_word1;
1175 rw_mask_f1 = parameter_dump_packet.sy_lfr_rw_mask_f1_word1;
1176 rw_mask_f2 = parameter_dump_packet.sy_lfr_rw_mask_f2_word1;
1176 rw_mask_f2 = parameter_dump_packet.sy_lfr_rw_mask_f2_word1;
1177
1177
1178 for( k=0; k < BYTES_PER_MASK; k++ )
1178 for( k=0; k < BYTES_PER_MASK; k++ )
1179 {
1179 {
1180 fbins_masks.merged_fbins_mask_f0[k] = fbins_f0[k] & rw_mask_f0[k];
1180 fbins_masks.merged_fbins_mask_f0[k] = fbins_f0[k] & rw_mask_f0[k];
1181 fbins_masks.merged_fbins_mask_f1[k] = fbins_f1[k] & rw_mask_f1[k];
1181 fbins_masks.merged_fbins_mask_f1[k] = fbins_f1[k] & rw_mask_f1[k];
1182 fbins_masks.merged_fbins_mask_f2[k] = fbins_f2[k] & rw_mask_f2[k];
1182 fbins_masks.merged_fbins_mask_f2[k] = fbins_f2[k] & rw_mask_f2[k];
1183 }
1183 }
1184 }
1184 }
1185
1185
1186 //***********
1186 //***********
1187 // FBINS MASK
1187 // FBINS MASK
1188
1188
1189 int set_sy_lfr_fbins( ccsdsTelecommandPacket_t *TC )
1189 int set_sy_lfr_fbins( ccsdsTelecommandPacket_t *TC )
1190 {
1190 {
1191 int status;
1191 int status;
1192 unsigned int k;
1192 unsigned int k;
1193 unsigned char *fbins_mask_dump;
1193 unsigned char *fbins_mask_dump;
1194 unsigned char *fbins_mask_TC;
1194 unsigned char *fbins_mask_TC;
1195
1195
1196 status = LFR_SUCCESSFUL;
1196 status = LFR_SUCCESSFUL;
1197
1197
1198 fbins_mask_dump = parameter_dump_packet.sy_lfr_fbins_f0_word1;
1198 fbins_mask_dump = parameter_dump_packet.sy_lfr_fbins_f0_word1;
1199 fbins_mask_TC = TC->dataAndCRC;
1199 fbins_mask_TC = TC->dataAndCRC;
1200
1200
1201 for (k=0; k < BYTES_PER_MASKS_SET; k++)
1201 for (k=0; k < BYTES_PER_MASKS_SET; k++)
1202 {
1202 {
1203 fbins_mask_dump[k] = fbins_mask_TC[k];
1203 fbins_mask_dump[k] = fbins_mask_TC[k];
1204 }
1204 }
1205
1205
1206 return status;
1206 return status;
1207 }
1207 }
1208
1208
1209 //***************************
1209 //***************************
1210 // TC_LFR_LOAD_PAS_FILTER_PAR
1210 // TC_LFR_LOAD_PAS_FILTER_PAR
1211
1211
1212 int check_sy_lfr_filter_parameters( ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
1212 int check_sy_lfr_filter_parameters( ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
1213 {
1213 {
1214 int flag;
1214 int flag;
1215 rtems_status_code status;
1215 rtems_status_code status;
1216
1216
1217 unsigned char sy_lfr_pas_filter_enabled;
1217 unsigned char sy_lfr_pas_filter_enabled;
1218 unsigned char sy_lfr_pas_filter_modulus;
1218 unsigned char sy_lfr_pas_filter_modulus;
1219 float sy_lfr_pas_filter_tbad;
1219 float sy_lfr_pas_filter_tbad;
1220 unsigned char sy_lfr_pas_filter_offset;
1220 unsigned char sy_lfr_pas_filter_offset;
1221 float sy_lfr_pas_filter_shift;
1221 float sy_lfr_pas_filter_shift;
1222 float sy_lfr_sc_rw_delta_f;
1222 float sy_lfr_sc_rw_delta_f;
1223 char *parPtr;
1223 char *parPtr;
1224
1224
1225 flag = LFR_SUCCESSFUL;
1225 flag = LFR_SUCCESSFUL;
1226 sy_lfr_pas_filter_tbad = INIT_FLOAT;
1226 sy_lfr_pas_filter_tbad = INIT_FLOAT;
1227 sy_lfr_pas_filter_shift = INIT_FLOAT;
1227 sy_lfr_pas_filter_shift = INIT_FLOAT;
1228 sy_lfr_sc_rw_delta_f = INIT_FLOAT;
1228 sy_lfr_sc_rw_delta_f = INIT_FLOAT;
1229 parPtr = NULL;
1229 parPtr = NULL;
1230
1230
1231 //***************
1231 //***************
1232 // get parameters
1232 // get parameters
1233 sy_lfr_pas_filter_enabled = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_ENABLED ] & BIT_PAS_FILTER_ENABLED; // [0000 0001]
1233 sy_lfr_pas_filter_enabled = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_ENABLED ] & BIT_PAS_FILTER_ENABLED; // [0000 0001]
1234 sy_lfr_pas_filter_modulus = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_MODULUS ];
1234 sy_lfr_pas_filter_modulus = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_MODULUS ];
1235 copyFloatByChar(
1235 copyFloatByChar(
1236 (unsigned char*) &sy_lfr_pas_filter_tbad,
1236 (unsigned char*) &sy_lfr_pas_filter_tbad,
1237 (unsigned char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD ]
1237 (unsigned char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD ]
1238 );
1238 );
1239 sy_lfr_pas_filter_offset = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_OFFSET ];
1239 sy_lfr_pas_filter_offset = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_OFFSET ];
1240 copyFloatByChar(
1240 copyFloatByChar(
1241 (unsigned char*) &sy_lfr_pas_filter_shift,
1241 (unsigned char*) &sy_lfr_pas_filter_shift,
1242 (unsigned char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT ]
1242 (unsigned char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT ]
1243 );
1243 );
1244 copyFloatByChar(
1244 copyFloatByChar(
1245 (unsigned char*) &sy_lfr_sc_rw_delta_f,
1245 (unsigned char*) &sy_lfr_sc_rw_delta_f,
1246 (unsigned char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F ]
1246 (unsigned char*) &TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_SC_RW_DELTA_F ]
1247 );
1247 );
1248
1248
1249 //******************
1249 //******************
1250 // CHECK CONSISTENCY
1250 // CHECK CONSISTENCY
1251
1251
1252 //**************************
1252 //**************************
1253 // sy_lfr_pas_filter_enabled
1253 // sy_lfr_pas_filter_enabled
1254 // nothing to check, value is 0 or 1
1254 // nothing to check, value is 0 or 1
1255
1255
1256 //**************************
1256 //**************************
1257 // sy_lfr_pas_filter_modulus
1257 // sy_lfr_pas_filter_modulus
1258 if ( (sy_lfr_pas_filter_modulus < MIN_PAS_FILTER_MODULUS) || (sy_lfr_pas_filter_modulus > MAX_PAS_FILTER_MODULUS) )
1258 if ( (sy_lfr_pas_filter_modulus < MIN_PAS_FILTER_MODULUS) || (sy_lfr_pas_filter_modulus > MAX_PAS_FILTER_MODULUS) )
1259 {
1259 {
1260 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_MODULUS + DATAFIELD_OFFSET, sy_lfr_pas_filter_modulus );
1260 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_MODULUS + DATAFIELD_OFFSET, sy_lfr_pas_filter_modulus );
1261 flag = WRONG_APP_DATA;
1261 flag = WRONG_APP_DATA;
1262 }
1262 }
1263
1263
1264 //***********************
1264 //***********************
1265 // sy_lfr_pas_filter_tbad
1265 // sy_lfr_pas_filter_tbad
1266 if ( (sy_lfr_pas_filter_tbad < MIN_PAS_FILTER_TBAD) || (sy_lfr_pas_filter_tbad > MAX_PAS_FILTER_TBAD) )
1266 if ( (sy_lfr_pas_filter_tbad < MIN_PAS_FILTER_TBAD) || (sy_lfr_pas_filter_tbad > MAX_PAS_FILTER_TBAD) )
1267 {
1267 {
1268 parPtr = (char*) &sy_lfr_pas_filter_tbad;
1268 parPtr = (char*) &sy_lfr_pas_filter_tbad;
1269 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + DATAFIELD_OFFSET, parPtr[FLOAT_LSBYTE] );
1269 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_TBAD + DATAFIELD_OFFSET, parPtr[FLOAT_LSBYTE] );
1270 flag = WRONG_APP_DATA;
1270 flag = WRONG_APP_DATA;
1271 }
1271 }
1272
1272
1273 //*************************
1273 //*************************
1274 // sy_lfr_pas_filter_offset
1274 // sy_lfr_pas_filter_offset
1275 if (flag == LFR_SUCCESSFUL)
1275 if (flag == LFR_SUCCESSFUL)
1276 {
1276 {
1277 if ( (sy_lfr_pas_filter_offset < MIN_PAS_FILTER_OFFSET) || (sy_lfr_pas_filter_offset > MAX_PAS_FILTER_OFFSET) )
1277 if ( (sy_lfr_pas_filter_offset < MIN_PAS_FILTER_OFFSET) || (sy_lfr_pas_filter_offset > MAX_PAS_FILTER_OFFSET) )
1278 {
1278 {
1279 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_OFFSET + DATAFIELD_OFFSET, sy_lfr_pas_filter_offset );
1279 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_OFFSET + DATAFIELD_OFFSET, sy_lfr_pas_filter_offset );
1280 flag = WRONG_APP_DATA;
1280 flag = WRONG_APP_DATA;
1281 }
1281 }
1282 }
1282 }
1283
1283
1284 //************************
1284 //************************
1285 // sy_lfr_pas_filter_shift
1285 // sy_lfr_pas_filter_shift
1286 if (flag == LFR_SUCCESSFUL)
1286 if (flag == LFR_SUCCESSFUL)
1287 {
1287 {
1288 if ( (sy_lfr_pas_filter_shift < MIN_PAS_FILTER_SHIFT) || (sy_lfr_pas_filter_shift > MAX_PAS_FILTER_SHIFT) )
1288 if ( (sy_lfr_pas_filter_shift < MIN_PAS_FILTER_SHIFT) || (sy_lfr_pas_filter_shift > MAX_PAS_FILTER_SHIFT) )
1289 {
1289 {
1290 parPtr = (char*) &sy_lfr_pas_filter_shift;
1290 parPtr = (char*) &sy_lfr_pas_filter_shift;
1291 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + DATAFIELD_OFFSET, parPtr[FLOAT_LSBYTE] );
1291 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_SHIFT + DATAFIELD_OFFSET, parPtr[FLOAT_LSBYTE] );
1292 flag = WRONG_APP_DATA;
1292 flag = WRONG_APP_DATA;
1293 }
1293 }
1294 }
1294 }
1295
1295
1296 //*************************************
1296 //*************************************
1297 // check global coherency of the values
1297 // check global coherency of the values
1298 if (flag == LFR_SUCCESSFUL)
1298 if (flag == LFR_SUCCESSFUL)
1299 {
1299 {
1300 if ( (sy_lfr_pas_filter_tbad + sy_lfr_pas_filter_offset + sy_lfr_pas_filter_shift) > sy_lfr_pas_filter_modulus )
1300 if ( (sy_lfr_pas_filter_tbad + sy_lfr_pas_filter_offset + sy_lfr_pas_filter_shift) > sy_lfr_pas_filter_modulus )
1301 {
1301 {
1302 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_MODULUS + DATAFIELD_OFFSET, sy_lfr_pas_filter_modulus );
1302 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_PAS_FILTER_MODULUS + DATAFIELD_OFFSET, sy_lfr_pas_filter_modulus );
1303 flag = WRONG_APP_DATA;
1303 flag = WRONG_APP_DATA;
1304 }
1304 }
1305 }
1305 }
1306
1306
1307 //*********************
1307 //*********************
1308 // sy_lfr_sc_rw_delta_f
1308 // sy_lfr_sc_rw_delta_f
1309 // nothing to check, no default value in the ICD
1309 // nothing to check, no default value in the ICD
1310
1310
1311 return flag;
1311 return flag;
1312 }
1312 }
1313
1313
1314 //**************
1314 //**************
1315 // KCOEFFICIENTS
1315 // KCOEFFICIENTS
1316 int set_sy_lfr_kcoeff( ccsdsTelecommandPacket_t *TC,rtems_id queue_id )
1316 int set_sy_lfr_kcoeff( ccsdsTelecommandPacket_t *TC,rtems_id queue_id )
1317 {
1317 {
1318 unsigned int kcoeff;
1318 unsigned int kcoeff;
1319 unsigned short sy_lfr_kcoeff_frequency;
1319 unsigned short sy_lfr_kcoeff_frequency;
1320 unsigned short bin;
1320 unsigned short bin;
1321 float *kcoeffPtr_norm;
1321 float *kcoeffPtr_norm;
1322 float *kcoeffPtr_sbm;
1322 float *kcoeffPtr_sbm;
1323 int status;
1323 int status;
1324 unsigned char *kcoeffLoadPtr;
1324 unsigned char *kcoeffLoadPtr;
1325 unsigned char *kcoeffNormPtr;
1325 unsigned char *kcoeffNormPtr;
1326 unsigned char *kcoeffSbmPtr_a;
1326 unsigned char *kcoeffSbmPtr_a;
1327 unsigned char *kcoeffSbmPtr_b;
1327 unsigned char *kcoeffSbmPtr_b;
1328
1328
1329 sy_lfr_kcoeff_frequency = 0;
1329 sy_lfr_kcoeff_frequency = 0;
1330 bin = 0;
1330 bin = 0;
1331 kcoeffPtr_norm = NULL;
1331 kcoeffPtr_norm = NULL;
1332 kcoeffPtr_sbm = NULL;
1332 kcoeffPtr_sbm = NULL;
1333 status = LFR_SUCCESSFUL;
1333 status = LFR_SUCCESSFUL;
1334
1334
1335 // copy the value of the frequency byte by byte DO NOT USE A SHORT* POINTER
1335 // copy the value of the frequency byte by byte DO NOT USE A SHORT* POINTER
1336 copyInt16ByChar( (unsigned char*) &sy_lfr_kcoeff_frequency, &TC->dataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_FREQUENCY] );
1336 copyInt16ByChar( (unsigned char*) &sy_lfr_kcoeff_frequency, &TC->dataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_FREQUENCY] );
1337
1337
1338 if ( sy_lfr_kcoeff_frequency >= NB_BINS_COMPRESSED_SM )
1338 if ( sy_lfr_kcoeff_frequency >= NB_BINS_COMPRESSED_SM )
1339 {
1339 {
1340 PRINTF1("ERR *** in set_sy_lfr_kcoeff_frequency *** sy_lfr_kcoeff_frequency = %d\n", sy_lfr_kcoeff_frequency)
1340 PRINTF1("ERR *** in set_sy_lfr_kcoeff_frequency *** sy_lfr_kcoeff_frequency = %d\n", sy_lfr_kcoeff_frequency)
1341 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_KCOEFF_FREQUENCY + DATAFIELD_OFFSET + 1,
1341 status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_KCOEFF_FREQUENCY + DATAFIELD_OFFSET + 1,
1342 TC->dataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_FREQUENCY + 1] ); // +1 to get the LSB instead of the MSB
1342 TC->dataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_FREQUENCY + 1] ); // +1 to get the LSB instead of the MSB
1343 status = LFR_DEFAULT;
1343 status = LFR_DEFAULT;
1344 }
1344 }
1345 else
1345 else
1346 {
1346 {
1347 if ( ( sy_lfr_kcoeff_frequency >= 0 )
1347 if ( ( sy_lfr_kcoeff_frequency >= 0 )
1348 && ( sy_lfr_kcoeff_frequency < NB_BINS_COMPRESSED_SM_F0 ) )
1348 && ( sy_lfr_kcoeff_frequency < NB_BINS_COMPRESSED_SM_F0 ) )
1349 {
1349 {
1350 kcoeffPtr_norm = k_coeff_intercalib_f0_norm;
1350 kcoeffPtr_norm = k_coeff_intercalib_f0_norm;
1351 kcoeffPtr_sbm = k_coeff_intercalib_f0_sbm;
1351 kcoeffPtr_sbm = k_coeff_intercalib_f0_sbm;
1352 bin = sy_lfr_kcoeff_frequency;
1352 bin = sy_lfr_kcoeff_frequency;
1353 }
1353 }
1354 else if ( ( sy_lfr_kcoeff_frequency >= NB_BINS_COMPRESSED_SM_F0 )
1354 else if ( ( sy_lfr_kcoeff_frequency >= NB_BINS_COMPRESSED_SM_F0 )
1355 && ( sy_lfr_kcoeff_frequency < (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1) ) )
1355 && ( sy_lfr_kcoeff_frequency < (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1) ) )
1356 {
1356 {
1357 kcoeffPtr_norm = k_coeff_intercalib_f1_norm;
1357 kcoeffPtr_norm = k_coeff_intercalib_f1_norm;
1358 kcoeffPtr_sbm = k_coeff_intercalib_f1_sbm;
1358 kcoeffPtr_sbm = k_coeff_intercalib_f1_sbm;
1359 bin = sy_lfr_kcoeff_frequency - NB_BINS_COMPRESSED_SM_F0;
1359 bin = sy_lfr_kcoeff_frequency - NB_BINS_COMPRESSED_SM_F0;
1360 }
1360 }
1361 else if ( ( sy_lfr_kcoeff_frequency >= (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1) )
1361 else if ( ( sy_lfr_kcoeff_frequency >= (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1) )
1362 && ( sy_lfr_kcoeff_frequency < (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1 + NB_BINS_COMPRESSED_SM_F2) ) )
1362 && ( sy_lfr_kcoeff_frequency < (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1 + NB_BINS_COMPRESSED_SM_F2) ) )
1363 {
1363 {
1364 kcoeffPtr_norm = k_coeff_intercalib_f2;
1364 kcoeffPtr_norm = k_coeff_intercalib_f2;
1365 kcoeffPtr_sbm = NULL;
1365 kcoeffPtr_sbm = NULL;
1366 bin = sy_lfr_kcoeff_frequency - (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1);
1366 bin = sy_lfr_kcoeff_frequency - (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1);
1367 }
1367 }
1368 }
1368 }
1369
1369
1370 if (kcoeffPtr_norm != NULL ) // update K coefficient for NORMAL data products
1370 if (kcoeffPtr_norm != NULL ) // update K coefficient for NORMAL data products
1371 {
1371 {
1372 for (kcoeff=0; kcoeff<NB_K_COEFF_PER_BIN; kcoeff++)
1372 for (kcoeff=0; kcoeff<NB_K_COEFF_PER_BIN; kcoeff++)
1373 {
1373 {
1374 // destination
1374 // destination
1375 kcoeffNormPtr = (unsigned char*) &kcoeffPtr_norm[ (bin * NB_K_COEFF_PER_BIN) + kcoeff ];
1375 kcoeffNormPtr = (unsigned char*) &kcoeffPtr_norm[ (bin * NB_K_COEFF_PER_BIN) + kcoeff ];
1376 // source
1376 // source
1377 kcoeffLoadPtr = (unsigned char*) &TC->dataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_1 + (NB_BYTES_PER_FLOAT * kcoeff)];
1377 kcoeffLoadPtr = (unsigned char*) &TC->dataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_1 + (NB_BYTES_PER_FLOAT * kcoeff)];
1378 // copy source to destination
1378 // copy source to destination
1379 copyFloatByChar( kcoeffNormPtr, kcoeffLoadPtr );
1379 copyFloatByChar( kcoeffNormPtr, kcoeffLoadPtr );
1380 }
1380 }
1381 }
1381 }
1382
1382
1383 if (kcoeffPtr_sbm != NULL ) // update K coefficient for SBM data products
1383 if (kcoeffPtr_sbm != NULL ) // update K coefficient for SBM data products
1384 {
1384 {
1385 for (kcoeff=0; kcoeff<NB_K_COEFF_PER_BIN; kcoeff++)
1385 for (kcoeff=0; kcoeff<NB_K_COEFF_PER_BIN; kcoeff++)
1386 {
1386 {
1387 // destination
1387 // destination
1388 kcoeffSbmPtr_a= (unsigned char*) &kcoeffPtr_sbm[ ( (bin * NB_K_COEFF_PER_BIN) + kcoeff) * SBM_COEFF_PER_NORM_COEFF ];
1388 kcoeffSbmPtr_a= (unsigned char*) &kcoeffPtr_sbm[ ( (bin * NB_K_COEFF_PER_BIN) + kcoeff) * SBM_COEFF_PER_NORM_COEFF ];
1389 kcoeffSbmPtr_b= (unsigned char*) &kcoeffPtr_sbm[ (((bin * NB_K_COEFF_PER_BIN) + kcoeff) * SBM_KCOEFF_PER_NORM_KCOEFF) + 1 ];
1389 kcoeffSbmPtr_b= (unsigned char*) &kcoeffPtr_sbm[ (((bin * NB_K_COEFF_PER_BIN) + kcoeff) * SBM_KCOEFF_PER_NORM_KCOEFF) + 1 ];
1390 // source
1390 // source
1391 kcoeffLoadPtr = (unsigned char*) &TC->dataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_1 + (NB_BYTES_PER_FLOAT * kcoeff)];
1391 kcoeffLoadPtr = (unsigned char*) &TC->dataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_1 + (NB_BYTES_PER_FLOAT * kcoeff)];
1392 // copy source to destination
1392 // copy source to destination
1393 copyFloatByChar( kcoeffSbmPtr_a, kcoeffLoadPtr );
1393 copyFloatByChar( kcoeffSbmPtr_a, kcoeffLoadPtr );
1394 copyFloatByChar( kcoeffSbmPtr_b, kcoeffLoadPtr );
1394 copyFloatByChar( kcoeffSbmPtr_b, kcoeffLoadPtr );
1395 }
1395 }
1396 }
1396 }
1397
1397
1398 //print_k_coeff();
1398 //print_k_coeff();
1399
1399
1400 return status;
1400 return status;
1401 }
1401 }
1402
1402
1403 void copyFloatByChar( unsigned char *destination, unsigned char *source )
1403 void copyFloatByChar( unsigned char *destination, unsigned char *source )
1404 {
1404 {
1405 destination[BYTE_0] = source[BYTE_0];
1405 destination[BYTE_0] = source[BYTE_0];
1406 destination[BYTE_1] = source[BYTE_1];
1406 destination[BYTE_1] = source[BYTE_1];
1407 destination[BYTE_2] = source[BYTE_2];
1407 destination[BYTE_2] = source[BYTE_2];
1408 destination[BYTE_3] = source[BYTE_3];
1408 destination[BYTE_3] = source[BYTE_3];
1409 }
1409 }
1410
1410
1411 void copyInt32ByChar( unsigned char *destination, unsigned char *source )
1411 void copyInt32ByChar( unsigned char *destination, unsigned char *source )
1412 {
1412 {
1413 destination[BYTE_0] = source[BYTE_0];
1413 destination[BYTE_0] = source[BYTE_0];
1414 destination[BYTE_1] = source[BYTE_1];
1414 destination[BYTE_1] = source[BYTE_1];
1415 destination[BYTE_2] = source[BYTE_2];
1415 destination[BYTE_2] = source[BYTE_2];
1416 destination[BYTE_3] = source[BYTE_3];
1416 destination[BYTE_3] = source[BYTE_3];
1417 }
1417 }
1418
1418
1419 void copyInt16ByChar( unsigned char *destination, unsigned char *source )
1419 void copyInt16ByChar( unsigned char *destination, unsigned char *source )
1420 {
1420 {
1421 destination[BYTE_0] = source[BYTE_0];
1421 destination[BYTE_0] = source[BYTE_0];
1422 destination[BYTE_1] = source[BYTE_1];
1422 destination[BYTE_1] = source[BYTE_1];
1423 }
1423 }
1424
1424
1425 void floatToChar( float value, unsigned char* ptr)
1425 void floatToChar( float value, unsigned char* ptr)
1426 {
1426 {
1427 unsigned char* valuePtr;
1427 unsigned char* valuePtr;
1428
1428
1429 valuePtr = (unsigned char*) &value;
1429 valuePtr = (unsigned char*) &value;
1430
1430
1431 ptr[BYTE_0] = valuePtr[BYTE_0];
1431 ptr[BYTE_0] = valuePtr[BYTE_0];
1432 ptr[BYTE_1] = valuePtr[BYTE_1];
1432 ptr[BYTE_1] = valuePtr[BYTE_1];
1433 ptr[BYTE_2] = valuePtr[BYTE_2];
1433 ptr[BYTE_2] = valuePtr[BYTE_2];
1434 ptr[BYTE_3] = valuePtr[BYTE_3];
1434 ptr[BYTE_3] = valuePtr[BYTE_3];
1435
1436 // <TEST>
1437 printf("\n\n<TEST>\n");
1438
1439 float aux = NAN;
1440 unsigned char* auxPtr;
1441 auxPtr = (unsigned char*) &aux;
1442
1443 printf("aux = %f, value = %f\n", aux, value);
1444
1445 auxPtr[BYTE_0] = valuePtr[BYTE_0];
1446 auxPtr[BYTE_1] = valuePtr[BYTE_1];
1447 auxPtr[BYTE_2] = valuePtr[BYTE_2];
1448 auxPtr[BYTE_3] = valuePtr[BYTE_3];
1449
1450 printf("aux = %f\n", aux);
1451 // </TEST>
1452 }
1435 }
1453
1436
1454 //**********
1437 //**********
1455 // init dump
1438 // init dump
1456
1439
1457 void init_parameter_dump( void )
1440 void init_parameter_dump( void )
1458 {
1441 {
1459 /** This function initialize the parameter_dump_packet global variable with default values.
1442 /** This function initialize the parameter_dump_packet global variable with default values.
1460 *
1443 *
1461 */
1444 */
1462
1445
1463 unsigned int k;
1446 unsigned int k;
1464
1447
1465 parameter_dump_packet.targetLogicalAddress = CCSDS_DESTINATION_ID;
1448 parameter_dump_packet.targetLogicalAddress = CCSDS_DESTINATION_ID;
1466 parameter_dump_packet.protocolIdentifier = CCSDS_PROTOCOLE_ID;
1449 parameter_dump_packet.protocolIdentifier = CCSDS_PROTOCOLE_ID;
1467 parameter_dump_packet.reserved = CCSDS_RESERVED;
1450 parameter_dump_packet.reserved = CCSDS_RESERVED;
1468 parameter_dump_packet.userApplication = CCSDS_USER_APP;
1451 parameter_dump_packet.userApplication = CCSDS_USER_APP;
1469 parameter_dump_packet.packetID[0] = (unsigned char) (APID_TM_PARAMETER_DUMP >> SHIFT_1_BYTE);
1452 parameter_dump_packet.packetID[0] = (unsigned char) (APID_TM_PARAMETER_DUMP >> SHIFT_1_BYTE);
1470 parameter_dump_packet.packetID[1] = (unsigned char) APID_TM_PARAMETER_DUMP;
1453 parameter_dump_packet.packetID[1] = (unsigned char) APID_TM_PARAMETER_DUMP;
1471 parameter_dump_packet.packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
1454 parameter_dump_packet.packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
1472 parameter_dump_packet.packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT;
1455 parameter_dump_packet.packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT;
1473 parameter_dump_packet.packetLength[0] = (unsigned char) (PACKET_LENGTH_PARAMETER_DUMP >> SHIFT_1_BYTE);
1456 parameter_dump_packet.packetLength[0] = (unsigned char) (PACKET_LENGTH_PARAMETER_DUMP >> SHIFT_1_BYTE);
1474 parameter_dump_packet.packetLength[1] = (unsigned char) PACKET_LENGTH_PARAMETER_DUMP;
1457 parameter_dump_packet.packetLength[1] = (unsigned char) PACKET_LENGTH_PARAMETER_DUMP;
1475 // DATA FIELD HEADER
1458 // DATA FIELD HEADER
1476 parameter_dump_packet.spare1_pusVersion_spare2 = SPARE1_PUSVERSION_SPARE2;
1459 parameter_dump_packet.spare1_pusVersion_spare2 = SPARE1_PUSVERSION_SPARE2;
1477 parameter_dump_packet.serviceType = TM_TYPE_PARAMETER_DUMP;
1460 parameter_dump_packet.serviceType = TM_TYPE_PARAMETER_DUMP;
1478 parameter_dump_packet.serviceSubType = TM_SUBTYPE_PARAMETER_DUMP;
1461 parameter_dump_packet.serviceSubType = TM_SUBTYPE_PARAMETER_DUMP;
1479 parameter_dump_packet.destinationID = TM_DESTINATION_ID_GROUND;
1462 parameter_dump_packet.destinationID = TM_DESTINATION_ID_GROUND;
1480 parameter_dump_packet.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
1463 parameter_dump_packet.time[BYTE_0] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_3_BYTES);
1481 parameter_dump_packet.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
1464 parameter_dump_packet.time[BYTE_1] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_2_BYTES);
1482 parameter_dump_packet.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
1465 parameter_dump_packet.time[BYTE_2] = (unsigned char) (time_management_regs->coarse_time >> SHIFT_1_BYTE);
1483 parameter_dump_packet.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
1466 parameter_dump_packet.time[BYTE_3] = (unsigned char) (time_management_regs->coarse_time);
1484 parameter_dump_packet.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
1467 parameter_dump_packet.time[BYTE_4] = (unsigned char) (time_management_regs->fine_time >> SHIFT_1_BYTE);
1485 parameter_dump_packet.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
1468 parameter_dump_packet.time[BYTE_5] = (unsigned char) (time_management_regs->fine_time);
1486 parameter_dump_packet.sid = SID_PARAMETER_DUMP;
1469 parameter_dump_packet.sid = SID_PARAMETER_DUMP;
1487
1470
1488 //******************
1471 //******************
1489 // COMMON PARAMETERS
1472 // COMMON PARAMETERS
1490 parameter_dump_packet.sy_lfr_common_parameters_spare = DEFAULT_SY_LFR_COMMON0;
1473 parameter_dump_packet.sy_lfr_common_parameters_spare = DEFAULT_SY_LFR_COMMON0;
1491 parameter_dump_packet.sy_lfr_common_parameters = DEFAULT_SY_LFR_COMMON1;
1474 parameter_dump_packet.sy_lfr_common_parameters = DEFAULT_SY_LFR_COMMON1;
1492
1475
1493 //******************
1476 //******************
1494 // NORMAL PARAMETERS
1477 // NORMAL PARAMETERS
1495 parameter_dump_packet.sy_lfr_n_swf_l[0] = (unsigned char) (DFLT_SY_LFR_N_SWF_L >> SHIFT_1_BYTE);
1478 parameter_dump_packet.sy_lfr_n_swf_l[0] = (unsigned char) (DFLT_SY_LFR_N_SWF_L >> SHIFT_1_BYTE);
1496 parameter_dump_packet.sy_lfr_n_swf_l[1] = (unsigned char) (DFLT_SY_LFR_N_SWF_L );
1479 parameter_dump_packet.sy_lfr_n_swf_l[1] = (unsigned char) (DFLT_SY_LFR_N_SWF_L );
1497 parameter_dump_packet.sy_lfr_n_swf_p[0] = (unsigned char) (DFLT_SY_LFR_N_SWF_P >> SHIFT_1_BYTE);
1480 parameter_dump_packet.sy_lfr_n_swf_p[0] = (unsigned char) (DFLT_SY_LFR_N_SWF_P >> SHIFT_1_BYTE);
1498 parameter_dump_packet.sy_lfr_n_swf_p[1] = (unsigned char) (DFLT_SY_LFR_N_SWF_P );
1481 parameter_dump_packet.sy_lfr_n_swf_p[1] = (unsigned char) (DFLT_SY_LFR_N_SWF_P );
1499 parameter_dump_packet.sy_lfr_n_asm_p[0] = (unsigned char) (DFLT_SY_LFR_N_ASM_P >> SHIFT_1_BYTE);
1482 parameter_dump_packet.sy_lfr_n_asm_p[0] = (unsigned char) (DFLT_SY_LFR_N_ASM_P >> SHIFT_1_BYTE);
1500 parameter_dump_packet.sy_lfr_n_asm_p[1] = (unsigned char) (DFLT_SY_LFR_N_ASM_P );
1483 parameter_dump_packet.sy_lfr_n_asm_p[1] = (unsigned char) (DFLT_SY_LFR_N_ASM_P );
1501 parameter_dump_packet.sy_lfr_n_bp_p0 = (unsigned char) DFLT_SY_LFR_N_BP_P0;
1484 parameter_dump_packet.sy_lfr_n_bp_p0 = (unsigned char) DFLT_SY_LFR_N_BP_P0;
1502 parameter_dump_packet.sy_lfr_n_bp_p1 = (unsigned char) DFLT_SY_LFR_N_BP_P1;
1485 parameter_dump_packet.sy_lfr_n_bp_p1 = (unsigned char) DFLT_SY_LFR_N_BP_P1;
1503 parameter_dump_packet.sy_lfr_n_cwf_long_f3 = (unsigned char) DFLT_SY_LFR_N_CWF_LONG_F3;
1486 parameter_dump_packet.sy_lfr_n_cwf_long_f3 = (unsigned char) DFLT_SY_LFR_N_CWF_LONG_F3;
1504
1487
1505 //*****************
1488 //*****************
1506 // BURST PARAMETERS
1489 // BURST PARAMETERS
1507 parameter_dump_packet.sy_lfr_b_bp_p0 = (unsigned char) DEFAULT_SY_LFR_B_BP_P0;
1490 parameter_dump_packet.sy_lfr_b_bp_p0 = (unsigned char) DEFAULT_SY_LFR_B_BP_P0;
1508 parameter_dump_packet.sy_lfr_b_bp_p1 = (unsigned char) DEFAULT_SY_LFR_B_BP_P1;
1491 parameter_dump_packet.sy_lfr_b_bp_p1 = (unsigned char) DEFAULT_SY_LFR_B_BP_P1;
1509
1492
1510 //****************
1493 //****************
1511 // SBM1 PARAMETERS
1494 // SBM1 PARAMETERS
1512 parameter_dump_packet.sy_lfr_s1_bp_p0 = (unsigned char) DEFAULT_SY_LFR_S1_BP_P0; // min value is 0.25 s for the period
1495 parameter_dump_packet.sy_lfr_s1_bp_p0 = (unsigned char) DEFAULT_SY_LFR_S1_BP_P0; // min value is 0.25 s for the period
1513 parameter_dump_packet.sy_lfr_s1_bp_p1 = (unsigned char) DEFAULT_SY_LFR_S1_BP_P1;
1496 parameter_dump_packet.sy_lfr_s1_bp_p1 = (unsigned char) DEFAULT_SY_LFR_S1_BP_P1;
1514
1497
1515 //****************
1498 //****************
1516 // SBM2 PARAMETERS
1499 // SBM2 PARAMETERS
1517 parameter_dump_packet.sy_lfr_s2_bp_p0 = (unsigned char) DEFAULT_SY_LFR_S2_BP_P0;
1500 parameter_dump_packet.sy_lfr_s2_bp_p0 = (unsigned char) DEFAULT_SY_LFR_S2_BP_P0;
1518 parameter_dump_packet.sy_lfr_s2_bp_p1 = (unsigned char) DEFAULT_SY_LFR_S2_BP_P1;
1501 parameter_dump_packet.sy_lfr_s2_bp_p1 = (unsigned char) DEFAULT_SY_LFR_S2_BP_P1;
1519
1502
1520 //************
1503 //************
1521 // FBINS MASKS
1504 // FBINS MASKS
1522 for (k=0; k < BYTES_PER_MASKS_SET; k++)
1505 for (k=0; k < BYTES_PER_MASKS_SET; k++)
1523 {
1506 {
1524 parameter_dump_packet.sy_lfr_fbins_f0_word1[k] = INT8_ALL_F;
1507 parameter_dump_packet.sy_lfr_fbins_f0_word1[k] = INT8_ALL_F;
1525 }
1508 }
1526
1509
1527 // PAS FILTER PARAMETERS
1510 // PAS FILTER PARAMETERS
1528 parameter_dump_packet.pa_rpw_spare8_2 = INIT_CHAR;
1511 parameter_dump_packet.pa_rpw_spare8_2 = INIT_CHAR;
1529 parameter_dump_packet.spare_sy_lfr_pas_filter_enabled = INIT_CHAR;
1512 parameter_dump_packet.spare_sy_lfr_pas_filter_enabled = INIT_CHAR;
1530 parameter_dump_packet.sy_lfr_pas_filter_modulus = DEFAULT_SY_LFR_PAS_FILTER_MODULUS;
1513 parameter_dump_packet.sy_lfr_pas_filter_modulus = DEFAULT_SY_LFR_PAS_FILTER_MODULUS;
1531 floatToChar( DEFAULT_SY_LFR_PAS_FILTER_TBAD, parameter_dump_packet.sy_lfr_pas_filter_tbad );
1514 floatToChar( DEFAULT_SY_LFR_PAS_FILTER_TBAD, parameter_dump_packet.sy_lfr_pas_filter_tbad );
1532 parameter_dump_packet.sy_lfr_pas_filter_offset = DEFAULT_SY_LFR_PAS_FILTER_OFFSET;
1515 parameter_dump_packet.sy_lfr_pas_filter_offset = DEFAULT_SY_LFR_PAS_FILTER_OFFSET;
1533 floatToChar( DEFAULT_SY_LFR_PAS_FILTER_SHIFT, parameter_dump_packet.sy_lfr_pas_filter_shift );
1516 floatToChar( DEFAULT_SY_LFR_PAS_FILTER_SHIFT, parameter_dump_packet.sy_lfr_pas_filter_shift );
1534 floatToChar( DEFAULT_SY_LFR_SC_RW_DELTA_F, parameter_dump_packet.sy_lfr_sc_rw_delta_f );
1517 floatToChar( DEFAULT_SY_LFR_SC_RW_DELTA_F, parameter_dump_packet.sy_lfr_sc_rw_delta_f );
1535
1518
1536 // LFR_RW_MASK
1519 // LFR_RW_MASK
1537 for (k=0; k < BYTES_PER_MASKS_SET; k++)
1520 for (k=0; k < BYTES_PER_MASKS_SET; k++)
1538 {
1521 {
1539 parameter_dump_packet.sy_lfr_rw_mask_f0_word1[k] = INT8_ALL_F;
1522 parameter_dump_packet.sy_lfr_rw_mask_f0_word1[k] = INT8_ALL_F;
1540 }
1523 }
1541
1524
1542 // once the reaction wheels masks have been initialized, they have to be merged with the fbins masks
1525 // once the reaction wheels masks have been initialized, they have to be merged with the fbins masks
1543 merge_fbins_masks();
1526 merge_fbins_masks();
1544 }
1527 }
1545
1528
1546 void init_kcoefficients_dump( void )
1529 void init_kcoefficients_dump( void )
1547 {
1530 {
1548 init_kcoefficients_dump_packet( &kcoefficients_dump_1, PKTNR_1, KCOEFF_BLK_NR_PKT1 );
1531 init_kcoefficients_dump_packet( &kcoefficients_dump_1, PKTNR_1, KCOEFF_BLK_NR_PKT1 );
1549 init_kcoefficients_dump_packet( &kcoefficients_dump_2, PKTNR_2, KCOEFF_BLK_NR_PKT2 );
1532 init_kcoefficients_dump_packet( &kcoefficients_dump_2, PKTNR_2, KCOEFF_BLK_NR_PKT2 );
1550
1533
1551 kcoefficient_node_1.previous = NULL;
1534 kcoefficient_node_1.previous = NULL;
1552 kcoefficient_node_1.next = NULL;
1535 kcoefficient_node_1.next = NULL;
1553 kcoefficient_node_1.sid = TM_CODE_K_DUMP;
1536 kcoefficient_node_1.sid = TM_CODE_K_DUMP;
1554 kcoefficient_node_1.coarseTime = INIT_CHAR;
1537 kcoefficient_node_1.coarseTime = INIT_CHAR;
1555 kcoefficient_node_1.fineTime = INIT_CHAR;
1538 kcoefficient_node_1.fineTime = INIT_CHAR;
1556 kcoefficient_node_1.buffer_address = (int) &kcoefficients_dump_1;
1539 kcoefficient_node_1.buffer_address = (int) &kcoefficients_dump_1;
1557 kcoefficient_node_1.status = INIT_CHAR;
1540 kcoefficient_node_1.status = INIT_CHAR;
1558
1541
1559 kcoefficient_node_2.previous = NULL;
1542 kcoefficient_node_2.previous = NULL;
1560 kcoefficient_node_2.next = NULL;
1543 kcoefficient_node_2.next = NULL;
1561 kcoefficient_node_2.sid = TM_CODE_K_DUMP;
1544 kcoefficient_node_2.sid = TM_CODE_K_DUMP;
1562 kcoefficient_node_2.coarseTime = INIT_CHAR;
1545 kcoefficient_node_2.coarseTime = INIT_CHAR;
1563 kcoefficient_node_2.fineTime = INIT_CHAR;
1546 kcoefficient_node_2.fineTime = INIT_CHAR;
1564 kcoefficient_node_2.buffer_address = (int) &kcoefficients_dump_2;
1547 kcoefficient_node_2.buffer_address = (int) &kcoefficients_dump_2;
1565 kcoefficient_node_2.status = INIT_CHAR;
1548 kcoefficient_node_2.status = INIT_CHAR;
1566 }
1549 }
1567
1550
1568 void init_kcoefficients_dump_packet( Packet_TM_LFR_KCOEFFICIENTS_DUMP_t *kcoefficients_dump, unsigned char pkt_nr, unsigned char blk_nr )
1551 void init_kcoefficients_dump_packet( Packet_TM_LFR_KCOEFFICIENTS_DUMP_t *kcoefficients_dump, unsigned char pkt_nr, unsigned char blk_nr )
1569 {
1552 {
1570 unsigned int k;
1553 unsigned int k;
1571 unsigned int packetLength;
1554 unsigned int packetLength;
1572
1555
1573 packetLength =
1556 packetLength =
1574 ((blk_nr * KCOEFF_BLK_SIZE) + BYTE_POS_KCOEFFICIENTS_PARAMETES) - CCSDS_TC_TM_PACKET_OFFSET; // 4 bytes for the CCSDS header
1557 ((blk_nr * KCOEFF_BLK_SIZE) + BYTE_POS_KCOEFFICIENTS_PARAMETES) - CCSDS_TC_TM_PACKET_OFFSET; // 4 bytes for the CCSDS header
1575
1558
1576 kcoefficients_dump->targetLogicalAddress = CCSDS_DESTINATION_ID;
1559 kcoefficients_dump->targetLogicalAddress = CCSDS_DESTINATION_ID;
1577 kcoefficients_dump->protocolIdentifier = CCSDS_PROTOCOLE_ID;
1560 kcoefficients_dump->protocolIdentifier = CCSDS_PROTOCOLE_ID;
1578 kcoefficients_dump->reserved = CCSDS_RESERVED;
1561 kcoefficients_dump->reserved = CCSDS_RESERVED;
1579 kcoefficients_dump->userApplication = CCSDS_USER_APP;
1562 kcoefficients_dump->userApplication = CCSDS_USER_APP;
1580 kcoefficients_dump->packetID[0] = (unsigned char) (APID_TM_PARAMETER_DUMP >> SHIFT_1_BYTE);
1563 kcoefficients_dump->packetID[0] = (unsigned char) (APID_TM_PARAMETER_DUMP >> SHIFT_1_BYTE);
1581 kcoefficients_dump->packetID[1] = (unsigned char) APID_TM_PARAMETER_DUMP;
1564 kcoefficients_dump->packetID[1] = (unsigned char) APID_TM_PARAMETER_DUMP;
1582 kcoefficients_dump->packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
1565 kcoefficients_dump->packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
1583 kcoefficients_dump->packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT;
1566 kcoefficients_dump->packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT;
1584 kcoefficients_dump->packetLength[0] = (unsigned char) (packetLength >> SHIFT_1_BYTE);
1567 kcoefficients_dump->packetLength[0] = (unsigned char) (packetLength >> SHIFT_1_BYTE);
1585 kcoefficients_dump->packetLength[1] = (unsigned char) packetLength;
1568 kcoefficients_dump->packetLength[1] = (unsigned char) packetLength;
1586 // DATA FIELD HEADER
1569 // DATA FIELD HEADER
1587 kcoefficients_dump->spare1_pusVersion_spare2 = SPARE1_PUSVERSION_SPARE2;
1570 kcoefficients_dump->spare1_pusVersion_spare2 = SPARE1_PUSVERSION_SPARE2;
1588 kcoefficients_dump->serviceType = TM_TYPE_K_DUMP;
1571 kcoefficients_dump->serviceType = TM_TYPE_K_DUMP;
1589 kcoefficients_dump->serviceSubType = TM_SUBTYPE_K_DUMP;
1572 kcoefficients_dump->serviceSubType = TM_SUBTYPE_K_DUMP;
1590 kcoefficients_dump->destinationID= TM_DESTINATION_ID_GROUND;
1573 kcoefficients_dump->destinationID= TM_DESTINATION_ID_GROUND;
1591 kcoefficients_dump->time[BYTE_0] = INIT_CHAR;
1574 kcoefficients_dump->time[BYTE_0] = INIT_CHAR;
1592 kcoefficients_dump->time[BYTE_1] = INIT_CHAR;
1575 kcoefficients_dump->time[BYTE_1] = INIT_CHAR;
1593 kcoefficients_dump->time[BYTE_2] = INIT_CHAR;
1576 kcoefficients_dump->time[BYTE_2] = INIT_CHAR;
1594 kcoefficients_dump->time[BYTE_3] = INIT_CHAR;
1577 kcoefficients_dump->time[BYTE_3] = INIT_CHAR;
1595 kcoefficients_dump->time[BYTE_4] = INIT_CHAR;
1578 kcoefficients_dump->time[BYTE_4] = INIT_CHAR;
1596 kcoefficients_dump->time[BYTE_5] = INIT_CHAR;
1579 kcoefficients_dump->time[BYTE_5] = INIT_CHAR;
1597 kcoefficients_dump->sid = SID_K_DUMP;
1580 kcoefficients_dump->sid = SID_K_DUMP;
1598
1581
1599 kcoefficients_dump->pkt_cnt = KCOEFF_PKTCNT;
1582 kcoefficients_dump->pkt_cnt = KCOEFF_PKTCNT;
1600 kcoefficients_dump->pkt_nr = PKTNR_1;
1583 kcoefficients_dump->pkt_nr = PKTNR_1;
1601 kcoefficients_dump->blk_nr = blk_nr;
1584 kcoefficients_dump->blk_nr = blk_nr;
1602
1585
1603 //******************
1586 //******************
1604 // SOURCE DATA repeated N times with N in [0 .. PA_LFR_KCOEFF_BLK_NR]
1587 // SOURCE DATA repeated N times with N in [0 .. PA_LFR_KCOEFF_BLK_NR]
1605 // one blk is 2 + 4 * 32 = 130 bytes, 30 blks max in one packet (30 * 130 = 3900)
1588 // one blk is 2 + 4 * 32 = 130 bytes, 30 blks max in one packet (30 * 130 = 3900)
1606 for (k=0; k<(KCOEFF_BLK_NR_PKT1 * KCOEFF_BLK_SIZE); k++)
1589 for (k=0; k<(KCOEFF_BLK_NR_PKT1 * KCOEFF_BLK_SIZE); k++)
1607 {
1590 {
1608 kcoefficients_dump->kcoeff_blks[k] = INIT_CHAR;
1591 kcoefficients_dump->kcoeff_blks[k] = INIT_CHAR;
1609 }
1592 }
1610 }
1593 }
1611
1594
1612 void increment_seq_counter_destination_id_dump( unsigned char *packet_sequence_control, unsigned char destination_id )
1595 void increment_seq_counter_destination_id_dump( unsigned char *packet_sequence_control, unsigned char destination_id )
1613 {
1596 {
1614 /** This function increment the packet sequence control parameter of a TC, depending on its destination ID.
1597 /** This function increment the packet sequence control parameter of a TC, depending on its destination ID.
1615 *
1598 *
1616 * @param packet_sequence_control points to the packet sequence control which will be incremented
1599 * @param packet_sequence_control points to the packet sequence control which will be incremented
1617 * @param destination_id is the destination ID of the TM, there is one counter by destination ID
1600 * @param destination_id is the destination ID of the TM, there is one counter by destination ID
1618 *
1601 *
1619 * If the destination ID is not known, a dedicated counter is incremented.
1602 * If the destination ID is not known, a dedicated counter is incremented.
1620 *
1603 *
1621 */
1604 */
1622
1605
1623 unsigned short sequence_cnt;
1606 unsigned short sequence_cnt;
1624 unsigned short segmentation_grouping_flag;
1607 unsigned short segmentation_grouping_flag;
1625 unsigned short new_packet_sequence_control;
1608 unsigned short new_packet_sequence_control;
1626 unsigned char i;
1609 unsigned char i;
1627
1610
1628 switch (destination_id)
1611 switch (destination_id)
1629 {
1612 {
1630 case SID_TC_GROUND:
1613 case SID_TC_GROUND:
1631 i = GROUND;
1614 i = GROUND;
1632 break;
1615 break;
1633 case SID_TC_MISSION_TIMELINE:
1616 case SID_TC_MISSION_TIMELINE:
1634 i = MISSION_TIMELINE;
1617 i = MISSION_TIMELINE;
1635 break;
1618 break;
1636 case SID_TC_TC_SEQUENCES:
1619 case SID_TC_TC_SEQUENCES:
1637 i = TC_SEQUENCES;
1620 i = TC_SEQUENCES;
1638 break;
1621 break;
1639 case SID_TC_RECOVERY_ACTION_CMD:
1622 case SID_TC_RECOVERY_ACTION_CMD:
1640 i = RECOVERY_ACTION_CMD;
1623 i = RECOVERY_ACTION_CMD;
1641 break;
1624 break;
1642 case SID_TC_BACKUP_MISSION_TIMELINE:
1625 case SID_TC_BACKUP_MISSION_TIMELINE:
1643 i = BACKUP_MISSION_TIMELINE;
1626 i = BACKUP_MISSION_TIMELINE;
1644 break;
1627 break;
1645 case SID_TC_DIRECT_CMD:
1628 case SID_TC_DIRECT_CMD:
1646 i = DIRECT_CMD;
1629 i = DIRECT_CMD;
1647 break;
1630 break;
1648 case SID_TC_SPARE_GRD_SRC1:
1631 case SID_TC_SPARE_GRD_SRC1:
1649 i = SPARE_GRD_SRC1;
1632 i = SPARE_GRD_SRC1;
1650 break;
1633 break;
1651 case SID_TC_SPARE_GRD_SRC2:
1634 case SID_TC_SPARE_GRD_SRC2:
1652 i = SPARE_GRD_SRC2;
1635 i = SPARE_GRD_SRC2;
1653 break;
1636 break;
1654 case SID_TC_OBCP:
1637 case SID_TC_OBCP:
1655 i = OBCP;
1638 i = OBCP;
1656 break;
1639 break;
1657 case SID_TC_SYSTEM_CONTROL:
1640 case SID_TC_SYSTEM_CONTROL:
1658 i = SYSTEM_CONTROL;
1641 i = SYSTEM_CONTROL;
1659 break;
1642 break;
1660 case SID_TC_AOCS:
1643 case SID_TC_AOCS:
1661 i = AOCS;
1644 i = AOCS;
1662 break;
1645 break;
1663 case SID_TC_RPW_INTERNAL:
1646 case SID_TC_RPW_INTERNAL:
1664 i = RPW_INTERNAL;
1647 i = RPW_INTERNAL;
1665 break;
1648 break;
1666 default:
1649 default:
1667 i = GROUND;
1650 i = GROUND;
1668 break;
1651 break;
1669 }
1652 }
1670
1653
1671 segmentation_grouping_flag = TM_PACKET_SEQ_CTRL_STANDALONE << SHIFT_1_BYTE;
1654 segmentation_grouping_flag = TM_PACKET_SEQ_CTRL_STANDALONE << SHIFT_1_BYTE;
1672 sequence_cnt = sequenceCounters_TM_DUMP[ i ] & SEQ_CNT_MASK;
1655 sequence_cnt = sequenceCounters_TM_DUMP[ i ] & SEQ_CNT_MASK;
1673
1656
1674 new_packet_sequence_control = segmentation_grouping_flag | sequence_cnt ;
1657 new_packet_sequence_control = segmentation_grouping_flag | sequence_cnt ;
1675
1658
1676 packet_sequence_control[0] = (unsigned char) (new_packet_sequence_control >> SHIFT_1_BYTE);
1659 packet_sequence_control[0] = (unsigned char) (new_packet_sequence_control >> SHIFT_1_BYTE);
1677 packet_sequence_control[1] = (unsigned char) (new_packet_sequence_control );
1660 packet_sequence_control[1] = (unsigned char) (new_packet_sequence_control );
1678
1661
1679 // increment the sequence counter
1662 // increment the sequence counter
1680 if ( sequenceCounters_TM_DUMP[ i ] < SEQ_CNT_MAX )
1663 if ( sequenceCounters_TM_DUMP[ i ] < SEQ_CNT_MAX )
1681 {
1664 {
1682 sequenceCounters_TM_DUMP[ i ] = sequenceCounters_TM_DUMP[ i ] + 1;
1665 sequenceCounters_TM_DUMP[ i ] = sequenceCounters_TM_DUMP[ i ] + 1;
1683 }
1666 }
1684 else
1667 else
1685 {
1668 {
1686 sequenceCounters_TM_DUMP[ i ] = 0;
1669 sequenceCounters_TM_DUMP[ i ] = 0;
1687 }
1670 }
1688 }
1671 }
General Comments 0
You need to be logged in to leave comments. Login now