diff --git a/.hgsubstate b/.hgsubstate --- a/.hgsubstate +++ b/.hgsubstate @@ -1,2 +1,2 @@ a586fe639ac179e95bdc150ebdbab0312f31dc30 LFR_basic-parameters -ddd0a6fe16cc1861ad679bf646663e070189e037 header/lfr_common_headers +5467523e44cd6a627a81b156673a891f4d6b0017 header/lfr_common_headers diff --git a/header/fsw_spacewire.h b/header/fsw_spacewire.h --- a/header/fsw_spacewire.h +++ b/header/fsw_spacewire.h @@ -38,6 +38,7 @@ int spw_send_waveform_CWF( ring_node *ri int spw_send_waveform_SWF( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_SWF_t *header ); int spw_send_waveform_CWF3_light( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_CWF_t *header ); void spw_send_asm( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_ASM_t *header ); +void spw_send_k_dump( ring_node *ring_node_to_send ); void timecode_irq_handler( void *pDev, void *regs, int minor, unsigned int tc ); rtems_timer_service_routine user_routine( rtems_id timer_id, void *user_data ); diff --git a/header/tc_load_dump_parameters.h b/header/tc_load_dump_parameters.h --- a/header/tc_load_dump_parameters.h +++ b/header/tc_load_dump_parameters.h @@ -8,10 +8,16 @@ #include "wf_handler.h" #include "tm_lfr_tc_exe.h" #include "fsw_misc.h" +#include "basic_parameters_params.h" #define FLOAT_EQUAL_ZERO 0.001 extern unsigned short sequenceCounterParameterDump; +extern float k_coeff_intercalib_f0_norm[ ]; +extern float k_coeff_intercalib_f0_sbm[ ]; +extern float k_coeff_intercalib_f1_norm[ ]; +extern float k_coeff_intercalib_f1_sbm[ ]; +extern float k_coeff_intercalib_f2[ ]; int action_load_common_par( ccsdsTelecommandPacket_t *TC ); int action_load_normal_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time); @@ -49,6 +55,11 @@ unsigned int check_update_info_hk_lfr_mo unsigned int check_update_info_hk_tds_mode( unsigned char mode ); unsigned int check_update_info_hk_thr_mode( unsigned char mode ); +// KCOEFFICIENTS +int set_sy_lfr_kcoeff( ccsdsTelecommandPacket_t *TC ); + void init_parameter_dump( void ); +void init_kcoefficients_dump( void ); +void init_kcoefficients_dump_packet( Packet_TM_LFR_KCOEFFICIENTS_DUMP_t *kcoefficients_dump, unsigned char pkt_nr, unsigned char blk_nr ); #endif // TC_LOAD_DUMP_PARAMETERS_H diff --git a/python_scripts/LFRControlPlugin_reload_fsw.py b/python_scripts/LFRControlPlugin_reload_fsw.py --- a/python_scripts/LFRControlPlugin_reload_fsw.py +++ b/python_scripts/LFRControlPlugin_reload_fsw.py @@ -1,8 +1,8 @@ # LOAD FSW USING LINK 1 SpwPlugin0.StarDundeeSelectLinkNumber( 1 ) -#dsu3plugin0.openFile("/opt/DEV_PLE/FSW-qt/bin/fsw") -dsu3plugin0.openFile("/opt/LFR/LFR-FSW/2.0.2.3/fsw") +dsu3plugin0.openFile("/opt/DEV_PLE/FSW-qt/bin/fsw") +#dsu3plugin0.openFile("/opt/LFR/LFR-FSW/2.0.2.3/fsw") dsu3plugin0.loadFile() dsu3plugin0.run() diff --git a/python_scripts/LFRControlPlugin_startFsw.py b/python_scripts/LFRControlPlugin_startFsw.py --- a/python_scripts/LFRControlPlugin_startFsw.py +++ b/python_scripts/LFRControlPlugin_startFsw.py @@ -22,6 +22,7 @@ SpwPlugin0.TCPServerConnect() LFRControlPlugin0.TCPServerConnect() dsu3plugin0.openFile("/opt/DEV_PLE/FSW-qt/bin/fsw") +#dsu3plugin0.openFile("/opt/LFR/LFR-FSW/2.0.2.3/fsw") dsu3plugin0.loadFile() dsu3plugin0.run() diff --git a/src/fsw_init.c b/src/fsw_init.c --- a/src/fsw_init.c +++ b/src/fsw_init.c @@ -129,6 +129,7 @@ rtems_task Init( rtems_task_argument ign PRINTF("\n\n") init_parameter_dump(); + init_kcoefficients_dump(); init_local_mode_parameters(); init_housekeeping_parameters(); init_k_coefficients_f0(); diff --git a/src/fsw_misc.c b/src/fsw_misc.c --- a/src/fsw_misc.c +++ b/src/fsw_misc.c @@ -335,7 +335,7 @@ void init_housekeeping_parameters( void void increment_seq_counter( unsigned short *packetSequenceControl ) { - /** This function increment the sequence counter psased in argument. + /** This function increment the sequence counter passes in argument. * * The increment does not affect the grouping flag. In case of an overflow, the counter is reset to 0. * diff --git a/src/fsw_spacewire.c b/src/fsw_spacewire.c --- a/src/fsw_spacewire.c +++ b/src/fsw_spacewire.c @@ -217,7 +217,7 @@ rtems_task send_task( rtems_task_argumen size_t size; // size of the incoming TC packet u_int32_t count; rtems_id queue_id; - unsigned char sid; + unsigned int sid; incomingRingNodePtr = NULL; ring_node_address = 0; @@ -270,10 +270,14 @@ rtems_task send_task( rtems_task_argumen { spw_send_waveform_CWF3_light( incomingRingNodePtr, &headerCWF ); } - else if ( (sid==SID_NORM_ASM_F0) || (SID_NORM_ASM_F1) || (SID_NORM_ASM_F2) ) + else if ( (sid==SID_NORM_ASM_F0) || (sid==SID_NORM_ASM_F1) || (sid==SID_NORM_ASM_F2) ) { spw_send_asm( incomingRingNodePtr, &headerASM ); } + else if ( sid==TM_CODE_K_DUMP ) + { + spw_send_k_dump( incomingRingNodePtr ); + } else { printf("unexpected sid = %d\n", sid); @@ -1124,3 +1128,29 @@ void spw_send_asm( ring_node *ring_node_ } } } + +void spw_send_k_dump( ring_node *ring_node_to_send ) +{ + rtems_status_code status; + Packet_TM_LFR_KCOEFFICIENTS_DUMP_t *kcoefficients_dump; + unsigned int packetLength; + unsigned int size; + + printf("spw_send_k_dump\n"); + + kcoefficients_dump = (Packet_TM_LFR_KCOEFFICIENTS_DUMP_t *) ring_node_to_send->buffer_address; + + packetLength = kcoefficients_dump->packetLength[0] * 256 + kcoefficients_dump->packetLength[1]; + + size = packetLength + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES; + + printf("packetLength %d, size %d\n", packetLength, size ); + + status = write( fdSPW, (char *) ring_node_to_send->buffer_address, size ); + + if (status == -1){ + PRINTF2("in SEND *** (2.a) ERRNO = %d, size = %d\n", errno, size) + } + + ring_node_to_send->status = 0x00; +} diff --git a/src/tc_acceptance.c b/src/tc_acceptance.c --- a/src/tc_acceptance.c +++ b/src/tc_acceptance.c @@ -226,7 +226,9 @@ int tc_check_type_subtype( unsigned char || (packetSubType == TC_SUBTYPE_DUMP) || (packetSubType == TC_SUBTYPE_ENTER) || (packetSubType == TC_SUBTYPE_UPDT_INFO) - || (packetSubType == TC_SUBTYPE_EN_CAL) || (packetSubType == TC_SUBTYPE_DIS_CAL) ) + || (packetSubType == TC_SUBTYPE_EN_CAL) || (packetSubType == TC_SUBTYPE_DIS_CAL) + || (packetSubType == TC_SUBTYPE_LOAD_K) || (packetSubType == TC_SUBTYPE_DUMP_K) + || (packetSubType == TC_SUBTYPE_LOAD_FBINS) ) { status = CCSDS_TM_VALID; } @@ -388,6 +390,30 @@ int tc_check_length( unsigned char packe status = CCSDS_TM_VALID; } break; + case TC_SUBTYPE_LOAD_K: + if (length!=(TC_LEN_LOAD_K-CCSDS_TC_TM_PACKET_OFFSET)) { + status = WRONG_LEN_PKT; + } + else { + status = CCSDS_TM_VALID; + } + break; + case TC_SUBTYPE_DUMP_K: + if (length!=(TC_LEN_DUMP_K-CCSDS_TC_TM_PACKET_OFFSET)) { + status = WRONG_LEN_PKT; + } + else { + status = CCSDS_TM_VALID; + } + break; + case TC_SUBTYPE_LOAD_FBINS: + if (length!=(TC_LEN_LOAD_FBINS-CCSDS_TC_TM_PACKET_OFFSET)) { + status = WRONG_LEN_PKT; + } + else { + status = CCSDS_TM_VALID; + } + break; case TC_SUBTYPE_UPDT_TIME: if (length!=(TC_LEN_UPDT_TIME-CCSDS_TC_TM_PACKET_OFFSET)) { status = WRONG_LEN_PKT; diff --git a/src/tc_handler.c b/src/tc_handler.c --- a/src/tc_handler.c +++ b/src/tc_handler.c @@ -112,6 +112,7 @@ rtems_task actn_task( rtems_task_argumen close_action( &TC, result, queue_snd_id ); break; case TC_SUBTYPE_LOAD_K: + printf("TC_SUBTYPE_LOAD_K\n"); result = action_load_kcoefficients( &TC, queue_snd_id, time ); close_action( &TC, result, queue_snd_id ); break; @@ -167,8 +168,6 @@ int action_enter_mode(ccsdsTelecommandPa unsigned int transitionCoarseTime; unsigned char * bytePosPtr; - printTaskID(); - bytePosPtr = (unsigned char *) &TC->packetID; requestedMode = bytePosPtr[ BYTE_POS_CP_MODE_LFR_SET ]; @@ -672,7 +671,6 @@ int suspend_science_tasks() rtems_status_code status; printf("in suspend_science_tasks\n"); - printTaskID(); status = rtems_task_suspend( Task_id[TASKID_AVF0] ); // suspend AVF0 if (status != RTEMS_SUCCESSFUL) @@ -1121,13 +1119,3 @@ void reset_lfr( void ) set_lfr_soft_reset( 0 ); } - -void printTaskID( void ) -{ - unsigned int i; - - for (i=0; i<20;i++) - { - printf("ID %d = %d\n", i, (unsigned int) Task_id[i]); - } -} diff --git a/src/tc_load_dump_parameters.c b/src/tc_load_dump_parameters.c --- a/src/tc_load_dump_parameters.c +++ b/src/tc_load_dump_parameters.c @@ -14,6 +14,11 @@ #include "tc_load_dump_parameters.h" +Packet_TM_LFR_KCOEFFICIENTS_DUMP_t kcoefficients_dump_1; +Packet_TM_LFR_KCOEFFICIENTS_DUMP_t kcoefficients_dump_2; +ring_node kcoefficient_node_1; +ring_node kcoefficient_node_2; + int action_load_common_par(ccsdsTelecommandPacket_t *TC) { /** This function updates the LFR registers with the incoming common parameters. @@ -282,11 +287,7 @@ int action_load_kcoefficients(ccsdsTelec flag = LFR_DEFAULT; -// NB_BINS_COMPRESSED_SM_F0; -// NB_BINS_COMPRESSED_SM_F1; -// NB_BINS_COMPRESSED_SM_F2; - - send_tm_lfr_tc_exe_not_implemented( TC, queue_id, time ); + flag = set_sy_lfr_kcoeff( TC ); return flag; } @@ -309,6 +310,18 @@ int action_load_fbins_mask(ccsdsTelecomm return flag; } +void printKCoefficients(unsigned int freq, unsigned int bin, float *k_coeff) +{ + printf("freq = %d *** bin = %d *** (0) %f *** (1) %f *** (2) %f *** (3) %f *** (4) %f\n", + freq, + bin, + k_coeff[ (bin*NB_K_COEFF_PER_BIN) + 0 ], + k_coeff[ (bin*NB_K_COEFF_PER_BIN) + 1 ], + k_coeff[ (bin*NB_K_COEFF_PER_BIN) + 2 ], + k_coeff[ (bin*NB_K_COEFF_PER_BIN) + 3 ], + k_coeff[ (bin*NB_K_COEFF_PER_BIN) + 4 ]); +} + int action_dump_kcoefficients(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time) { /** This function updates the LFR registers with the incoming sbm2 parameters. @@ -318,13 +331,127 @@ int action_dump_kcoefficients(ccsdsTelec * */ - int flag; + unsigned int address; + rtems_status_code status; + unsigned int freq; + unsigned int bin; + unsigned int coeff; + unsigned char *kCoeffPtr; + unsigned char *kCoeffDumpPtr; - flag = LFR_DEFAULT; + // for each sy_lfr_kcoeff_frequency there is 32 kcoeff + // F0 => 11 bins + // F1 => 13 bins + // F2 => 12 bins + // 36 bins to dump in two packets (30 bins max per packet) - send_tm_lfr_tc_exe_not_implemented( TC, queue_id, time ); + //********* + // PACKET 1 + // 11 F0 bins, 13 F1 bins and 6 F2 bins + kcoefficients_dump_1.packetSequenceControl[0] = (unsigned char) (sequenceCounterParameterDump >> 8); + kcoefficients_dump_1.packetSequenceControl[1] = (unsigned char) (sequenceCounterParameterDump ); + increment_seq_counter( &sequenceCounterParameterDump ); + for( freq=0; + freqcoarse_time>>24); + kcoefficients_dump_1.time[1] = (unsigned char) (time_management_regs->coarse_time>>16); + kcoefficients_dump_1.time[2] = (unsigned char) (time_management_regs->coarse_time>>8); + kcoefficients_dump_1.time[3] = (unsigned char) (time_management_regs->coarse_time); + kcoefficients_dump_1.time[4] = (unsigned char) (time_management_regs->fine_time>>8); + kcoefficients_dump_1.time[5] = (unsigned char) (time_management_regs->fine_time); + // SEND DATA + kcoefficient_node_1.status = 1; + address = (unsigned int) &kcoefficient_node_1; + status = rtems_message_queue_send( queue_id, &address, sizeof( ring_node* ) ); + if (status != RTEMS_SUCCESSFUL) { + PRINTF1("in action_dump_kcoefficients *** ERR sending packet 1 , code %d", status) + } - return flag; + //******** + // PACKET 2 + // 6 F2 bins + kcoefficients_dump_2.packetSequenceControl[0] = (unsigned char) (sequenceCounterParameterDump >> 8); + kcoefficients_dump_2.packetSequenceControl[1] = (unsigned char) (sequenceCounterParameterDump ); + increment_seq_counter( &sequenceCounterParameterDump ); + for( freq=0; freq<6; freq++ ) + { + kcoefficients_dump_2.kcoeff_blks[ freq*KCOEFF_BLK_SIZE + 1 ] = NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1 + 6 + freq; + bin = freq + 6; + printKCoefficients( freq, bin, k_coeff_intercalib_f2); + for ( coeff=0; coeffcoarse_time>>24); + kcoefficients_dump_2.time[1] = (unsigned char) (time_management_regs->coarse_time>>16); + kcoefficients_dump_2.time[2] = (unsigned char) (time_management_regs->coarse_time>>8); + kcoefficients_dump_2.time[3] = (unsigned char) (time_management_regs->coarse_time); + kcoefficients_dump_2.time[4] = (unsigned char) (time_management_regs->fine_time>>8); + kcoefficients_dump_2.time[5] = (unsigned char) (time_management_regs->fine_time); + // SEND DATA + kcoefficient_node_2.status = 1; + address = (unsigned int) &kcoefficient_node_2; + status = rtems_message_queue_send( queue_id, &address, sizeof( ring_node* ) ); + if (status != RTEMS_SUCCESSFUL) { + PRINTF1("in action_dump_kcoefficients *** ERR sending packet 2, code %d", status) + } + + return status; } int action_dump_par( rtems_id queue_id ) @@ -760,21 +887,73 @@ unsigned int check_update_info_hk_thr_mo // KCOEFFICIENTS int set_sy_lfr_kcoeff( ccsdsTelecommandPacket_t *TC ) { + unsigned int i; unsigned short sy_lfr_kcoeff_frequency; + unsigned short bin; unsigned short *freqPtr; + float *kcoeffPtr_norm; + float *kcoeffPtr_sbm; int status; + unsigned char *kcoeffLoadPtr; + unsigned char *kcoeffNormPtr; status = LFR_SUCCESSFUL; - freqPtr = (unsigned short *) &TC->dataAndCRC[0]; + kcoeffPtr_norm = NULL; + kcoeffPtr_sbm = NULL; + bin = 0; + + freqPtr = (unsigned short *) &TC->dataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_FREQUENCY]; sy_lfr_kcoeff_frequency = *freqPtr; - PRINTF1("sy_lfr_kcoeff_frequency = %d\n", sy_lfr_kcoeff_frequency) - - if (sy_lfr_kcoeff_frequency >= NB_BINS_COMPRESSED_SM) + if ( sy_lfr_kcoeff_frequency >= NB_BINS_COMPRESSED_SM ) { PRINTF1("ERR *** in set_sy_lfr_kcoeff_frequency *** sy_lfr_kcoeff_frequency = %d\n", sy_lfr_kcoeff_frequency) } + else + { + if ( ( sy_lfr_kcoeff_frequency >= 0 ) + && ( sy_lfr_kcoeff_frequency < NB_BINS_COMPRESSED_SM_F0 ) ) + { + kcoeffPtr_norm = k_coeff_intercalib_f0_norm; + kcoeffPtr_sbm = k_coeff_intercalib_f0_sbm; + bin = sy_lfr_kcoeff_frequency; + } + else if ( ( sy_lfr_kcoeff_frequency >= NB_BINS_COMPRESSED_SM_F0 ) + && ( sy_lfr_kcoeff_frequency < (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1) ) ) + { + kcoeffPtr_norm = k_coeff_intercalib_f1_norm; + kcoeffPtr_sbm = k_coeff_intercalib_f1_sbm; + bin = sy_lfr_kcoeff_frequency - NB_BINS_COMPRESSED_SM_F0; + } + else if ( ( sy_lfr_kcoeff_frequency >= (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1) ) + && ( sy_lfr_kcoeff_frequency < (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1 + NB_BINS_COMPRESSED_SM_F2) ) ) + { + kcoeffPtr_norm = k_coeff_intercalib_f2; + kcoeffPtr_sbm = NULL; + bin = sy_lfr_kcoeff_frequency - (NB_BINS_COMPRESSED_SM_F0 + NB_BINS_COMPRESSED_SM_F1); + } + } + + if (kcoeffPtr_norm != NULL ) + { + printf("freq = %d, bin = %d\n", sy_lfr_kcoeff_frequency, bin); + for (i=0; idataAndCRC[DATAFIELD_POS_SY_LFR_KCOEFF_1 + NB_BYTES_PER_FLOAT * i]; + kcoeffNormPtr = (unsigned char*) &kcoeffPtr_norm[ (bin * NB_K_COEFF_PER_BIN) + i ]; + kcoeffNormPtr[0] = kcoeffLoadPtr[0]; + kcoeffNormPtr[1] = kcoeffLoadPtr[1]; + kcoeffNormPtr[2] = kcoeffLoadPtr[2]; + kcoeffNormPtr[3] = kcoeffLoadPtr[3]; + printf("kcoeffPtr: %x %x %x %x *** %f \n", + kcoeffLoadPtr[0], + kcoeffLoadPtr[1], + kcoeffLoadPtr[2], + kcoeffLoadPtr[3], + kcoeffPtr_norm[ (bin * NB_K_COEFF_PER_BIN) + i ]); + } + } return status; } @@ -844,9 +1023,70 @@ void init_parameter_dump( void ) parameter_dump_packet.sy_lfr_s2_bp_p1 = (unsigned char) DEFAULT_SY_LFR_S2_BP_P1; } +void init_kcoefficients_dump( void ) +{ + init_kcoefficients_dump_packet( &kcoefficients_dump_1, 1, 30 ); + init_kcoefficients_dump_packet( &kcoefficients_dump_2, 2, 6 ); + + kcoefficient_node_1.previous = NULL; + kcoefficient_node_1.next = NULL; + kcoefficient_node_1.sid = TM_CODE_K_DUMP; + kcoefficient_node_1.coarseTime = 0x00; + kcoefficient_node_1.fineTime = 0x00; + kcoefficient_node_1.buffer_address = (int) &kcoefficients_dump_1; + kcoefficient_node_1.status = 0x00; + + kcoefficient_node_2.previous = NULL; + kcoefficient_node_2.next = NULL; + kcoefficient_node_2.sid = TM_CODE_K_DUMP; + kcoefficient_node_2.coarseTime = 0x00; + kcoefficient_node_2.fineTime = 0x00; + kcoefficient_node_2.buffer_address = (int) &kcoefficients_dump_2; + kcoefficient_node_2.status = 0x00; +} + +void init_kcoefficients_dump_packet( Packet_TM_LFR_KCOEFFICIENTS_DUMP_t *kcoefficients_dump, unsigned char pkt_nr, unsigned char blk_nr ) +{ + unsigned int k; + unsigned int packetLength; + + packetLength = blk_nr * 130 + 20 - CCSDS_TC_TM_PACKET_OFFSET; // 4 bytes for the CCSDS header + + kcoefficients_dump->targetLogicalAddress = CCSDS_DESTINATION_ID; + kcoefficients_dump->protocolIdentifier = CCSDS_PROTOCOLE_ID; + kcoefficients_dump->reserved = CCSDS_RESERVED; + kcoefficients_dump->userApplication = CCSDS_USER_APP; + kcoefficients_dump->packetID[0] = (unsigned char) (APID_TM_PARAMETER_DUMP >> 8);; + kcoefficients_dump->packetID[1] = (unsigned char) APID_TM_PARAMETER_DUMP;; + kcoefficients_dump->packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE; + kcoefficients_dump->packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT; + kcoefficients_dump->packetLength[0] = (unsigned char) (packetLength >> 8); + kcoefficients_dump->packetLength[1] = (unsigned char) packetLength; + // DATA FIELD HEADER + kcoefficients_dump->spare1_pusVersion_spare2 = SPARE1_PUSVERSION_SPARE2; + kcoefficients_dump->serviceType = TM_TYPE_K_DUMP; + kcoefficients_dump->serviceSubType = TM_SUBTYPE_K_DUMP; + kcoefficients_dump->destinationID= TM_DESTINATION_ID_GROUND; + kcoefficients_dump->time[0] = 0x00; + kcoefficients_dump->time[1] = 0x00; + kcoefficients_dump->time[2] = 0x00; + kcoefficients_dump->time[3] = 0x00; + kcoefficients_dump->time[4] = 0x00; + kcoefficients_dump->time[5] = 0x00; + kcoefficients_dump->sid = SID_K_DUMP; + + kcoefficients_dump->pkt_cnt = 2; + kcoefficients_dump->pkt_nr = pkt_nr; + kcoefficients_dump->blk_nr = blk_nr; + + //****************** + // SOURCE DATA repeated N times with N in [0 .. PA_LFR_KCOEFF_BLK_NR] + // one blk is 2 + 4 * 32 = 130 bytes, 30 blks max in one packet (30 * 130 = 3900) + for (k=0; k<3900; k++) + { + kcoefficients_dump->kcoeff_blks[k] = 0x00; + } +} - - - diff --git a/src/wf_handler.c b/src/wf_handler.c --- a/src/wf_handler.c +++ b/src/wf_handler.c @@ -680,7 +680,7 @@ rtems_task cwf1_task(rtems_task_argument rtems_id queue_id; rtems_status_code status; - ring_node * ring_node_to_send_cwf; + ring_node *ring_node_to_send_cwf; status = get_message_queue_id_send( &queue_id ); if (status != RTEMS_SUCCESSFUL)