# HG changeset patch # User paul # Date 2017-01-09 07:19:50 # Node ID 0d12752c6dcdf3291a4d4e1c4e15d144413768c8 # Parent f8bdd7f2088645e1fd63374fb1dccd88b2799ff1 Bug #703 hk_lfr_le and hk_lfr_me handling corrected diff --git a/header/fsw_misc.h b/header/fsw_misc.h --- a/header/fsw_misc.h +++ b/header/fsw_misc.h @@ -20,6 +20,28 @@ enum lfr_reset_cause_t{ UNEXP_RESET }; +typedef struct{ + unsigned char dpu_spw_parity; + unsigned char dpu_spw_disconnect; + unsigned char dpu_spw_escape; + unsigned char dpu_spw_credit; + unsigned char dpu_spw_write_sync; + unsigned char timecode_erroneous; + unsigned char timecode_missing; + unsigned char timecode_invalid; + unsigned char time_timecode_it; + unsigned char time_not_synchro; + unsigned char time_timecode_ctr; + unsigned char ahb_correctable; +} hk_lfr_le_t; + +typedef struct{ + unsigned char dpu_spw_early_eop; + unsigned char dpu_spw_invalid_addr; + unsigned char dpu_spw_eep; + unsigned char dpu_spw_rx_too_big; +} hk_lfr_me_t; + extern gptimer_regs_t *gptimer_regs; extern void ASR16_get_FPRF_IURF_ErrorCounters( unsigned int*, unsigned int* ); extern void CCR_getInstructionAndDataErrorCounters( unsigned int*, unsigned int* ); diff --git a/src/fsw_misc.c b/src/fsw_misc.c --- a/src/fsw_misc.c +++ b/src/fsw_misc.c @@ -775,58 +775,143 @@ void set_hk_lfr_reset_cause( enum lfr_re } -void hk_lfr_le_me_he_update() +void increment_hk_counter( unsigned char newValue, unsigned char oldValue, unsigned int *counter ) { - unsigned int hk_lfr_le_cnt; - unsigned int hk_lfr_me_cnt; - unsigned int hk_lfr_he_cnt; - unsigned int current_hk_lfr_le_cnt; - unsigned int current_hk_lfr_me_cnt; - unsigned int current_hk_lfr_he_cnt; + int delta; + + delta = 0; - hk_lfr_le_cnt = 0; - hk_lfr_me_cnt = 0; - hk_lfr_he_cnt = 0; - current_hk_lfr_le_cnt = ((unsigned int) housekeeping_packet.hk_lfr_le_cnt[0]) * 256 + housekeeping_packet.hk_lfr_le_cnt[1]; - current_hk_lfr_me_cnt = ((unsigned int) housekeeping_packet.hk_lfr_me_cnt[0]) * 256 + housekeeping_packet.hk_lfr_me_cnt[1]; - current_hk_lfr_he_cnt = ((unsigned int) housekeeping_packet.hk_lfr_he_cnt[0]) * 256 + housekeeping_packet.hk_lfr_he_cnt[1]; + if (newValue >= oldValue) + { + delta = newValue - oldValue; + } + else + { + delta = 255 - oldValue + newValue; + } + + *counter = *counter + delta; +} - //update the low severity error counter - hk_lfr_le_cnt = - current_hk_lfr_le_cnt - + housekeeping_packet.hk_lfr_dpu_spw_parity - + housekeeping_packet.hk_lfr_dpu_spw_disconnect - + housekeeping_packet.hk_lfr_dpu_spw_escape - + housekeeping_packet.hk_lfr_dpu_spw_credit - + housekeeping_packet.hk_lfr_dpu_spw_write_sync - + housekeeping_packet.hk_lfr_timecode_erroneous - + housekeeping_packet.hk_lfr_timecode_missing - + housekeeping_packet.hk_lfr_timecode_invalid - + housekeeping_packet.hk_lfr_time_timecode_it - + housekeeping_packet.hk_lfr_time_not_synchro - + housekeeping_packet.hk_lfr_time_timecode_ctr - + housekeeping_packet.hk_lfr_ahb_correctable; +void hk_lfr_le_update( void ) +{ + static hk_lfr_le_t old_hk_lfr_le = {0}; + hk_lfr_le_t new_hk_lfr_le; + unsigned int counter; + + counter = ((unsigned int) housekeeping_packet.hk_lfr_le_cnt[0]) * 256 + housekeeping_packet.hk_lfr_le_cnt[1]; + + // DPU + new_hk_lfr_le.dpu_spw_parity = housekeeping_packet.hk_lfr_dpu_spw_parity; + new_hk_lfr_le.dpu_spw_disconnect= housekeeping_packet.hk_lfr_dpu_spw_disconnect; + new_hk_lfr_le.dpu_spw_escape = housekeeping_packet.hk_lfr_dpu_spw_escape; + new_hk_lfr_le.dpu_spw_credit = housekeeping_packet.hk_lfr_dpu_spw_credit; + new_hk_lfr_le.dpu_spw_write_sync= housekeeping_packet.hk_lfr_dpu_spw_write_sync; + // TIMECODE + new_hk_lfr_le.timecode_erroneous= housekeeping_packet.hk_lfr_timecode_erroneous; + new_hk_lfr_le.timecode_missing = housekeeping_packet.hk_lfr_timecode_missing; + new_hk_lfr_le.timecode_invalid = housekeeping_packet.hk_lfr_timecode_invalid; + // TIME + new_hk_lfr_le.time_timecode_it = housekeeping_packet.hk_lfr_time_timecode_it; + new_hk_lfr_le.time_not_synchro = housekeeping_packet.hk_lfr_time_not_synchro; + new_hk_lfr_le.time_timecode_ctr = housekeeping_packet.hk_lfr_time_timecode_ctr; + //AHB + new_hk_lfr_le.ahb_correctable = housekeeping_packet.hk_lfr_ahb_correctable; // housekeeping_packet.hk_lfr_dpu_spw_rx_ahb => not handled by the grspw driver // housekeeping_packet.hk_lfr_dpu_spw_tx_ahb => not handled by the grspw driver + // update the le counter + // DPU + increment_hk_counter( new_hk_lfr_le.dpu_spw_parity, old_hk_lfr_le.dpu_spw_parity, counter ); + increment_hk_counter( new_hk_lfr_le.dpu_spw_disconnect,old_hk_lfr_le.dpu_spw_disconnect, counter ); + increment_hk_counter( new_hk_lfr_le.dpu_spw_escape, old_hk_lfr_le.dpu_spw_escape, counter ); + increment_hk_counter( new_hk_lfr_le.dpu_spw_credit, old_hk_lfr_le.dpu_spw_credit, counter ); + increment_hk_counter( new_hk_lfr_le.dpu_spw_write_sync,old_hk_lfr_le.dpu_spw_write_sync, counter ); + // TIMECODE + increment_hk_counter( new_hk_lfr_le.timecode_erroneous,old_hk_lfr_le.timecode_erroneous, counter ); + increment_hk_counter( new_hk_lfr_le.timecode_missing, old_hk_lfr_le.timecode_missing, counter ); + increment_hk_counter( new_hk_lfr_le.timecode_invalid, old_hk_lfr_le.timecode_invalid, counter ); + // TIME + increment_hk_counter( new_hk_lfr_le.time_timecode_it, old_hk_lfr_le.time_timecode_it, counter ); + increment_hk_counter( new_hk_lfr_le.time_not_synchro, old_hk_lfr_le.time_not_synchro, counter ); + increment_hk_counter( new_hk_lfr_le.time_timecode_ctr, old_hk_lfr_le.time_timecode_ctr, counter ); + // AHB + increment_hk_counter( new_hk_lfr_le.ahb_correctable, old_hk_lfr_le.ahb_correctable, counter ); + + // DPU + old_hk_lfr_le.dpu_spw_parity = new_hk_lfr_le.dpu_spw_parity; + old_hk_lfr_le.dpu_spw_disconnect= new_hk_lfr_le.dpu_spw_disconnect; + old_hk_lfr_le.dpu_spw_escape = new_hk_lfr_le.dpu_spw_escape; + old_hk_lfr_le.dpu_spw_credit = new_hk_lfr_le.dpu_spw_credit; + old_hk_lfr_le.dpu_spw_write_sync= new_hk_lfr_le.dpu_spw_write_sync; + // TIMECODE + old_hk_lfr_le.timecode_erroneous= new_hk_lfr_le.timecode_erroneous; + old_hk_lfr_le.timecode_missing = new_hk_lfr_le.timecode_missing; + old_hk_lfr_le.timecode_invalid = new_hk_lfr_le.timecode_invalid; + // TIME + old_hk_lfr_le.time_timecode_it = new_hk_lfr_le.time_timecode_it; + old_hk_lfr_le.time_not_synchro = new_hk_lfr_le.time_not_synchro; + old_hk_lfr_le.time_timecode_ctr = new_hk_lfr_le.time_timecode_ctr; + //AHB + old_hk_lfr_le.ahb_correctable = new_hk_lfr_le.ahb_correctable; + // housekeeping_packet.hk_lfr_dpu_spw_rx_ahb => not handled by the grspw driver + // housekeeping_packet.hk_lfr_dpu_spw_tx_ahb => not handled by the grspw driver + + // update housekeeping packet counters, convert unsigned int numbers in 2 bytes numbers + // LE + housekeeping_packet.hk_lfr_le_cnt[0] = (unsigned char) ((hk_lfr_le_cnt & 0xff00) >> 8); + housekeeping_packet.hk_lfr_le_cnt[1] = (unsigned char) (hk_lfr_le_cnt & 0x00ff); +} + +void hk_lfr_me_update( void ) +{ + static hk_lfr_me_t old_hk_lfr_me = {0}; + hk_lfr_me_t new_hk_lfr_me; + unsigned int counter; + + counter = ((unsigned int) housekeeping_packet.hk_lfr_me_cnt[0]) * 256 + housekeeping_packet.hk_lfr_me_cnt[1]; + + // get the current values + new_hk_lfr_me.dpu_spw_early_eop = housekeeping_packet.hk_lfr_dpu_spw_early_eop; + new_hk_lfr_me.dpu_spw_invalid_addr = housekeeping_packet.hk_lfr_dpu_spw_invalid_addr; + new_hk_lfr_me.dpu_spw_eep = housekeeping_packet.hk_lfr_dpu_spw_eep; + new_hk_lfr_me.dpu_spw_rx_too_big = housekeeping_packet.hk_lfr_dpu_spw_rx_too_big; + + // update the me counter + increment_hk_counter( new_hk_lfr_me.dpu_spw_early_eop, old_hk_lfr_me.dpu_spw_early_eop, counter ); + increment_hk_counter( new_hk_lfr_me.dpu_spw_invalid_addr, old_hk_lfr_me.dpu_spw_invalid_addr, counter ); + increment_hk_counter( new_hk_lfr_me.dpu_spw_eep, old_hk_lfr_me.dpu_spw_eep, counter ); + increment_hk_counter( new_hk_lfr_me.dpu_spw_rx_too_big, old_hk_lfr_me.dpu_spw_rx_too_big, counter ); + + // store the counters for the next time + old_hk_lfr_me.dpu_spw_early_eop = new_hk_lfr_me.dpu_spw_early_eop; + old_hk_lfr_me.dpu_spw_invalid_addr = new_hk_lfr_me.dpu_spw_invalid_addr; + old_hk_lfr_me.dpu_spw_eep = new_hk_lfr_me.dpu_spw_eep; + old_hk_lfr_me.dpu_spw_rx_too_big = new_hk_lfr_me.dpu_spw_rx_too_big; + + // update housekeeping packet counters, convert unsigned int numbers in 2 bytes numbers + // ME + housekeeping_packet.hk_lfr_me_cnt[0] = (unsigned char) ((hk_lfr_me_cnt & 0xff00) >> 8); + housekeeping_packet.hk_lfr_me_cnt[1] = (unsigned char) (hk_lfr_me_cnt & 0x00ff); +} + +void hk_lfr_le_me_he_update() +{ + + unsigned int hk_lfr_he_cnt; + + hk_lfr_he_cnt = ((unsigned int) housekeeping_packet.hk_lfr_he_cnt[0]) * 256 + housekeeping_packet.hk_lfr_he_cnt[1]; + + //update the low severity error counter + hk_lfr_le_update( ); + //update the medium severity error counter - hk_lfr_me_cnt = - current_hk_lfr_me_cnt - + housekeeping_packet.hk_lfr_dpu_spw_early_eop - + housekeeping_packet.hk_lfr_dpu_spw_invalid_addr - + housekeeping_packet.hk_lfr_dpu_spw_eep - + housekeeping_packet.hk_lfr_dpu_spw_rx_too_big; + hk_lfr_me_update(); //update the high severity error counter hk_lfr_he_cnt = 0; // update housekeeping packet counters, convert unsigned int numbers in 2 bytes numbers - // LE - housekeeping_packet.hk_lfr_le_cnt[0] = (unsigned char) ((hk_lfr_le_cnt & 0xff00) >> 8); - housekeeping_packet.hk_lfr_le_cnt[1] = (unsigned char) (hk_lfr_le_cnt & 0x00ff); - // ME - housekeeping_packet.hk_lfr_me_cnt[0] = (unsigned char) ((hk_lfr_me_cnt & 0xff00) >> 8); - housekeeping_packet.hk_lfr_me_cnt[1] = (unsigned char) (hk_lfr_me_cnt & 0x00ff); // HE housekeeping_packet.hk_lfr_he_cnt[0] = (unsigned char) ((hk_lfr_he_cnt & 0xff00) >> 8); housekeeping_packet.hk_lfr_he_cnt[1] = (unsigned char) (hk_lfr_he_cnt & 0x00ff); diff --git a/src/fsw_spacewire.c b/src/fsw_spacewire.c --- a/src/fsw_spacewire.c +++ b/src/fsw_spacewire.c @@ -159,7 +159,7 @@ rtems_task recv_task( rtems_task_argumen } else { estimatedPacketLength = (unsigned int) (len - CCSDS_TC_TM_PACKET_OFFSET - 3); // => -3 is for Prot ID, Reserved and User App bytes - PRINTF1("incoming TC with Length (byte): %d\n", len - 3); + //PRINTF1("incoming TC with Length (byte): %d\n", len - 3); currentTC_LEN_RCV[ 0 ] = (unsigned char) (estimatedPacketLength >> 8); currentTC_LEN_RCV[ 1 ] = (unsigned char) (estimatedPacketLength ); // CHECK THE TC diff --git a/src/lfr_cpu_usage_report.c b/src/lfr_cpu_usage_report.c --- a/src/lfr_cpu_usage_report.c +++ b/src/lfr_cpu_usage_report.c @@ -49,8 +49,8 @@ unsigned char lfr_rtems_cpu_usage_report for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; - if ( the_thread != NULL ) - total_units += the_thread->cpu_time_used; + if ( the_thread != NULL ) { + total_units += the_thread->cpu_time_used; } } } } diff --git a/src/processing/fsw_processing.c b/src/processing/fsw_processing.c --- a/src/processing/fsw_processing.c +++ b/src/processing/fsw_processing.c @@ -665,8 +665,14 @@ void ASM_compress_reorganize_and_divide_ ( compressed_spec_mat[ offsetCompressed ] + averaged_spec_mat[ offsetASM + k ] * fBinMask ); } - compressed_spec_mat[ offsetCompressed ] = - (divider != 0.) ? compressed_spec_mat[ offsetCompressed ] / (divider * nbBinsToAverage) : 0.0; + if (divider != 0) + { + compressed_spec_mat[ offsetCompressed ] = compressed_spec_mat[ offsetCompressed ] / (divider * nbBinsToAverage); + } + else + { + compressed_spec_mat[ offsetCompressed ] = 0.0; + } } }