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

Fork of HG_REPOSITORIES/LPP/INSTRUMENTATION/SOLO_LFR/DEV_PLE

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

TM_LFR_TC_EXE_CORRUPTED: the received crc code is now OK
paul -
r39:45138ed2d482 default
parent child
Show More
Show file before | Show file after | Hide comments
1 NO CONTENT: modified file, binary diff hidden
Show file before | Show file after | Hide comments
@@ -1,86 +1,86
1 1 #ifndef TC_HANDLER_H_INCLUDED
2 2 #define TC_HANDLER_H_INCLUDED
3 3
4 4 #include <rtems.h>
5 5 #include <bsp.h> // for the LEON_Unmask_interrupt function
6 6 #include <stdio.h>
7 7 #include <unistd.h> // for the read call
8 8 #include <sys/ioctl.h> // for the ioctl call
9 9 #include <ccsds_types.h>
10 10 #include <grspw.h>
11 11
12 12 #include "fsw_init.h"
13 13 #include "fsw_misc.h"
14 14
15 15 // MODE PARAMETERS
16 16 extern struct param_sbm1_str param_sbm1;
17 17 extern struct param_sbm2_str param_sbm2;
18 18 extern time_management_regs_t *time_management_regs;
19 19 extern waveform_picker_regs_t *waveform_picker_regs;
20 20 extern gptimer_regs_t *gptimer_regs;
21 21
22 22 //****
23 23 // ISR
24 24 rtems_isr commutation_isr1( rtems_vector_number vector );
25 25 rtems_isr commutation_isr2( rtems_vector_number vector );
26 26
27 27 //**********************
28 28 // GENERAL USE FUNCTIONS
29 29 unsigned int Crc_opt( unsigned char D, unsigned int Chk);
30 30 void initLookUpTableForCRC( void );
31 31 void GetCRCAsTwoBytes(unsigned char* data, unsigned char* crcAsTwoBytes, unsigned int sizeOfData);
32 32 void updateLFRCurrentMode();
33 33
34 34 //*********************
35 35 // ACCEPTANCE FUNCTIONS
36 int TC_acceptance(ccsdsTelecommandPacket_t *TC, unsigned int TC_LEN_RCV, rtems_id queue_id);
37 unsigned char TC_parser(ccsdsTelecommandPacket_t * TMPacket, unsigned int TC_LEN_RCV);
36 int TC_acceptance(ccsdsTelecommandPacket_t *TC, unsigned int TC_LEN_RCV, rtems_id queue_queu_id, rtems_id queue_pkts_id);
37 unsigned char TC_parser(ccsdsTelecommandPacket_t * TCPacket, unsigned int TC_LEN_RCV);
38 38
39 39 //***********
40 40 // RTEMS TASK
41 41 rtems_task recv_task( rtems_task_argument unused );
42 42 rtems_task actn_task( rtems_task_argument unused );
43 43 rtems_task dumb_task( rtems_task_argument unused );
44 44
45 45 //***********
46 46 // TC ACTIONS
47 47 int action_reset(ccsdsTelecommandPacket_t *TC, rtems_id queue_id);
48 48 int action_load_common_par(ccsdsTelecommandPacket_t *TC);
49 49 int action_load_normal_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id);
50 50 int action_load_burst_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id);
51 51 int action_load_sbm1_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id);
52 52 int action_load_sbm2_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id);
53 53 int action_dump_par(ccsdsTelecommandPacket_t *TC);
54 54 int action_enter_mode(ccsdsTelecommandPacket_t *TC, rtems_id queue_id);
55 55 int action_update_info(ccsdsTelecommandPacket_t *TC, rtems_id queue_id);
56 56 int action_enable_calibration(ccsdsTelecommandPacket_t *TC, rtems_id queue_id);
57 57 int action_disable_calibration(ccsdsTelecommandPacket_t *TC, rtems_id queue_id);
58 58 int action_update_time(ccsdsTelecommandPacket_t *TC);
59 59
60 60 // mode transition
61 61 int transition_validation(unsigned char requestedMode);
62 62 int stop_current_mode();
63 63 int enter_mode(unsigned char mode, ccsdsTelecommandPacket_t *TC);
64 64 int enter_standby_mode();
65 65 int enter_normal_mode();
66 66 int enter_burst_mode();
67 67 int enter_sbm1_mode();
68 68 int enter_sbm2_mode();
69 69 int restart_science_tasks();
70 70 int suspend_science_tasks();
71 71
72 72 // other functions
73 73 void update_last_TC_exe(ccsdsTelecommandPacket_t *TC);
74 74 void update_last_TC_rej(ccsdsTelecommandPacket_t *TC);
75 75 void close_action(ccsdsTelecommandPacket_t *TC, int result, rtems_id queue_id);
76 76 //
77 77 int send_tm_lfr_tc_exe_success(ccsdsTelecommandPacket_t *TC, rtems_id queue_id);
78 78 int send_tm_lfr_tc_exe_inconsistent(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char byte_position, unsigned char rcv_value);
79 79 int send_tm_lfr_tc_exe_not_executable(ccsdsTelecommandPacket_t *TC, rtems_id queue_id);
80 80 int send_tm_lfr_tc_exe_not_implemented(ccsdsTelecommandPacket_t *TC, rtems_id queue_id);
81 81 int send_tm_lfr_tc_exe_error(ccsdsTelecommandPacket_t *TC, rtems_id queue_id);
82 82
83 83 #endif // TC_HANDLER_H_INCLUDED
84 84
85 85
86 86
Show file before | Show file after | Hide comments
@@ -1,1472 +1,1476
1 1 #include <tc_handler.h>
2 2 #include <fsw_params.h>
3 3
4 4 char *DumbMessages[6] = {"in DUMB *** default", // RTEMS_EVENT_0
5 5 "in DUMB *** timecode_irq_handler", // RTEMS_EVENT_1
6 6 "in DUMB *** waveforms_isr", // RTEMS_EVENT_2
7 7 "in DUMB *** in SMIQ *** Error sending event to AVF0", // RTEMS_EVENT_3
8 8 "in DUMB *** spectral_matrices_isr *** Error sending event to SMIQ", // RTEMS_EVENT_4
9 9 "in DUMB *** waveforms_simulator_isr" // RTEMS_EVENT_5
10 10 };
11 11
12 12 unsigned char currentTC_LEN_RCV[2]; // SHALL be equal to the current TC packet estimated packet length field
13 13 unsigned char currentTC_COMPUTED_CRC[2];
14 14 unsigned int currentTC_LEN_RCV_AsUnsignedInt;
15 15 unsigned int currentTM_length;
16 16 unsigned char currentTC_processedFlag;
17 17
18 18 unsigned int lookUpTableForCRC[256];
19 19
20 20 //**********************
21 21 // GENERAL USE FUNCTIONS
22 22 unsigned int Crc_opt( unsigned char D, unsigned int Chk)
23 23 {
24 24 return(((Chk << 8) & 0xff00)^lookUpTableForCRC [(((Chk >> 8)^D) & 0x00ff)]);
25 25 }
26 26
27 27 void initLookUpTableForCRC( void )
28 28 {
29 29 unsigned int i;
30 30 unsigned int tmp;
31 31
32 32 for (i=0; i<256; i++)
33 33 {
34 34 tmp = 0;
35 35 if((i & 1) != 0) {
36 36 tmp = tmp ^ 0x1021;
37 37 }
38 38 if((i & 2) != 0) {
39 39 tmp = tmp ^ 0x2042;
40 40 }
41 41 if((i & 4) != 0) {
42 42 tmp = tmp ^ 0x4084;
43 43 }
44 44 if((i & 8) != 0) {
45 45 tmp = tmp ^ 0x8108;
46 46 }
47 47 if((i & 16) != 0) {
48 48 tmp = tmp ^ 0x1231;
49 49 }
50 50 if((i & 32) != 0) {
51 51 tmp = tmp ^ 0x2462;
52 52 }
53 53 if((i & 64) != 0) {
54 54 tmp = tmp ^ 0x48c4;
55 55 }
56 56 if((i & 128) != 0) {
57 57 tmp = tmp ^ 0x9188;
58 58 }
59 59 lookUpTableForCRC[i] = tmp;
60 60 }
61 61 }
62 62
63 63 void GetCRCAsTwoBytes(unsigned char* data, unsigned char* crcAsTwoBytes, unsigned int sizeOfData)
64 64 {
65 65 unsigned int Chk;
66 66 int j;
67 67 Chk = 0xffff; // reset the syndrom to all ones
68 68 for (j=0; j<sizeOfData; j++) {
69 69 Chk = Crc_opt(data[j], Chk);
70 70 }
71 71 crcAsTwoBytes[0] = (unsigned char) (Chk >> 8);
72 72 crcAsTwoBytes[1] = (unsigned char) (Chk & 0x00ff);
73 73 }
74 74
75 75 void updateLFRCurrentMode()
76 76 {
77 77 lfrCurrentMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4;
78 78 }
79 79
80 80 //*********************
81 81 // ACCEPTANCE FUNCTIONS
82 int TC_acceptance(ccsdsTelecommandPacket_t *TC, unsigned int tc_len_recv, rtems_id queue_id)
82 int TC_acceptance(ccsdsTelecommandPacket_t *TC, unsigned int tc_len_recv, rtems_id queue_queu_id, rtems_id queue_pkts_id)
83 83 {
84 84 int ret = 0;
85 85 rtems_status_code status;
86 86 Packet_TM_LFR_TC_EXE_CORRUPTED_t packet;
87 87 unsigned int parserCode = 0;
88 88 unsigned char computed_CRC[2];
89 89 unsigned int packetLength;
90 unsigned char *packetDataField;
90 91
91 92 GetCRCAsTwoBytes( (unsigned char*) TC->packetID, computed_CRC, tc_len_recv + 5 );
92 93 parserCode = TC_parser( TC, tc_len_recv ) ;
93 94 if ( (parserCode == ILLEGAL_APID) | (parserCode == WRONG_LEN_PACKET) | (parserCode == INCOR_CHECKSUM)
94 95 | (parserCode == ILL_TYPE) | (parserCode == ILL_SUBTYPE) | (parserCode == WRONG_APP_DATA) )
95 96 { // generate TM_LFR_TC_EXE_CORRUPTED
96 packetLength = (TC->packetLength[0] * 256) + TC->packetLength[1];
97 packetDataField = (unsigned char *) &TC->headerFlag_pusVersion_Ack; // get the beginning of the data field
98 packetLength = (TC->packetLength[0] * 256) + TC->packetLength[1]; // compute the packet length
99 //
97 100 packet.targetLogicalAddress = CCSDS_DESTINATION_ID;
98 101 packet.protocolIdentifier = CCSDS_PROTOCOLE_ID;
99 102 packet.reserved = DEFAULT_RESERVED;
100 103 packet.userApplication = CCSDS_USER_APP;
101 104 // PACKET HEADER
102 105 packet.packetID[0] = (unsigned char) (TM_PACKET_ID_TC_EXE >> 8);
103 106 packet.packetID[1] = (unsigned char) (TM_PACKET_ID_TC_EXE );
104 107 packet.packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
105 108 packet.packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT;
106 109 packet.packetLength[0] = (unsigned char) (PACKET_LENGTH_TC_EXE_CORRUPTED >> 8);
107 110 packet.packetLength[1] = (unsigned char) (PACKET_LENGTH_TC_EXE_CORRUPTED );
108 111 // DATA FIELD HEADER
109 112 packet.spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
110 113 packet.serviceType = TM_TYPE_TC_EXE;
111 114 packet.serviceSubType = TM_SUBTYPE_EXE_NOK;
112 115 packet.destinationID = TM_DESTINATION_ID_GROUND;
113 116 packet.time[0] = (time_management_regs->coarse_time>>24 );
114 117 packet.time[1] = (time_management_regs->coarse_time>>16 );
115 118 packet.time[2] = (time_management_regs->coarse_time>>8 );
116 119 packet.time[3] = (time_management_regs->coarse_time );
117 120 packet.time[4] = (time_management_regs->fine_time>>8 );
118 121 packet.time[5] = (time_management_regs->fine_time );
119 122 //
120 123 packet.tc_failure_code[0] = (unsigned char) (FAILURE_CODE_CORRUPTED >> 8);
121 124 packet.tc_failure_code[1] = (unsigned char) (FAILURE_CODE_CORRUPTED );
122 125 packet.telecommand_pkt_id[0] = TC->packetID[0];
123 126 packet.telecommand_pkt_id[1] = TC->packetID[1];
124 127 packet.pkt_seq_control[0] = TC->packetSequenceControl[0];
125 128 packet.pkt_seq_control[0] = TC->packetSequenceControl[1];
126 129 packet.tc_service = TC->serviceType;
127 130 packet.tc_subtype = TC->serviceSubType;
128 131 packet.pkt_len_rcv_value[0] = TC->packetLength[0];
129 132 packet.pkt_len_rcv_value[1] = TC->packetLength[1];
130 133 packet.pkt_datafieldsize_cnt[0] = currentTC_LEN_RCV[0];
131 134 packet.pkt_datafieldsize_cnt[1] = currentTC_LEN_RCV[1];
132 packet.rcv_crc[0] = TC->dataAndCRC[packetLength];
133 packet.rcv_crc[1] = TC->dataAndCRC[packetLength];
135 packet.rcv_crc[0] = packetDataField[ packetLength - 1 ];
136 packet.rcv_crc[1] = packetDataField[ packetLength ];
134 137 packet.computed_crc[0] = computed_CRC[0];
135 138 packet.computed_crc[1] = computed_CRC[1];
136 // SEND PACKET
137 status = write( fdSPW, (char *) &packet, PACKET_LENGTH_TC_EXE_CORRUPTED + CCSDS_TC_TM_PACKET_OFFSET + 4);
139 // SEND DATA
140 status = rtems_message_queue_urgent( queue_pkts_id, &packet, PACKET_LENGTH_TC_EXE_CORRUPTED + CCSDS_TC_TM_PACKET_OFFSET + 4);
141 if (status != RTEMS_SUCCESSFUL) {
142 PRINTF("in TC_acceptance *** ERR rtems_message_queue_urgent\n")
143 ret = LFR_DEFAULT;
144 }
138 145 }
139 146 else { // send valid TC to the action launcher
140 status = rtems_message_queue_send( queue_id, TC, tc_len_recv + CCSDS_TC_TM_PACKET_OFFSET + 3);
141 ret = -1;
147 status = rtems_message_queue_send( queue_queu_id, TC, tc_len_recv + CCSDS_TC_TM_PACKET_OFFSET + 3);
148 ret = LFR_SUCCESSFUL;
142 149 }
143 150 return ret;
144 151 }
145 152
146 unsigned char TC_parser(ccsdsTelecommandPacket_t * TMPacket, unsigned int TC_LEN_RCV)
153 unsigned char TC_parser(ccsdsTelecommandPacket_t * TCPacket, unsigned int TC_LEN_RCV)
147 154 {
148 155 unsigned char ret = 0;
149 156 unsigned char pid = 0;
150 157 unsigned char category = 0;
151 158 unsigned int length = 0;
152 159 unsigned char packetType = 0;
153 160 unsigned char packetSubtype = 0;
154 161 unsigned char * CCSDSContent = NULL;
155 162
156 163 // APID check *** APID on 2 bytes
157 pid = ((TMPacket->packetID[0] & 0x07)<<4) + ( (TMPacket->packetID[1]>>4) & 0x0f ); // PID = 11 *** 7 bits xxxxx210 7654xxxx
158 category = (TMPacket->packetID[1] & 0x0f); // PACKET_CATEGORY = 12 *** 4 bits xxxxxxxx xxxx3210
159 length = (TMPacket->packetLength[0] * 256) + TMPacket->packetLength[1];
160 packetType = TMPacket->serviceType;
161 packetSubtype = TMPacket->serviceSubType;
164 pid = ((TCPacket->packetID[0] & 0x07)<<4) + ( (TCPacket->packetID[1]>>4) & 0x0f ); // PID = 11 *** 7 bits xxxxx210 7654xxxx
165 category = (TCPacket->packetID[1] & 0x0f); // PACKET_CATEGORY = 12 *** 4 bits xxxxxxxx xxxx3210
166 length = (TCPacket->packetLength[0] * 256) + TCPacket->packetLength[1];
167 packetType = TCPacket->serviceType;
168 packetSubtype = TCPacket->serviceSubType;
162 169
163 170 if ( pid != CCSDS_PROCESS_ID ) {
164 171 ret = ILLEGAL_APID;
165 172 }
166 173 else if ( category != CCSDS_PACKET_CATEGORY ) {
167 174 ret = ILLEGAL_APID;
168 175 }
169 176 else if (length != TC_LEN_RCV ) { // packet length check
170 177 ret = WRONG_LEN_PACKET; // LEN RCV != SIZE FIELD
171 178 }
172 179 else if ( length >= CCSDS_TC_PKT_MAX_SIZE ) {
173 180 ret = WRONG_LEN_PACKET; // check that the packet does not exceed the MAX size
174 181 }
175 182 else if ( packetType == TC_TYPE_GEN ){ // service type, subtype and packet length check
176 183 switch(packetSubtype){ //subtype, autorized values are 3, 20, 21, 24, 27, 28, 30, 40, 50, 60, 61
177 184 case TC_SUBTYPE_RESET:
178 185 if (length!=(TC_LEN_RESET-CCSDS_TC_TM_PACKET_OFFSET)) {
179 186 ret = WRONG_LEN_PACKET;
180 187 }
181 188 else {
182 189 ret = CCSDS_TM_VALID;
183 190 }
184 191 break;
185 192 case TC_SUBTYPE_LOAD_COMM:
186 193 if (length!=(TC_LEN_LOAD_COMM-CCSDS_TC_TM_PACKET_OFFSET)) {
187 194 ret = WRONG_LEN_PACKET;
188 195 }
189 196 else {
190 197 ret = CCSDS_TM_VALID;
191 198 }
192 199 break;
193 200 case TC_SUBTYPE_LOAD_NORM:
194 201 if (length!=(TC_LEN_LOAD_NORM-CCSDS_TC_TM_PACKET_OFFSET)) {
195 202 ret = WRONG_LEN_PACKET;
196 203 }
197 204 else {
198 205 ret = CCSDS_TM_VALID;
199 206 }
200 207 break;
201 208 case TC_SUBTYPE_LOAD_BURST:
202 209 if (length!=(TC_LEN_LOAD_BURST-CCSDS_TC_TM_PACKET_OFFSET)) {
203 210 ret = WRONG_LEN_PACKET;
204 211 }
205 212 else {
206 213 ret = CCSDS_TM_VALID;
207 214 }
208 215 break;
209 216 case TC_SUBTYPE_LOAD_SBM1:
210 217 if (length!=(TC_LEN_LOAD_SBM1-CCSDS_TC_TM_PACKET_OFFSET)) {
211 218 ret = WRONG_LEN_PACKET;
212 219 }
213 220 else {
214 221 ret = CCSDS_TM_VALID;
215 222 }
216 223 break;
217 224 case TC_SUBTYPE_LOAD_SBM2:
218 225 if (length!=(TC_LEN_LOAD_SBM2-CCSDS_TC_TM_PACKET_OFFSET)) {
219 226 ret = WRONG_LEN_PACKET;
220 227 }
221 228 else {
222 229 ret = CCSDS_TM_VALID;
223 230 }
224 231 break;
225 232 case TC_SUBTYPE_DUMP:
226 233 if (length!=(TC_LEN_DUMP-CCSDS_TC_TM_PACKET_OFFSET)) {
227 234 ret = WRONG_LEN_PACKET;
228 235 }
229 236 else {
230 237 ret = CCSDS_TM_VALID;
231 238 }
232 239 break;
233 240 case TC_SUBTYPE_ENTER:
234 241 if (length!=(TC_LEN_ENTER-CCSDS_TC_TM_PACKET_OFFSET)) {
235 242 ret = WRONG_LEN_PACKET;
236 243 }
237 244 else {
238 245 ret = CCSDS_TM_VALID;
239 246 }
240 247 break;
241 248 case TC_SUBTYPE_UPDT_INFO:
242 249 if (length!=(TC_LEN_UPDT_INFO-CCSDS_TC_TM_PACKET_OFFSET)) {
243 250 ret = WRONG_LEN_PACKET;
244 251 }
245 252 else {
246 253 ret = CCSDS_TM_VALID;
247 254 }
248 255 break;
249 256 case TC_SUBTYPE_EN_CAL:
250 257 if (length!=(TC_LEN_EN_CAL-CCSDS_TC_TM_PACKET_OFFSET)) {
251 258 ret = WRONG_LEN_PACKET;
252 259 }
253 260 else {
254 261 ret = CCSDS_TM_VALID;
255 262 }
256 263 break;
257 264 case TC_SUBTYPE_DIS_CAL:
258 265 if (length!=(TC_LEN_DIS_CAL-CCSDS_TC_TM_PACKET_OFFSET)) {
259 266 ret = WRONG_LEN_PACKET;
260 267 }
261 268 else {
262 269 ret = CCSDS_TM_VALID;
263 270 }
264 271 break;
265 272 default:
266 273 ret = ILL_SUBTYPE;
267 274 break;
268 275 }
269 276 }
270 277 else if ( packetType == TC_TYPE_TIME ){
271 278 if (packetSubtype!=TC_SUBTYPE_UPDT_TIME) {
272 279 ret = ILL_SUBTYPE;
273 280 }
274 281 else if (length!=(TC_LEN_UPDT_TIME-CCSDS_TC_TM_PACKET_OFFSET)) {
275 282 ret = WRONG_LEN_PACKET;
276 283 }
277 284 else {
278 285 ret = CCSDS_TM_VALID;
279 286 }
280 287 }
281 288 else {
282 289 ret = ILL_TYPE;
283 290 }
284 291
285 292 // source ID check // Source ID not documented in the ICD
286 293
287 294 // packet error control, CRC check
288 295 if ( ret == CCSDS_TM_VALID ) {
289 CCSDSContent = (unsigned char*) TMPacket->packetID;
296 CCSDSContent = (unsigned char*) TCPacket->packetID;
290 297 GetCRCAsTwoBytes(CCSDSContent, currentTC_COMPUTED_CRC, length + CCSDS_TC_TM_PACKET_OFFSET - 2); // 2 CRC bytes removed from the calculation of the CRC
291 298 if (currentTC_COMPUTED_CRC[0] != CCSDSContent[length + CCSDS_TC_TM_PACKET_OFFSET -2]) {
292 299 ret = INCOR_CHECKSUM;
293 300 }
294 301 else if (currentTC_COMPUTED_CRC[1] != CCSDSContent[length + CCSDS_TC_TM_PACKET_OFFSET -1]) {
295 302 ret = INCOR_CHECKSUM;
296 303 }
297 304 else {
298 305 ret = CCSDS_TM_VALID;
299 306 }
300 307 }
301 308
302 309 return ret;
303 310 }
304 311
305 312 //***********
306 313 // RTEMS TASK
307 314 rtems_task recv_task( rtems_task_argument unused )
308 315 {
309 316 int len = 0;
310 317 unsigned int i = 0;
311 unsigned int data_length = 0;
312 318 ccsdsTelecommandPacket_t currentTC;
313 319 char data[100];
314 320 rtems_status_code status;
315 rtems_id queue_id;
321 rtems_id queue_queu_id;
322 rtems_id queue_pkts_id;
316 323
317 324 for(i=0; i<100; i++) data[i] = 0;
318 325
319 status = rtems_message_queue_ident( misc_name[QUEUE_QUEU], 0, &queue_id );
326 status = rtems_message_queue_ident( misc_name[QUEUE_QUEU], 0, &queue_queu_id );
320 327 if (status != RTEMS_SUCCESSFUL)
321 328 {
322 PRINTF1("in RECV *** ERR getting queue id, %d\n", status)
329 PRINTF1("in RECV *** ERR getting queue_queu id, %d\n", status)
330 }
331
332 status = rtems_message_queue_ident( misc_name[QUEUE_PKTS], 0, &queue_pkts_id );
333 if (status != RTEMS_SUCCESSFUL)
334 {
335 PRINTF1("in RECV *** ERR getting queue_pkts id, %d\n", status)
323 336 }
324 337
325 338 BOOT_PRINTF("in RECV *** \n")
326 339
327 340 while(1)
328 341 {
329 342 len = read(fdSPW, (char*) &currentTC, CCSDS_TC_PKT_MAX_SIZE); // the call to read is blocking
330 343 if (len == -1){ // error during the read call
331 344 PRINTF("In RECV *** last read call returned -1\n")
332 //if (rtems_event_send( Task_id[TASKID_SPIQ], SPW_LINKERR_EVENT ) != RTEMS_SUCCESSFUL) {
333 // PRINTF("IN RECV *** Error: rtems_event_send SPW_LINKERR_EVENT\n")
334 //}
335 //if (rtems_task_suspend(RTEMS_SELF) != RTEMS_SUCCESSFUL) {
336 // PRINTF("In RECV *** Error: rtems_task_suspend(RTEMS_SELF)\n")
337 //}
338 345 }
339 346 else {
340 347 if ( (len+1) < CCSDS_TC_PKT_MIN_SIZE ) {
341 348 PRINTF("In RECV *** packet lenght too short\n")
342 349 }
343 350 else {
344 351 currentTC_LEN_RCV[0] = 0x00;
345 352 currentTC_LEN_RCV[1] = (unsigned char) (len - CCSDS_TC_TM_PACKET_OFFSET - 3); // build the corresponding packet size field
346 353 currentTC_LEN_RCV_AsUnsignedInt = (unsigned int) (len - CCSDS_TC_TM_PACKET_OFFSET - 3); // => -3 is for Prot ID, Reserved and User App bytes
347 // CHECK THE TC AND BUILD THE APPROPRIATE TM
348 data_length = TC_acceptance(&currentTC, currentTC_LEN_RCV_AsUnsignedInt, queue_id);
349 if (data_length!=-1)
350 {
351 }
354 // CHECK THE TC
355 TC_acceptance(&currentTC, currentTC_LEN_RCV_AsUnsignedInt, queue_queu_id, queue_pkts_id);
352 356 }
353 357 }
354 358 }
355 359 }
356 360
357 361 rtems_task actn_task( rtems_task_argument unused )
358 362 {
359 363 int result;
360 364 rtems_status_code status; // RTEMS status code
361 365 ccsdsTelecommandPacket_t TC; // TC sent to the ACTN task
362 366 size_t size; // size of the incoming TC packet
363 367 unsigned char subtype; // subtype of the current TC packet
364 368 rtems_id queue_rcv_id;
365 369 rtems_id queue_snd_id;
366 370
367 371 status = rtems_message_queue_ident( misc_name[QUEUE_QUEU], 0, &queue_rcv_id );
368 372 if (status != RTEMS_SUCCESSFUL)
369 373 {
370 374 PRINTF1("in ACTN *** ERR getting queue_rcv_id %d\n", status)
371 375 }
372 376
373 377 status = rtems_message_queue_ident( misc_name[QUEUE_PKTS], 0, &queue_snd_id );
374 378 if (status != RTEMS_SUCCESSFUL)
375 379 {
376 380 PRINTF1("in ACTN *** ERR getting queue_snd_id %d\n", status)
377 381 }
378 382
379 383 result = LFR_SUCCESSFUL;
380 384 subtype = 0; // subtype of the current TC packet
381 385
382 386 BOOT_PRINTF("in ACTN *** \n")
383 387
384 388 while(1)
385 389 {
386 390 status = rtems_message_queue_receive( queue_rcv_id, (char*) &TC, &size,
387 391 RTEMS_WAIT, RTEMS_NO_TIMEOUT);
388 392 if (status!=RTEMS_SUCCESSFUL) PRINTF1("ERR *** in task ACTN *** error receiving a message, code %d \n", status)
389 393 else
390 394 {
391 395 subtype = TC.serviceSubType;
392 396 switch(subtype)
393 397 {
394 398 case TC_SUBTYPE_RESET:
395 399 result = action_reset( &TC, queue_snd_id );
396 400 close_action( &TC, result, queue_snd_id );
397 401 break;
398 402 //
399 403 case TC_SUBTYPE_LOAD_COMM:
400 404 result = action_load_common_par( &TC );
401 405 close_action( &TC, result, queue_snd_id );
402 406 break;
403 407 //
404 408 case TC_SUBTYPE_LOAD_NORM:
405 409 result = action_load_normal_par( &TC, queue_snd_id );
406 410 close_action( &TC, result, queue_snd_id );
407 411 break;
408 412 //
409 413 case TC_SUBTYPE_LOAD_BURST:
410 414 result = action_load_burst_par( &TC, queue_snd_id );
411 415 close_action( &TC, result, queue_snd_id );
412 416 break;
413 417 //
414 418 case TC_SUBTYPE_LOAD_SBM1:
415 419 result = action_load_sbm1_par( &TC, queue_snd_id );
416 420 close_action( &TC, result, queue_snd_id );
417 421 break;
418 422 //
419 423 case TC_SUBTYPE_LOAD_SBM2:
420 424 result = action_load_sbm2_par( &TC, queue_snd_id );
421 425 close_action( &TC, result, queue_snd_id );
422 426 break;
423 427 //
424 428 case TC_SUBTYPE_DUMP:
425 429 result = action_dump_par( &TC );
426 430 close_action( &TC, result, queue_snd_id );
427 431 break;
428 432 //
429 433 case TC_SUBTYPE_ENTER:
430 434 result = action_enter_mode( &TC, queue_snd_id );
431 435 close_action( &TC, result, queue_snd_id );
432 436 break;
433 437 //
434 438 case TC_SUBTYPE_UPDT_INFO:
435 439 result = action_update_info( &TC, queue_snd_id );
436 440 close_action( &TC, result, queue_snd_id );
437 441 break;
438 442 //
439 443 case TC_SUBTYPE_EN_CAL:
440 444 result = action_enable_calibration( &TC, queue_snd_id );
441 445 close_action( &TC, result, queue_snd_id );
442 446 break;
443 447 //
444 448 case TC_SUBTYPE_DIS_CAL:
445 449 result = action_disable_calibration( &TC, queue_snd_id );
446 450 close_action( &TC, result, queue_snd_id );
447 451 break;
448 452 //
449 453 case TC_SUBTYPE_UPDT_TIME:
450 454 result = action_update_time( &TC );
451 455 close_action( &TC, result, queue_snd_id );
452 456 break;
453 457 //
454 458 default:
455 459 break;
456 460 }
457 461 }
458 462 }
459 463 }
460 464
461 465 rtems_task dumb_task( rtems_task_argument unused )
462 466 {
463 467 unsigned int i;
464 468 unsigned int intEventOut;
465 469 unsigned int coarse_time = 0;
466 470 unsigned int fine_time = 0;
467 471 rtems_event_set event_out;
468 472
469 473 BOOT_PRINTF("in DUMB *** \n")
470 474
471 475 while(1){
472 476 rtems_event_receive(RTEMS_EVENT_0 | RTEMS_EVENT_1 | RTEMS_EVENT_2 | RTEMS_EVENT_3 | RTEMS_EVENT_4 | RTEMS_EVENT_5,
473 477 RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT
474 478 intEventOut = (unsigned int) event_out;
475 479 for ( i=0; i<32; i++)
476 480 {
477 481 if ( ((intEventOut >> i) & 0x0001) != 0)
478 482 {
479 483 coarse_time = time_management_regs->coarse_time;
480 484 fine_time = time_management_regs->fine_time;
481 485 printf("in DUMB *** time = coarse: %x, fine: %x, %s\n", coarse_time, fine_time, DumbMessages[i]);
482 486 }
483 487 }
484 488 }
485 489 }
486 490
487 491 //***********
488 492 // TC ACTIONS
489 493
490 494 int action_reset(ccsdsTelecommandPacket_t *TC, rtems_id queue_id)
491 495 {
492 496 send_tm_lfr_tc_exe_not_implemented( TC, queue_id );
493 497 return LFR_DEFAULT;
494 498 }
495 499
496 500 int action_load_common_par(ccsdsTelecommandPacket_t *TC)
497 501 {
498 502 parameter_dump_packet.unused0 = TC->dataAndCRC[0];
499 503 parameter_dump_packet.bw_sp0_sp1_r0_r1 = TC->dataAndCRC[1];
500 504
501 505 set_wfp_data_shaping(parameter_dump_packet.bw_sp0_sp1_r0_r1);
502 506
503 507 return LFR_SUCCESSFUL;
504 508 }
505 509
506 510 int action_load_normal_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id)
507 511 {
508 512 int result;
509 513 unsigned int tmp;
510 514
511 515 result = LFR_SUCCESSFUL;
512 516
513 517 if ( lfrCurrentMode == LFR_MODE_NORMAL ) {
514 518 send_tm_lfr_tc_exe_not_executable( TC, queue_id );
515 519 result = LFR_DEFAULT;
516 520 }
517 521 else {
518 522 // sy_lfr_n_swf_l
519 523 parameter_dump_packet.sy_lfr_n_swf_l[0] = TC->dataAndCRC[0];
520 524 parameter_dump_packet.sy_lfr_n_swf_l[1] = TC->dataAndCRC[1];
521 525
522 526 // sy_lfr_n_swf_p
523 527 tmp = ( unsigned int ) floor(
524 528 (TC->dataAndCRC[2] * 256
525 529 + TC->dataAndCRC[3])/8
526 530 ) * 8;
527 531 if ( (tmp < 16) || (tmp>65528) )
528 532 {
529 533 send_tm_lfr_tc_exe_inconsistent( TC, queue_id, 12, TC->dataAndCRC[2]);
530 534 send_tm_lfr_tc_exe_inconsistent( TC, queue_id, 13, TC->dataAndCRC[3]);
531 535 result = LFR_DEFAULT;
532 536 }
533 537 else
534 538 {
535 539 parameter_dump_packet.sy_lfr_n_swf_p[0] = (unsigned char) (tmp >> 8);
536 540 parameter_dump_packet.sy_lfr_n_swf_p[1] = (unsigned char) (tmp );
537 541 }
538 542
539 543 // sy_lfr_n_asm_p
540 544 parameter_dump_packet.sy_lfr_n_asm_p[0] = TC->dataAndCRC[4];
541 545 parameter_dump_packet.sy_lfr_n_asm_p[1] = TC->dataAndCRC[5];
542 546
543 547 // sy_lfr_n_bp_p0
544 548 parameter_dump_packet.sy_lfr_n_bp_p0 = TC->dataAndCRC[6];
545 549
546 550 // sy_lfr_n_bp_p1
547 551 parameter_dump_packet.sy_lfr_n_bp_p1 = TC->dataAndCRC[7];
548 552 }
549 553
550 554 return result;
551 555 }
552 556
553 557 int action_load_burst_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id)
554 558 {
555 559 int result;
556 560 unsigned char lfrMode;
557 561
558 562 result = LFR_DEFAULT;
559 563 lfrMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4;
560 564
561 565 if ( lfrMode == LFR_MODE_BURST ) {
562 566 send_tm_lfr_tc_exe_not_executable( TC, queue_id );
563 567 result = LFR_DEFAULT;
564 568 }
565 569 else {
566 570 parameter_dump_packet.sy_lfr_b_bp_p0 = TC->dataAndCRC[0];
567 571 parameter_dump_packet.sy_lfr_b_bp_p1 = TC->dataAndCRC[1];
568 572
569 573 result = LFR_SUCCESSFUL;
570 574 }
571 575
572 576 return result;
573 577 }
574 578
575 579 int action_load_sbm1_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id)
576 580 {
577 581 int result;
578 582 unsigned char lfrMode;
579 583
580 584 result = LFR_DEFAULT;
581 585 lfrMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4;
582 586
583 587 if ( lfrMode == LFR_MODE_SBM1 ) {
584 588 send_tm_lfr_tc_exe_not_executable( TC, queue_id );
585 589 result = LFR_DEFAULT;
586 590 }
587 591 else {
588 592 parameter_dump_packet.sy_lfr_s1_bp_p0 = TC->dataAndCRC[0];
589 593 parameter_dump_packet.sy_lfr_s1_bp_p1 = TC->dataAndCRC[1];
590 594
591 595 result = LFR_SUCCESSFUL;
592 596 }
593 597
594 598 return result;
595 599 }
596 600
597 601 int action_load_sbm2_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id)
598 602 {
599 603 int result;
600 604 unsigned char lfrMode;
601 605
602 606 result = LFR_DEFAULT;
603 607 lfrMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4;
604 608
605 609 if ( lfrMode == LFR_MODE_SBM2 ) {
606 610 send_tm_lfr_tc_exe_not_executable( TC, queue_id );
607 611 result = LFR_DEFAULT;
608 612 }
609 613 else {
610 614 parameter_dump_packet.sy_lfr_s2_bp_p0 = TC->dataAndCRC[0];
611 615 parameter_dump_packet.sy_lfr_s2_bp_p1 = TC->dataAndCRC[1];
612 616
613 617 result = LFR_SUCCESSFUL;
614 618 }
615 619
616 620 return result;
617 621 }
618 622
619 623 int action_dump_par(ccsdsTelecommandPacket_t *TC)
620 624 {
621 625 int status;
622 626 // send parameter dump packet
623 627 status = write(fdSPW, (char *) &parameter_dump_packet,
624 628 PACKET_LENGTH_PARAMETER_DUMP + CCSDS_TC_TM_PACKET_OFFSET + 4);
625 629 if (status == -1)
626 630 {
627 631 PRINTF1("in action_dump *** ERR sending packet, code %d", status)
628 632 status = RTEMS_UNSATISFIED;
629 633 }
630 634 else
631 635 {
632 636 status = RTEMS_SUCCESSFUL;
633 637 }
634 638
635 639 return status;
636 640 }
637 641
638 642 int action_enter_mode(ccsdsTelecommandPacket_t *TC, rtems_id queue_id)
639 643 {
640 644 rtems_status_code status;
641 645 unsigned char requestedMode;
642 646
643 647 requestedMode = TC->dataAndCRC[1];
644 648
645 649 if ( (requestedMode != LFR_MODE_STANDBY)
646 650 && (requestedMode != LFR_MODE_NORMAL) && (requestedMode != LFR_MODE_BURST)
647 651 && (requestedMode != LFR_MODE_SBM1) && (requestedMode != LFR_MODE_SBM2) )
648 652 {
649 653 status = RTEMS_UNSATISFIED;
650 654 send_tm_lfr_tc_exe_inconsistent( TC, queue_id, BYTE_POS_CP_LFR_MODE, requestedMode );
651 655 }
652 656 else
653 657 {
654 658 printf("try to enter mode %d\n", requestedMode);
655 659
656 660 #ifdef PRINT_TASK_STATISTICS
657 661 if (requestedMode != LFR_MODE_STANDBY)
658 662 {
659 663 rtems_cpu_usage_reset();
660 664 maxCount = 0;
661 665 }
662 666 #endif
663 667
664 668 status = transition_validation(requestedMode);
665 669
666 670 if ( status == LFR_SUCCESSFUL ) {
667 671 if ( lfrCurrentMode != LFR_MODE_STANDBY)
668 672 {
669 673 status = stop_current_mode();
670 674 }
671 675 if (status != RTEMS_SUCCESSFUL)
672 676 {
673 677 PRINTF("ERR *** in action_enter *** stop_current_mode\n")
674 678 }
675 679 status = enter_mode(requestedMode, TC);
676 680 }
677 681 else
678 682 {
679 683 PRINTF("ERR *** in action_enter *** transition rejected\n")
680 684 send_tm_lfr_tc_exe_not_executable( TC, queue_id );
681 685 }
682 686 }
683 687
684 688 return status;
685 689 }
686 690
687 691 int action_update_info(ccsdsTelecommandPacket_t *TC, rtems_id queue_id) {
688 692 unsigned int val;
689 693 int result;
690 694 unsigned char lfrMode;
691 695
692 696 result = LFR_DEFAULT;
693 697 lfrMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4;
694 698
695 699 if ( (lfrMode == LFR_MODE_STANDBY) ) {
696 700 send_tm_lfr_tc_exe_not_implemented( TC, queue_id );
697 701 result = LFR_DEFAULT;
698 702 }
699 703 else {
700 704 val = housekeeping_packet.hk_lfr_update_info_tc_cnt[0] * 256
701 705 + housekeeping_packet.hk_lfr_update_info_tc_cnt[1];
702 706 val++;
703 707 housekeeping_packet.hk_lfr_update_info_tc_cnt[0] = (unsigned char) (val >> 8);
704 708 housekeeping_packet.hk_lfr_update_info_tc_cnt[1] = (unsigned char) (val);
705 709 result = LFR_SUCCESSFUL;
706 710 }
707 711
708 712 return result;
709 713 }
710 714
711 715 int action_enable_calibration(ccsdsTelecommandPacket_t *TC, rtems_id queue_id)
712 716 {
713 717 int result;
714 718 unsigned char lfrMode;
715 719
716 720 result = LFR_DEFAULT;
717 721 lfrMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4;
718 722
719 723 if ( (lfrMode == LFR_MODE_STANDBY) | (lfrMode == LFR_MODE_BURST) | (lfrMode == LFR_MODE_SBM2) ) {
720 724 send_tm_lfr_tc_exe_not_executable( TC, queue_id );
721 725 result = LFR_DEFAULT;
722 726 }
723 727 else {
724 728 send_tm_lfr_tc_exe_not_implemented( TC, queue_id );
725 729 result = LFR_DEFAULT;
726 730 }
727 731 return result;
728 732 }
729 733
730 734 int action_disable_calibration(ccsdsTelecommandPacket_t *TC, rtems_id queue_id)
731 735 {
732 736 int result;
733 737 unsigned char lfrMode;
734 738
735 739 result = LFR_DEFAULT;
736 740 lfrMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4;
737 741
738 742 if ( (lfrMode == LFR_MODE_STANDBY) | (lfrMode == LFR_MODE_BURST) | (lfrMode == LFR_MODE_SBM2) ) {
739 743 send_tm_lfr_tc_exe_not_executable( TC, queue_id );
740 744 result = LFR_DEFAULT;
741 745 }
742 746 else {
743 747 send_tm_lfr_tc_exe_not_implemented( TC, queue_id );
744 748 result = LFR_DEFAULT;
745 749 }
746 750 return result;
747 751 }
748 752
749 753 int action_update_time(ccsdsTelecommandPacket_t *TC)
750 754 {
751 755 unsigned int val;
752 756
753 757 time_management_regs->coarse_time_load = (TC->dataAndCRC[0] << 24)
754 758 + (TC->dataAndCRC[1] << 16)
755 759 + (TC->dataAndCRC[2] << 8)
756 760 + TC->dataAndCRC[3];
757 761 val = housekeeping_packet.hk_lfr_update_time_tc_cnt[0] * 256
758 762 + housekeeping_packet.hk_lfr_update_time_tc_cnt[1];
759 763 val++;
760 764 housekeeping_packet.hk_lfr_update_time_tc_cnt[0] = (unsigned char) (val >> 8);
761 765 housekeeping_packet.hk_lfr_update_time_tc_cnt[1] = (unsigned char) (val);
762 766 time_management_regs->ctrl = time_management_regs->ctrl | 1;
763 767
764 768 return LFR_SUCCESSFUL;
765 769 }
766 770
767 771 //*******************
768 772 // ENTERING THE MODES
769 773
770 774 int transition_validation(unsigned char requestedMode)
771 775 {
772 776 int status;
773 777
774 778 switch (requestedMode)
775 779 {
776 780 case LFR_MODE_STANDBY:
777 781 if ( lfrCurrentMode == LFR_MODE_STANDBY ) {
778 782 status = LFR_DEFAULT;
779 783 }
780 784 else
781 785 {
782 786 status = LFR_SUCCESSFUL;
783 787 }
784 788 break;
785 789 case LFR_MODE_NORMAL:
786 790 if ( lfrCurrentMode == LFR_MODE_NORMAL ) {
787 791 status = LFR_DEFAULT;
788 792 }
789 793 else {
790 794 status = LFR_SUCCESSFUL;
791 795 }
792 796 break;
793 797 case LFR_MODE_BURST:
794 798 if ( lfrCurrentMode == LFR_MODE_BURST ) {
795 799 status = LFR_DEFAULT;
796 800 }
797 801 else {
798 802 status = LFR_SUCCESSFUL;
799 803 }
800 804 break;
801 805 case LFR_MODE_SBM1:
802 806 if ( lfrCurrentMode == LFR_MODE_SBM1 ) {
803 807 status = LFR_DEFAULT;
804 808 }
805 809 else {
806 810 status = LFR_SUCCESSFUL;
807 811 }
808 812 break;
809 813 case LFR_MODE_SBM2:
810 814 if ( lfrCurrentMode == LFR_MODE_SBM2 ) {
811 815 status = LFR_DEFAULT;
812 816 }
813 817 else {
814 818 status = LFR_SUCCESSFUL;
815 819 }
816 820 break;
817 821 default:
818 822 status = LFR_DEFAULT;
819 823 break;
820 824 }
821 825
822 826 return status;
823 827 }
824 828
825 829 int stop_current_mode()
826 830 {
827 831 rtems_status_code status;
828 832
829 833 status = RTEMS_SUCCESSFUL;
830 834
831 835 // mask all IRQ lines related to signal processing
832 836 LEON_Mask_interrupt( IRQ_SM ); // mask spectral matrices interrupt (coming from the timer VHDL IP)
833 837 LEON_Clear_interrupt( IRQ_SM ); // clear spectral matrices interrupt (coming from the timer VHDL IP)
834 838
835 839 #ifdef GSA
836 840 LEON_Mask_interrupt( IRQ_WF ); // mask waveform interrupt (coming from the timer VHDL IP)
837 841 LEON_Clear_interrupt( IRQ_WF ); // clear waveform interrupt (coming from the timer VHDL IP)
838 842 timer_stop( (gptimer_regs_t*) REGS_ADDR_GPTIMER, TIMER_WF_SIMULATOR );
839 843 #else
840 844 LEON_Mask_interrupt( IRQ_WAVEFORM_PICKER ); // mask waveform picker interrupt
841 845 LEON_Clear_interrupt( IRQ_WAVEFORM_PICKER ); // clear waveform picker interrupt
842 846 LEON_Mask_interrupt( IRQ_SPECTRAL_MATRIX ); // mask spectral matrix interrupt
843 847 LEON_Clear_interrupt( IRQ_SPECTRAL_MATRIX ); // clear spectral matrix interrupt
844 848 LEON_Mask_interrupt( IRQ_SM ); // for SM simulation
845 849 LEON_Clear_interrupt( IRQ_SM ); // for SM simulation
846 850 #endif
847 851 //**********************
848 852 // suspend several tasks
849 853 if (lfrCurrentMode != LFR_MODE_STANDBY) {
850 854 suspend_science_tasks();
851 855 }
852 856
853 857 if (status != RTEMS_SUCCESSFUL)
854 858 {
855 859 PRINTF("ERR *** in stop_current_mode *** suspending tasks\n")
856 860 }
857 861
858 862 //*************************
859 863 // initialize the registers
860 864 #ifdef GSA
861 865 #else
862 866 reset_wfp_burst_enable(); // reset burst and enable bits
863 867 reset_wfp_status(); // reset all the status bits
864 868 #endif
865 869
866 870 return status;
867 871 }
868 872
869 873 int enter_mode(unsigned char mode, ccsdsTelecommandPacket_t *TC )
870 874 {
871 875 rtems_status_code status;
872 876
873 877 status = RTEMS_UNSATISFIED;
874 878
875 879 housekeeping_packet.lfr_status_word[0] = (unsigned char) ((mode << 4) + 0x0d);
876 880 lfrCurrentMode = mode;
877 881
878 882 switch(mode){
879 883 case LFR_MODE_STANDBY:
880 884 status = enter_standby_mode( TC );
881 885 break;
882 886 case LFR_MODE_NORMAL:
883 887 status = enter_normal_mode( TC );
884 888 break;
885 889 case LFR_MODE_BURST:
886 890 status = enter_burst_mode( TC );
887 891 break;
888 892 case LFR_MODE_SBM1:
889 893 status = enter_sbm1_mode( TC );
890 894 break;
891 895 case LFR_MODE_SBM2:
892 896 status = enter_sbm2_mode( TC );
893 897 break;
894 898 default:
895 899 status = RTEMS_UNSATISFIED;
896 900 }
897 901
898 902 if (status != RTEMS_SUCCESSFUL)
899 903 {
900 904 PRINTF("in enter_mode *** ERR\n")
901 905 status = RTEMS_UNSATISFIED;
902 906 }
903 907
904 908 return status;
905 909 }
906 910
907 911 int enter_standby_mode()
908 912 {
909 913 reset_waveform_picker_regs();
910 914
911 915 PRINTF1("maxCount = %d\n", maxCount)
912 916
913 917 #ifdef PRINT_TASK_STATISTICS
914 918 rtems_cpu_usage_report();
915 919 #endif
916 920
917 921 #ifdef PRINT_STACK_REPORT
918 922 rtems_stack_checker_report_usage();
919 923 #endif
920 924
921 925 return LFR_SUCCESSFUL;
922 926 }
923 927
924 928 int enter_normal_mode()
925 929 {
926 930 rtems_status_code status;
927 931
928 932 status = restart_science_tasks();
929 933
930 934 #ifdef GSA
931 935 timer_start( (gptimer_regs_t*) REGS_ADDR_GPTIMER, TIMER_WF_SIMULATOR );
932 936 timer_start( (gptimer_regs_t*) REGS_ADDR_GPTIMER, TIMER_SM_SIMULATOR );
933 937 LEON_Clear_interrupt( IRQ_WF );
934 938 LEON_Unmask_interrupt( IRQ_WF );
935 939 //
936 940 set_local_nb_interrupt_f0_MAX();
937 941 LEON_Clear_interrupt( IRQ_SM ); // the IRQ_SM seems to be incompatible with the IRQ_WF on the xilinx board
938 942 LEON_Unmask_interrupt( IRQ_SM );
939 943 #else
940 944 //****************
941 945 // waveform picker
942 946 LEON_Clear_interrupt( IRQ_WAVEFORM_PICKER );
943 947 LEON_Unmask_interrupt( IRQ_WAVEFORM_PICKER );
944 948 reset_waveform_picker_regs();
945 949 set_wfp_burst_enable_register(LFR_MODE_NORMAL);
946 950 //****************
947 951 // spectral matrix
948 952 // set_local_nb_interrupt_f0_MAX();
949 953 // LEON_Clear_interrupt( IRQ_SPECTRAL_MATRIX ); // the IRQ_SM seems to be incompatible with the IRQ_WF on the xilinx board
950 954 // LEON_Unmask_interrupt( IRQ_SPECTRAL_MATRIX );
951 955 // spectral_matrix_regs->config = 0x01;
952 956 // spectral_matrix_regs->status = 0x00;
953 957 #endif
954 958
955 959 return status;
956 960 }
957 961
958 962 int enter_burst_mode()
959 963 {
960 964 rtems_status_code status;
961 965
962 966 status = restart_science_tasks();
963 967
964 968 #ifdef GSA
965 969 LEON_Unmask_interrupt( IRQ_SM );
966 970 #else
967 971 LEON_Clear_interrupt( IRQ_WAVEFORM_PICKER );
968 972 LEON_Unmask_interrupt( IRQ_WAVEFORM_PICKER );
969 973 reset_waveform_picker_regs();
970 974 set_wfp_burst_enable_register(LFR_MODE_BURST);
971 975 #endif
972 976
973 977 return status;
974 978 }
975 979
976 980 int enter_sbm1_mode()
977 981 {
978 982 rtems_status_code status;
979 983
980 984 status = restart_science_tasks();
981 985
982 986 set_local_sbm1_nb_cwf_max();
983 987
984 988 reset_local_sbm1_nb_cwf_sent();
985 989
986 990 #ifdef GSA
987 991 LEON_Unmask_interrupt( IRQ_SM );
988 992 #else
989 993 LEON_Clear_interrupt( IRQ_WAVEFORM_PICKER );
990 994 LEON_Unmask_interrupt( IRQ_WAVEFORM_PICKER );
991 995 reset_waveform_picker_regs();
992 996 set_wfp_burst_enable_register(LFR_MODE_SBM1);
993 997 // SM simulation
994 998 // timer_start( (gptimer_regs_t*) REGS_ADDR_GPTIMER, TIMER_SM_SIMULATOR );
995 999 // LEON_Clear_interrupt( IRQ_SM ); // the IRQ_SM seems to be incompatible with the IRQ_WF on the xilinx board
996 1000 // LEON_Unmask_interrupt( IRQ_SM );
997 1001 #endif
998 1002
999 1003 return status;
1000 1004 }
1001 1005
1002 1006 int enter_sbm2_mode()
1003 1007 {
1004 1008 rtems_status_code status;
1005 1009
1006 1010 status = restart_science_tasks();
1007 1011
1008 1012 set_local_sbm2_nb_cwf_max();
1009 1013
1010 1014 reset_local_sbm2_nb_cwf_sent();
1011 1015
1012 1016 #ifdef GSA
1013 1017 LEON_Unmask_interrupt( IRQ_SM );
1014 1018 #else
1015 1019 LEON_Clear_interrupt( IRQ_WAVEFORM_PICKER );
1016 1020 LEON_Unmask_interrupt( IRQ_WAVEFORM_PICKER );
1017 1021 reset_waveform_picker_regs();
1018 1022 set_wfp_burst_enable_register(LFR_MODE_SBM2);
1019 1023 #endif
1020 1024
1021 1025 return status;
1022 1026 }
1023 1027
1024 1028 int restart_science_tasks()
1025 1029 {
1026 1030 rtems_status_code status[6];
1027 1031 rtems_status_code ret;
1028 1032
1029 1033 ret = RTEMS_SUCCESSFUL;
1030 1034
1031 1035 status[0] = rtems_task_restart( Task_id[TASKID_AVF0], 1 );
1032 1036 if (status[0] != RTEMS_SUCCESSFUL)
1033 1037 {
1034 1038 PRINTF1("in restart_science_task *** 0 ERR %d\n", status[0])
1035 1039 }
1036 1040
1037 1041 status[1] = rtems_task_restart( Task_id[TASKID_BPF0],1 );
1038 1042 if (status[1] != RTEMS_SUCCESSFUL)
1039 1043 {
1040 1044 PRINTF1("in restart_science_task *** 1 ERR %d\n", status[1])
1041 1045 }
1042 1046
1043 1047 status[2] = rtems_task_restart( Task_id[TASKID_WFRM],1 );
1044 1048 if (status[2] != RTEMS_SUCCESSFUL)
1045 1049 {
1046 1050 PRINTF1("in restart_science_task *** 2 ERR %d\n", status[2])
1047 1051 }
1048 1052
1049 1053 status[3] = rtems_task_restart( Task_id[TASKID_CWF3],1 );
1050 1054 if (status[3] != RTEMS_SUCCESSFUL)
1051 1055 {
1052 1056 PRINTF1("in restart_science_task *** 3 ERR %d\n", status[3])
1053 1057 }
1054 1058
1055 1059 status[4] = rtems_task_restart( Task_id[TASKID_CWF2],1 );
1056 1060 if (status[4] != RTEMS_SUCCESSFUL)
1057 1061 {
1058 1062 PRINTF1("in restart_science_task *** 4 ERR %d\n", status[4])
1059 1063 }
1060 1064
1061 1065 status[5] = rtems_task_restart( Task_id[TASKID_CWF1],1 );
1062 1066 if (status[5] != RTEMS_SUCCESSFUL)
1063 1067 {
1064 1068 PRINTF1("in restart_science_task *** 5 ERR %d\n", status[5])
1065 1069 }
1066 1070
1067 1071 if ( (status[0] != RTEMS_SUCCESSFUL) || (status[1] != RTEMS_SUCCESSFUL) || (status[2] != RTEMS_SUCCESSFUL) ||
1068 1072 (status[3] != RTEMS_SUCCESSFUL) || (status[4] != RTEMS_SUCCESSFUL) || (status[5] != RTEMS_SUCCESSFUL) )
1069 1073 {
1070 1074 ret = RTEMS_UNSATISFIED;
1071 1075 }
1072 1076
1073 1077 return ret;
1074 1078 }
1075 1079
1076 1080 int suspend_science_tasks()
1077 1081 {
1078 1082 rtems_status_code status[6];
1079 1083 rtems_status_code ret;
1080 1084
1081 1085 ret = RTEMS_SUCCESSFUL;
1082 1086
1083 1087 status[0] = rtems_task_suspend( Task_id[TASKID_AVF0] );
1084 1088 if (status[0] != RTEMS_SUCCESSFUL)
1085 1089 {
1086 1090 PRINTF1("in suspend_science_task *** 0 ERR %d\n", status[0])
1087 1091 }
1088 1092
1089 1093 status[1] = rtems_task_suspend( Task_id[TASKID_BPF0] );
1090 1094 if (status[1] != RTEMS_SUCCESSFUL)
1091 1095 {
1092 1096 PRINTF1("in suspend_science_task *** 1 ERR %d\n", status[1])
1093 1097 }
1094 1098
1095 1099 status[2] = rtems_task_suspend( Task_id[TASKID_WFRM] );
1096 1100 if (status[2] != RTEMS_SUCCESSFUL)
1097 1101 {
1098 1102 PRINTF1("in suspend_science_task *** 2 ERR %d\n", status[2])
1099 1103 }
1100 1104
1101 1105 status[3] = rtems_task_suspend( Task_id[TASKID_CWF3] );
1102 1106 if (status[3] != RTEMS_SUCCESSFUL)
1103 1107 {
1104 1108 PRINTF1("in suspend_science_task *** 3 ERR %d\n", status[3])
1105 1109 }
1106 1110
1107 1111 status[4] = rtems_task_suspend( Task_id[TASKID_CWF2] );
1108 1112 if (status[4] != RTEMS_SUCCESSFUL)
1109 1113 {
1110 1114 PRINTF1("in suspend_science_task *** 4 ERR %d\n", status[4])
1111 1115 }
1112 1116
1113 1117 status[5] = rtems_task_suspend( Task_id[TASKID_CWF1] );
1114 1118 if (status[5] != RTEMS_SUCCESSFUL)
1115 1119 {
1116 1120 PRINTF1("in suspend_science_task *** 5 ERR %d\n", status[5])
1117 1121 }
1118 1122
1119 1123 if ( (status[0] != RTEMS_SUCCESSFUL) || (status[1] != RTEMS_SUCCESSFUL) || (status[2] != RTEMS_SUCCESSFUL) ||
1120 1124 (status[3] != RTEMS_SUCCESSFUL) || (status[4] != RTEMS_SUCCESSFUL) || (status[5] != RTEMS_SUCCESSFUL) )
1121 1125 {
1122 1126 ret = RTEMS_UNSATISFIED;
1123 1127 }
1124 1128
1125 1129 return ret;
1126 1130 }
1127 1131
1128 1132 //****************
1129 1133 // CLOSING ACTIONS
1130 1134
1131 1135 int send_tm_lfr_tc_exe_success(ccsdsTelecommandPacket_t *TC, rtems_id queue_id)
1132 1136 {
1133 1137 int ret;
1134 1138 rtems_status_code status;
1135 1139 Packet_TM_LFR_TC_EXE_SUCCESS_t TM;
1136 1140 unsigned char messageSize;
1137 1141
1138 1142 ret = LFR_SUCCESSFUL;
1139 1143
1140 1144 TM.targetLogicalAddress = CCSDS_DESTINATION_ID;
1141 1145 TM.protocolIdentifier = CCSDS_PROTOCOLE_ID;
1142 1146 TM.reserved = DEFAULT_RESERVED;
1143 1147 TM.userApplication = CCSDS_USER_APP;
1144 1148 // PACKET HEADER
1145 1149 TM.packetID[0] = (unsigned char) (TM_PACKET_ID_TC_EXE >> 8);
1146 1150 TM.packetID[1] = (unsigned char) (TM_PACKET_ID_TC_EXE );
1147 1151 TM.packetSequenceControl[0] = (TM_PACKET_SEQ_CTRL_STANDALONE >> 8);
1148 1152 TM.packetSequenceControl[1] = (TM_PACKET_SEQ_CTRL_STANDALONE );
1149 1153 TM.packetLength[0] = (unsigned char) (PACKET_LENGTH_TC_EXE_SUCCESS >> 8);
1150 1154 TM.packetLength[1] = (unsigned char) (PACKET_LENGTH_TC_EXE_SUCCESS );
1151 1155 // DATA FIELD HEADER
1152 1156 TM.spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
1153 1157 TM.serviceType = TM_TYPE_TC_EXE;
1154 1158 TM.serviceSubType = TM_SUBTYPE_EXE_OK;
1155 1159 TM.destinationID = TM_DESTINATION_ID_GROUND; // default destination id
1156 1160 TM.time[0] = (unsigned char) (time_management_regs->coarse_time>>24);
1157 1161 TM.time[1] = (unsigned char) (time_management_regs->coarse_time>>16);
1158 1162 TM.time[2] = (unsigned char) (time_management_regs->coarse_time>>8);
1159 1163 TM.time[3] = (unsigned char) (time_management_regs->coarse_time);
1160 1164 TM.time[4] = (unsigned char) (time_management_regs->fine_time>>8);
1161 1165 TM.time[5] = (unsigned char) (time_management_regs->fine_time);
1162 1166 //
1163 1167 TM.telecommand_pkt_id[0] = TC->packetID[0];
1164 1168 TM.telecommand_pkt_id[1] = TC->packetID[1];
1165 1169 TM.pkt_seq_control[0] = TC->packetSequenceControl[0];
1166 1170 TM.pkt_seq_control[1] = TC->packetSequenceControl[1];
1167 1171
1168 1172 messageSize = PACKET_LENGTH_TC_EXE_SUCCESS + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES;
1169 1173
1170 1174 // SEND DATA
1171 1175 status = rtems_message_queue_urgent( queue_id, &TM, messageSize);
1172 1176 if (status != RTEMS_SUCCESSFUL) {
1173 1177 PRINTF("in send_tm_lfr_tc_exe_success *** ERR\n")
1174 1178 ret = LFR_DEFAULT;
1175 1179 }
1176 1180
1177 1181 return LFR_SUCCESSFUL;
1178 1182 }
1179 1183
1180 1184 int send_tm_lfr_tc_exe_inconsistent(ccsdsTelecommandPacket_t *TC, rtems_id queue_id,
1181 1185 unsigned char byte_position, unsigned char rcv_value)
1182 1186 {
1183 1187 int ret;
1184 1188 rtems_status_code status;
1185 1189 Packet_TM_LFR_TC_EXE_INCONSISTENT_t TM;
1186 1190 unsigned char messageSize;
1187 1191
1188 1192 ret = LFR_SUCCESSFUL;
1189 1193
1190 1194 TM.targetLogicalAddress = CCSDS_DESTINATION_ID;
1191 1195 TM.protocolIdentifier = CCSDS_PROTOCOLE_ID;
1192 1196 TM.reserved = DEFAULT_RESERVED;
1193 1197 TM.userApplication = CCSDS_USER_APP;
1194 1198 // PACKET HEADER
1195 1199 TM.packetID[0] = (unsigned char) (TM_PACKET_ID_TC_EXE >> 8);
1196 1200 TM.packetID[1] = (unsigned char) (TM_PACKET_ID_TC_EXE );
1197 1201 TM.packetSequenceControl[0] = (TM_PACKET_SEQ_CTRL_STANDALONE >> 8);
1198 1202 TM.packetSequenceControl[1] = (TM_PACKET_SEQ_CTRL_STANDALONE );
1199 1203 TM.packetLength[0] = (unsigned char) (PACKET_LENGTH_TC_EXE_INCONSISTENT >> 8);
1200 1204 TM.packetLength[1] = (unsigned char) (PACKET_LENGTH_TC_EXE_INCONSISTENT );
1201 1205 // DATA FIELD HEADER
1202 1206 TM.spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
1203 1207 TM.serviceType = TM_TYPE_TC_EXE;
1204 1208 TM.serviceSubType = TM_SUBTYPE_EXE_NOK;
1205 1209 TM.destinationID = TM_DESTINATION_ID_GROUND; // default destination id
1206 1210 TM.time[0] = (unsigned char) (time_management_regs->coarse_time>>24);
1207 1211 TM.time[1] = (unsigned char) (time_management_regs->coarse_time>>16);
1208 1212 TM.time[2] = (unsigned char) (time_management_regs->coarse_time>>8);
1209 1213 TM.time[3] = (unsigned char) (time_management_regs->coarse_time);
1210 1214 TM.time[4] = (unsigned char) (time_management_regs->fine_time>>8);
1211 1215 TM.time[5] = (unsigned char) (time_management_regs->fine_time);
1212 1216 //
1213 1217 TM.tc_failure_code[0] = (char) (FAILURE_CODE_INCONSISTENT >> 8);
1214 1218 TM.tc_failure_code[1] = (char) (FAILURE_CODE_INCONSISTENT );
1215 1219 TM.telecommand_pkt_id[0] = TC->packetID[0];
1216 1220 TM.telecommand_pkt_id[1] = TC->packetID[1];
1217 1221 TM.pkt_seq_control[0] = TC->packetSequenceControl[0];
1218 1222 TM.pkt_seq_control[1] = TC->packetSequenceControl[1];
1219 1223 TM.tc_service = TC->serviceType; // type of the rejected TC
1220 1224 TM.tc_subtype = TC->serviceSubType; // subtype of the rejected TC
1221 1225 TM.byte_position = byte_position;
1222 1226 TM.rcv_value = rcv_value;
1223 1227
1224 1228 messageSize = PACKET_LENGTH_TC_EXE_INCONSISTENT + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES;
1225 1229
1226 1230 // SEND DATA
1227 1231 status = rtems_message_queue_urgent( queue_id, &TM, messageSize);
1228 1232 if (status != RTEMS_SUCCESSFUL) {
1229 1233 PRINTF("in send_tm_lfr_tc_exe_inconsistent *** ERR\n")
1230 1234 ret = LFR_DEFAULT;
1231 1235 }
1232 1236
1233 1237 return LFR_SUCCESSFUL;
1234 1238 }
1235 1239
1236 1240 int send_tm_lfr_tc_exe_not_executable(ccsdsTelecommandPacket_t *TC, rtems_id queue_id)
1237 1241 {
1238 1242 int ret;
1239 1243 rtems_status_code status;
1240 1244 Packet_TM_LFR_TC_EXE_NOT_EXECUTABLE_t TM;
1241 1245 unsigned char messageSize;
1242 1246
1243 1247 ret = LFR_SUCCESSFUL;
1244 1248
1245 1249 TM.targetLogicalAddress = CCSDS_DESTINATION_ID;
1246 1250 TM.protocolIdentifier = CCSDS_PROTOCOLE_ID;
1247 1251 TM.reserved = DEFAULT_RESERVED;
1248 1252 TM.userApplication = CCSDS_USER_APP;
1249 1253 // PACKET HEADER
1250 1254 TM.packetID[0] = (unsigned char) (TM_PACKET_ID_TC_EXE >> 8);
1251 1255 TM.packetID[1] = (unsigned char) (TM_PACKET_ID_TC_EXE );
1252 1256 TM.packetSequenceControl[0] = (TM_PACKET_SEQ_CTRL_STANDALONE >> 8);
1253 1257 TM.packetSequenceControl[1] = (TM_PACKET_SEQ_CTRL_STANDALONE );
1254 1258 TM.packetLength[0] = (unsigned char) (PACKET_LENGTH_TC_EXE_NOT_EXECUTABLE >> 8);
1255 1259 TM.packetLength[1] = (unsigned char) (PACKET_LENGTH_TC_EXE_NOT_EXECUTABLE );
1256 1260 // DATA FIELD HEADER
1257 1261 TM.spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
1258 1262 TM.serviceType = TM_TYPE_TC_EXE;
1259 1263 TM.serviceSubType = TM_SUBTYPE_EXE_NOK;
1260 1264 TM.destinationID = TM_DESTINATION_ID_GROUND; // default destination id
1261 1265 TM.time[0] = (unsigned char) (time_management_regs->coarse_time>>24);
1262 1266 TM.time[1] = (unsigned char) (time_management_regs->coarse_time>>16);
1263 1267 TM.time[2] = (unsigned char) (time_management_regs->coarse_time>>8);
1264 1268 TM.time[3] = (unsigned char) (time_management_regs->coarse_time);
1265 1269 TM.time[4] = (unsigned char) (time_management_regs->fine_time>>8);
1266 1270 TM.time[5] = (unsigned char) (time_management_regs->fine_time);
1267 1271 //
1268 1272 TM.tc_failure_code[0] = (char) (FAILURE_CODE_NOT_EXECUTABLE >> 8);
1269 1273 TM.tc_failure_code[1] = (char) (FAILURE_CODE_NOT_EXECUTABLE );
1270 1274 TM.telecommand_pkt_id[0] = TC->packetID[0];
1271 1275 TM.telecommand_pkt_id[1] = TC->packetID[1];
1272 1276 TM.pkt_seq_control[0] = TC->packetSequenceControl[0];
1273 1277 TM.pkt_seq_control[1] = TC->packetSequenceControl[1];
1274 1278 TM.tc_service = TC->serviceType; // type of the rejected TC
1275 1279 TM.tc_subtype = TC->serviceSubType; // subtype of the rejected TC
1276 1280 TM.lfr_status_word[0] = housekeeping_packet.lfr_status_word[0];
1277 1281 TM.lfr_status_word[1] = housekeeping_packet.lfr_status_word[1];
1278 1282
1279 1283 messageSize = PACKET_LENGTH_TC_EXE_NOT_EXECUTABLE + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES;
1280 1284
1281 1285 // SEND DATA
1282 1286 status = rtems_message_queue_urgent( queue_id, &TM, messageSize);
1283 1287 if (status != RTEMS_SUCCESSFUL) {
1284 1288 PRINTF("in send_tm_lfr_tc_exe_not_executable *** ERR\n")
1285 1289 ret = LFR_DEFAULT;
1286 1290 }
1287 1291
1288 1292 return LFR_SUCCESSFUL;
1289 1293 }
1290 1294
1291 1295 int send_tm_lfr_tc_exe_not_implemented(ccsdsTelecommandPacket_t *TC, rtems_id queue_id)
1292 1296 {
1293 1297 int ret;
1294 1298 rtems_status_code status;
1295 1299 Packet_TM_LFR_TC_EXE_NOT_IMPLEMENTED_t TM;
1296 1300 unsigned char messageSize;
1297 1301
1298 1302 ret = LFR_SUCCESSFUL;
1299 1303
1300 1304 TM.targetLogicalAddress = CCSDS_DESTINATION_ID;
1301 1305 TM.protocolIdentifier = CCSDS_PROTOCOLE_ID;
1302 1306 TM.reserved = DEFAULT_RESERVED;
1303 1307 TM.userApplication = CCSDS_USER_APP;
1304 1308 // PACKET HEADER
1305 1309 TM.packetID[0] = (unsigned char) (TM_PACKET_ID_TC_EXE >> 8);
1306 1310 TM.packetID[1] = (unsigned char) (TM_PACKET_ID_TC_EXE );
1307 1311 TM.packetSequenceControl[0] = (TM_PACKET_SEQ_CTRL_STANDALONE >> 8);
1308 1312 TM.packetSequenceControl[1] = (TM_PACKET_SEQ_CTRL_STANDALONE );
1309 1313 TM.packetLength[0] = (unsigned char) (PACKET_LENGTH_TC_EXE_NOT_IMPLEMENTED >> 8);
1310 1314 TM.packetLength[1] = (unsigned char) (PACKET_LENGTH_TC_EXE_NOT_IMPLEMENTED );
1311 1315 // DATA FIELD HEADER
1312 1316 TM.spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
1313 1317 TM.serviceType = TM_TYPE_TC_EXE;
1314 1318 TM.serviceSubType = TM_SUBTYPE_EXE_NOK;
1315 1319 TM.destinationID = TM_DESTINATION_ID_GROUND; // default destination id
1316 1320 TM.time[0] = (unsigned char) (time_management_regs->coarse_time>>24);
1317 1321 TM.time[1] = (unsigned char) (time_management_regs->coarse_time>>16);
1318 1322 TM.time[2] = (unsigned char) (time_management_regs->coarse_time>>8);
1319 1323 TM.time[3] = (unsigned char) (time_management_regs->coarse_time);
1320 1324 TM.time[4] = (unsigned char) (time_management_regs->fine_time>>8);
1321 1325 TM.time[5] = (unsigned char) (time_management_regs->fine_time);
1322 1326 //
1323 1327 TM.tc_failure_code[0] = (char) (FAILURE_CODE_NOT_IMPLEMENTED >> 8);
1324 1328 TM.tc_failure_code[1] = (char) (FAILURE_CODE_NOT_IMPLEMENTED );
1325 1329 TM.telecommand_pkt_id[0] = TC->packetID[0];
1326 1330 TM.telecommand_pkt_id[1] = TC->packetID[1];
1327 1331 TM.pkt_seq_control[0] = TC->packetSequenceControl[0];
1328 1332 TM.pkt_seq_control[1] = TC->packetSequenceControl[1];
1329 1333 TM.tc_service = TC->serviceType; // type of the rejected TC
1330 1334 TM.tc_subtype = TC->serviceSubType; // subtype of the rejected TC
1331 1335
1332 1336 messageSize = PACKET_LENGTH_TC_EXE_NOT_IMPLEMENTED + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES;
1333 1337
1334 1338 // SEND DATA
1335 1339 status = rtems_message_queue_urgent( queue_id, &TM, messageSize);
1336 1340 if (status != RTEMS_SUCCESSFUL) {
1337 1341 PRINTF("in send_tm_lfr_tc_exe_not_implemented *** ERR\n")
1338 1342 ret = LFR_DEFAULT;
1339 1343 }
1340 1344
1341 1345 return LFR_SUCCESSFUL;
1342 1346 }
1343 1347
1344 1348 int send_tm_lfr_tc_exe_error(ccsdsTelecommandPacket_t *TC, rtems_id queue_id)
1345 1349 {
1346 1350 int ret;
1347 1351 rtems_status_code status;
1348 1352 Packet_TM_LFR_TC_EXE_ERROR_t TM;
1349 1353 unsigned char messageSize;
1350 1354
1351 1355 ret = LFR_SUCCESSFUL;
1352 1356
1353 1357 TM.targetLogicalAddress = CCSDS_DESTINATION_ID;
1354 1358 TM.protocolIdentifier = CCSDS_PROTOCOLE_ID;
1355 1359 TM.reserved = DEFAULT_RESERVED;
1356 1360 TM.userApplication = CCSDS_USER_APP;
1357 1361 // PACKET HEADER
1358 1362 TM.packetID[0] = (unsigned char) (TM_PACKET_ID_TC_EXE >> 8);
1359 1363 TM.packetID[1] = (unsigned char) (TM_PACKET_ID_TC_EXE );
1360 1364 TM.packetSequenceControl[0] = (TM_PACKET_SEQ_CTRL_STANDALONE >> 8);
1361 1365 TM.packetSequenceControl[1] = (TM_PACKET_SEQ_CTRL_STANDALONE );
1362 1366 TM.packetLength[0] = (unsigned char) (PACKET_LENGTH_TC_EXE_ERROR >> 8);
1363 1367 TM.packetLength[1] = (unsigned char) (PACKET_LENGTH_TC_EXE_ERROR );
1364 1368 // DATA FIELD HEADER
1365 1369 TM.spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
1366 1370 TM.serviceType = TM_TYPE_TC_EXE;
1367 1371 TM.serviceSubType = TM_SUBTYPE_EXE_NOK;
1368 1372 TM.destinationID = TM_DESTINATION_ID_GROUND; // default destination id
1369 1373 TM.time[0] = (unsigned char) (time_management_regs->coarse_time>>24);
1370 1374 TM.time[1] = (unsigned char) (time_management_regs->coarse_time>>16);
1371 1375 TM.time[2] = (unsigned char) (time_management_regs->coarse_time>>8);
1372 1376 TM.time[3] = (unsigned char) (time_management_regs->coarse_time);
1373 1377 TM.time[4] = (unsigned char) (time_management_regs->fine_time>>8);
1374 1378 TM.time[5] = (unsigned char) (time_management_regs->fine_time);
1375 1379 //
1376 1380 TM.tc_failure_code[0] = (char) (FAILURE_CODE_ERROR >> 8);
1377 1381 TM.tc_failure_code[1] = (char) (FAILURE_CODE_ERROR );
1378 1382 TM.telecommand_pkt_id[0] = TC->packetID[0];
1379 1383 TM.telecommand_pkt_id[1] = TC->packetID[1];
1380 1384 TM.pkt_seq_control[0] = TC->packetSequenceControl[0];
1381 1385 TM.pkt_seq_control[1] = TC->packetSequenceControl[1];
1382 1386 TM.tc_service = TC->serviceType; // type of the rejected TC
1383 1387 TM.tc_subtype = TC->serviceSubType; // subtype of the rejected TC
1384 1388
1385 1389 messageSize = PACKET_LENGTH_TC_EXE_ERROR + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES;
1386 1390
1387 1391 // SEND DATA
1388 1392 status = rtems_message_queue_urgent( queue_id, &TM, messageSize);
1389 1393 if (status != RTEMS_SUCCESSFUL) {
1390 1394 PRINTF("in send_tm_lfr_tc_exe_error *** ERR\n")
1391 1395 ret = LFR_DEFAULT;
1392 1396 }
1393 1397
1394 1398 return LFR_SUCCESSFUL;
1395 1399 }
1396 1400
1397 1401 void update_last_TC_exe(ccsdsTelecommandPacket_t *TC)
1398 1402 {
1399 1403 housekeeping_packet.hk_lfr_last_exe_tc_id[0] = TC->packetID[0];
1400 1404 housekeeping_packet.hk_lfr_last_exe_tc_id[1] = TC->packetID[1];
1401 1405 housekeeping_packet.hk_lfr_last_exe_tc_type[0] = 0x00;
1402 1406 housekeeping_packet.hk_lfr_last_exe_tc_type[1] = TC->serviceType;
1403 1407 housekeeping_packet.hk_lfr_last_exe_tc_subtype[0] = 0x00;
1404 1408 housekeeping_packet.hk_lfr_last_exe_tc_subtype[1] = TC->serviceSubType;
1405 1409 housekeeping_packet.hk_lfr_last_exe_tc_time[0] = (unsigned char) (time_management_regs->coarse_time>>24);
1406 1410 housekeeping_packet.hk_lfr_last_exe_tc_time[1] = (unsigned char) (time_management_regs->coarse_time>>16);
1407 1411 housekeeping_packet.hk_lfr_last_exe_tc_time[2] = (unsigned char) (time_management_regs->coarse_time>>8);
1408 1412 housekeeping_packet.hk_lfr_last_exe_tc_time[3] = (unsigned char) (time_management_regs->coarse_time);
1409 1413 housekeeping_packet.hk_lfr_last_exe_tc_time[4] = (unsigned char) (time_management_regs->fine_time>>8);
1410 1414 housekeeping_packet.hk_lfr_last_exe_tc_time[5] = (unsigned char) (time_management_regs->fine_time);
1411 1415 }
1412 1416
1413 1417 void update_last_TC_rej(ccsdsTelecommandPacket_t *TC)
1414 1418 {
1415 1419 housekeeping_packet.hk_lfr_last_rej_tc_id[0] = TC->packetID[0];
1416 1420 housekeeping_packet.hk_lfr_last_rej_tc_id[1] = TC->packetID[1];
1417 1421 housekeeping_packet.hk_lfr_last_rej_tc_type[0] = 0x00;
1418 1422 housekeeping_packet.hk_lfr_last_rej_tc_type[1] = TC->serviceType;
1419 1423 housekeeping_packet.hk_lfr_last_rej_tc_subtype[0] = 0x00;
1420 1424 housekeeping_packet.hk_lfr_last_rej_tc_subtype[1] = TC->serviceSubType;
1421 1425 housekeeping_packet.hk_lfr_last_rej_tc_time[0] = (unsigned char) (time_management_regs->coarse_time>>24);
1422 1426 housekeeping_packet.hk_lfr_last_rej_tc_time[1] = (unsigned char) (time_management_regs->coarse_time>>16);
1423 1427 housekeeping_packet.hk_lfr_last_rej_tc_time[2] = (unsigned char) (time_management_regs->coarse_time>>8);
1424 1428 housekeeping_packet.hk_lfr_last_rej_tc_time[3] = (unsigned char) (time_management_regs->coarse_time);
1425 1429 housekeeping_packet.hk_lfr_last_rej_tc_time[4] = (unsigned char) (time_management_regs->fine_time>>8);
1426 1430 housekeeping_packet.hk_lfr_last_rej_tc_time[5] = (unsigned char) (time_management_regs->fine_time);
1427 1431 }
1428 1432
1429 1433 void close_action(ccsdsTelecommandPacket_t *TC, int result, rtems_id queue_id)
1430 1434 {
1431 1435 unsigned int val = 0;
1432 1436 if (result == LFR_SUCCESSFUL)
1433 1437 {
1434 1438 if ( !( (TC->serviceType==TC_TYPE_TIME) && (TC->serviceSubType==TC_SUBTYPE_UPDT_TIME) ) )
1435 1439 {
1436 1440 send_tm_lfr_tc_exe_success( TC, queue_id );
1437 1441 }
1438 1442 update_last_TC_exe( TC );
1439 1443 val = housekeeping_packet.hk_dpu_exe_tc_lfr_cnt[0] * 256 + housekeeping_packet.hk_dpu_exe_tc_lfr_cnt[1];
1440 1444 val++;
1441 1445 housekeeping_packet.hk_dpu_exe_tc_lfr_cnt[0] = (unsigned char) (val >> 8);
1442 1446 housekeeping_packet.hk_dpu_exe_tc_lfr_cnt[1] = (unsigned char) (val);
1443 1447 }
1444 1448 else
1445 1449 {
1446 1450 update_last_TC_rej( TC );
1447 1451 val = housekeeping_packet.hk_dpu_rej_tc_lfr_cnt[0] * 256 + housekeeping_packet.hk_dpu_rej_tc_lfr_cnt[1];
1448 1452 val++;
1449 1453 housekeeping_packet.hk_dpu_rej_tc_lfr_cnt[0] = (unsigned char) (val >> 8);
1450 1454 housekeeping_packet.hk_dpu_rej_tc_lfr_cnt[1] = (unsigned char) (val);
1451 1455 }
1452 1456 }
1453 1457
1454 1458 //***************************
1455 1459 // Interrupt Service Routines
1456 1460 rtems_isr commutation_isr1( rtems_vector_number vector )
1457 1461 {
1458 1462 if (rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
1459 1463 printf("In commutation_isr1 *** Error sending event to DUMB\n");
1460 1464 }
1461 1465 }
1462 1466
1463 1467 rtems_isr commutation_isr2( rtems_vector_number vector )
1464 1468 {
1465 1469 if (rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
1466 1470 printf("In commutation_isr2 *** Error sending event to DUMB\n");
1467 1471 }
1468 1472 }
1469 1473
1470 1474
1471 1475
1472 1476
General Comments 0
You need to be logged in to leave comments. Login now