diff --git a/.hgsubstate b/.hgsubstate --- a/.hgsubstate +++ b/.hgsubstate @@ -1,2 +1,2 @@ -19349b3a5e90c2bacc9d369aa948c68aa9e8d5f0 LFR_basic-parameters -da5613aff4446e5c98b3c56bc32ce7008b3e2340 header/lfr_common_headers +a309a930a482e851061936696121f4a1cf7005de LFR_basic-parameters +2b5dc338fb623046072d6eb98c26ad884e17f95e header/lfr_common_headers diff --git a/FSW-qt/fsw-qt.pro b/FSW-qt/fsw-qt.pro --- a/FSW-qt/fsw-qt.pro +++ b/FSW-qt/fsw-qt.pro @@ -12,7 +12,7 @@ SWVERSION=-1-0 DEFINES += SW_VERSION_N1=2 # major DEFINES += SW_VERSION_N2=0 # minor DEFINES += SW_VERSION_N3=2 # patch -DEFINES += SW_VERSION_N4=0 # internal +DEFINES += SW_VERSION_N4=1 # internal # #QMAKE_CFLAGS_RELEASE += -fprofile-arcs -ftest-coverage @@ -28,6 +28,7 @@ contains( CONFIG, lpp_dpu_destid ) { contains( CONFIG, debug_tch ) { DEFINES += DEBUG_TCH } +DEFINES += LSB_FIRST_TCH contains( CONFIG, vhdl_dev ) { DEFINES += VHDL_DEV @@ -64,7 +65,7 @@ INCLUDEPATH += \ $${PWD}/../header \ $${PWD}/../header/lfr_common_headers \ $${PWD}/../header/processing \ - $${PWD}/../src/LFR_basic-parameters + $${PWD}/../LFR_basic-parameters SOURCES += \ ../src/wf_handler.c \ @@ -81,7 +82,7 @@ SOURCES += \ ../src/processing/avf1_prc1.c \ ../src/processing/avf2_prc2.c \ ../src/lfr_cpu_usage_report.c \ - ../src/LFR_basic-parameters/basic_parameters.c + ../LFR_basic-parameters/basic_parameters.c HEADERS += \ ../header/wf_handler.h \ @@ -99,12 +100,12 @@ HEADERS += \ ../header/processing/avf2_prc2.h \ ../header/fsw_params_wf_handler.h \ ../header/lfr_cpu_usage_report.h \ - ../src/LFR_basic-parameters/basic_parameters.h \ - ../src/LFR_basic-parameters/basic_parameters_params.h \ ../header/lfr_common_headers/ccsds_types.h \ ../header/lfr_common_headers/fsw_params.h \ ../header/lfr_common_headers/fsw_params_nb_bytes.h \ ../header/lfr_common_headers/fsw_params_processing.h \ ../header/lfr_common_headers/TC_types.h \ - ../header/lfr_common_headers/tm_byte_positions.h + ../header/lfr_common_headers/tm_byte_positions.h \ + ../LFR_basic-parameters/basic_parameters.h \ + ../LFR_basic-parameters/basic_parameters_params.h diff --git a/header/grlib_regs.h b/header/grlib_regs.h --- a/header/grlib_regs.h +++ b/header/grlib_regs.h @@ -90,6 +90,10 @@ typedef struct{ volatile unsigned int f3_1_fine_time; // 0x88 // unsigned int buffer_length; // 0x8c = buffer length in burst 2688 / 16 = 168 + // + volatile unsigned int v; // 0x90 + volatile unsigned int e1; // 0x94 + volatile unsigned int e2; // 0x98 } waveform_picker_regs_0_1_18_t; typedef struct { @@ -111,7 +115,7 @@ typedef struct { volatile unsigned int f1_0_coarse_time; // 0x30 volatile unsigned int f1_0_fine_time; // 0x34 volatile unsigned int f1_1_coarse_time; // 0x38 - volatile unsigned int f1_1_time_time; // 0x3C + volatile unsigned int f1_1_fine_time; // 0x3C // volatile unsigned int f2_0_coarse_time; // 0x40 volatile unsigned int f2_0_fine_time; // 0x44 diff --git a/header/processing/avf0_prc0.h b/header/processing/avf0_prc0.h --- a/header/processing/avf0_prc0.h +++ b/header/processing/avf0_prc0.h @@ -27,10 +27,11 @@ rtems_task prc0_task( rtems_task_argumen // FUNCTIONS void reset_nb_sm_f0( unsigned char lfrMode ); +void init_k_coefficients_f0( void ); +void test_TCH( void ); //******* // EXTERN -extern ring_node *ring_node_for_averaging_sm_f0; extern rtems_status_code get_message_queue_id_prc0( rtems_id *queue_id ); #endif // AVF0_PRC0_H_INCLUDED diff --git a/header/processing/avf1_prc1.h b/header/processing/avf1_prc1.h --- a/header/processing/avf1_prc1.h +++ b/header/processing/avf1_prc1.h @@ -2,6 +2,7 @@ #define AVF1_PRC1_H #include "fsw_processing.h" +#include "basic_parameters.h" typedef struct { unsigned int norm_bp1; @@ -24,10 +25,10 @@ rtems_task prc1_task( rtems_task_argumen // FUNCTIONS void reset_nb_sm_f1( unsigned char lfrMode ); +void init_k_coefficients_f1( void ); //******* // EXTERN -extern struct ring_node *ring_node_for_averaging_sm_f1; extern rtems_status_code get_message_queue_id_prc1( rtems_id *queue_id ); #endif // AVF1_PRC1_H diff --git a/header/processing/avf2_prc2.h b/header/processing/avf2_prc2.h --- a/header/processing/avf2_prc2.h +++ b/header/processing/avf2_prc2.h @@ -2,6 +2,7 @@ #define AVF2_PRC2_H #include "fsw_processing.h" +#include "basic_parameters.h" typedef struct { unsigned int norm_bp1; @@ -18,11 +19,11 @@ rtems_task prc2_task( rtems_task_argumen // FUNCTIONS void reset_nb_sm_f2( void ); -void SM_average_f2(float *averaged_spec_mat_f2, ring_node *ring_node, unsigned int nbAverageNormF2 ); +void SM_average_f2(float *averaged_spec_mat_f2, ring_node *ring_node, unsigned int nbAverageNormF2 , asm_msg *msgForMATR); +void init_k_coefficients_f2( void ); //******* // EXTERN -extern struct ring_node *ring_node_for_averaging_sm_f2; extern rtems_status_code get_message_queue_id_prc2( rtems_id *queue_id ); #endif // AVF2_PRC2_H diff --git a/header/processing/fsw_processing.h b/header/processing/fsw_processing.h --- a/header/processing/fsw_processing.h +++ b/header/processing/fsw_processing.h @@ -21,7 +21,25 @@ typedef struct ring_node_asm typedef struct { - Header_TM_LFR_SCIENCE_BP_t header; + unsigned char targetLogicalAddress; + unsigned char protocolIdentifier; + unsigned char reserved; + unsigned char userApplication; + unsigned char packetID[2]; + unsigned char packetSequenceControl[2]; + unsigned char packetLength[2]; + // DATA FIELD HEADER + unsigned char spare1_pusVersion_spare2; + unsigned char serviceType; + unsigned char serviceSubType; + unsigned char destinationID; + unsigned char time[6]; + // AUXILIARY HEADER + unsigned char sid; + unsigned char biaStatusInfo; + unsigned char acquisitionTime[6]; + unsigned char pa_lfr_bp_blk_nr[2]; + // SOURCE DATA unsigned char data[ 30 * 22 ]; // MAX size is 22 * 30 [TM_LFR_SCIENCE_BURST_BP2_F1] } bp_packet; @@ -36,8 +54,10 @@ typedef struct ring_node_asm *norm; ring_node_asm *burst_sbm; rtems_event_set event; - unsigned int coarseTime; - unsigned int fineTime; + unsigned int coarseTimeNORM; + unsigned int fineTimeNORM; + unsigned int coarseTimeSBM; + unsigned int fineTimeSBM; } asm_msg; extern volatile int sm_f0[ ]; @@ -49,11 +69,13 @@ extern struct param_local_str param_loca // registers extern time_management_regs_t *time_management_regs; -extern spectral_matrix_regs_t *spectral_matrix_regs; +extern volatile spectral_matrix_regs_t *spectral_matrix_regs; extern rtems_name misc_name[5]; extern rtems_id Task_id[20]; /* array of task ids */ +// +ring_node * getRingNodeForAveraging( unsigned char frequencyChannel); // ISR rtems_isr spectral_matrices_isr( rtems_vector_number vector ); rtems_isr spectral_matrices_isr_simu( rtems_vector_number vector ); @@ -71,7 +93,7 @@ void ASM_generic_init_ring(ring_node_asm // Basic Parameters void BP_reset_current_ring_nodes( void ); -void BP_init_header( Header_TM_LFR_SCIENCE_BP_t *header, +void BP_init_header(bp_packet *header, unsigned int apid, unsigned char sid, unsigned int packetLength , unsigned char blkNr); void BP_init_header_with_spare( Header_TM_LFR_SCIENCE_BP_with_spare_t *header, @@ -87,8 +109,6 @@ void reset_sm_status( void ); void reset_spectral_matrix_regs( void ); void set_time(unsigned char *time, unsigned char *timeInBuffer ); unsigned long long int get_acquisition_time( unsigned char *timePtr ); -void close_matrix_actions( unsigned int *nb_sm, unsigned int nb_sm_before_avf, rtems_id avf_task_id, - ring_node *node_for_averaging, ring_node *ringNode, unsigned long long int time ); unsigned char getSID( rtems_event_set event ); extern rtems_status_code get_message_queue_id_prc1( rtems_id *queue_id ); @@ -97,11 +117,12 @@ extern rtems_status_code get_message_que //*************************************** // DEFINITIONS OF STATIC INLINE FUNCTIONS static inline void SM_average(float *averaged_spec_mat_NORM, float *averaged_spec_mat_SBM, - ring_node *ring_node_tab[], - unsigned int nbAverageNORM, unsigned int nbAverageSBM ); + ring_node *ring_node_tab[], + unsigned int nbAverageNORM, unsigned int nbAverageSBM, + asm_msg *msgForMATR ); static inline void SM_average_debug( float *averaged_spec_mat_NORM, float *averaged_spec_mat_SBM, - ring_node *ring_node_tab[], - unsigned int nbAverageNORM, unsigned int nbAverageSBM ); + ring_node *ring_node_tab[], + unsigned int nbAverageNORM, unsigned int nbAverageSBM ); static inline void ASM_reorganize_and_divide(float *averaged_spec_mat, float *averaged_spec_mat_reorganized, float divider ); static inline void ASM_compress_reorganize_and_divide(float *averaged_spec_mat, float *compressed_spec_mat, @@ -110,8 +131,9 @@ static inline void ASM_compress_reorgani static inline void ASM_convert(volatile float *input_matrix, char *output_matrix); void SM_average( float *averaged_spec_mat_NORM, float *averaged_spec_mat_SBM, - ring_node *ring_node_tab[], - unsigned int nbAverageNORM, unsigned int nbAverageSBM ) + ring_node *ring_node_tab[], + unsigned int nbAverageNORM, unsigned int nbAverageSBM, + asm_msg *msgForMATR ) { float sum; unsigned int i; @@ -131,6 +153,10 @@ void SM_average( float *averaged_spec_ma { averaged_spec_mat_NORM[ i ] = sum; averaged_spec_mat_SBM[ i ] = sum; + msgForMATR->coarseTimeNORM = ring_node_tab[0]->coarseTime; + msgForMATR->fineTimeNORM = ring_node_tab[0]->fineTime; + msgForMATR->coarseTimeSBM = ring_node_tab[0]->coarseTime; + msgForMATR->fineTimeSBM = ring_node_tab[0]->fineTime; } else if ( (nbAverageNORM != 0) && (nbAverageSBM != 0) ) { @@ -141,6 +167,8 @@ void SM_average( float *averaged_spec_ma { averaged_spec_mat_NORM[ i ] = ( averaged_spec_mat_NORM[ i ] + sum ); averaged_spec_mat_SBM[ i ] = sum; + msgForMATR->coarseTimeSBM = ring_node_tab[0]->coarseTime; + msgForMATR->fineTimeSBM = ring_node_tab[0]->fineTime; } else { @@ -186,21 +214,22 @@ void ASM_reorganize_and_divide( float *a { int frequencyBin; int asmComponent; - unsigned int offsetAveragedSpecMatReorganized; - unsigned int offsetAveragedSpecMat; + unsigned int offsetASM; + unsigned int offsetASMReorganized; + // BUILD DATA for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++) { for( frequencyBin = 0; frequencyBin < NB_BINS_PER_SM; frequencyBin++ ) { - offsetAveragedSpecMatReorganized = + offsetASMReorganized = frequencyBin * NB_VALUES_PER_SM + asmComponent; - offsetAveragedSpecMat = + offsetASM = asmComponent * NB_BINS_PER_SM + frequencyBin; - averaged_spec_mat_reorganized[offsetAveragedSpecMatReorganized ] = - averaged_spec_mat[ offsetAveragedSpecMat ] / divider; + averaged_spec_mat_reorganized[offsetASMReorganized ] = + averaged_spec_mat[ offsetASM ] / divider; } } } @@ -214,7 +243,7 @@ void ASM_compress_reorganize_and_divide( int offsetCompressed; int k; - // build data + // BUILD DATA for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++) { for( frequencyBin = 0; frequencyBin < nbBinsCompressedMatrix; frequencyBin++ ) @@ -231,8 +260,10 @@ void ASM_compress_reorganize_and_divide( { compressed_spec_mat[offsetCompressed ] = ( compressed_spec_mat[ offsetCompressed ] - + averaged_spec_mat[ offsetASM + k ] ) / (divider * nbBinsToAverage); + + averaged_spec_mat[ offsetASM + k ] ); } + compressed_spec_mat[ offsetCompressed ] = + compressed_spec_mat[ offsetCompressed ] / (divider * nbBinsToAverage); } } } diff --git a/src/fsw_init.c b/src/fsw_init.c --- a/src/fsw_init.c +++ b/src/fsw_init.c @@ -108,6 +108,9 @@ rtems_task Init( rtems_task_argument ign init_parameter_dump(); init_local_mode_parameters(); init_housekeeping_parameters(); + init_k_coefficients_f0(); + init_k_coefficients_f1(); + init_k_coefficients_f2(); // waveform picker initialization WFP_init_rings(); // initialize the waveform rings @@ -215,6 +218,8 @@ rtems_task Init( rtems_task_argument ign BOOT_PRINTF("delete INIT\n") +// test_TCH(); + status = rtems_task_delete(RTEMS_SELF); } diff --git a/src/fsw_misc.c b/src/fsw_misc.c --- a/src/fsw_misc.c +++ b/src/fsw_misc.c @@ -225,7 +225,7 @@ rtems_task hous_task(rtems_task_argument spacewire_update_statistics(); -// get_v_e1_e2_f3( housekeeping_packet.hk_lfr_sc_v_f3 ); + get_v_e1_e2_f3( housekeeping_packet.hk_lfr_sc_v_f3 ); get_cpu_load( (unsigned char *) &housekeeping_packet.hk_lfr_cpu_load ); // SEND PACKET @@ -443,107 +443,20 @@ void send_dumb_hk( void ) void get_v_e1_e2_f3( unsigned char *spacecraft_potential ) { - unsigned long long int localTime_asLong; - unsigned long long int f3_0_AcquisitionTime_asLong; - unsigned long long int f3_1_AcquisitionTime_asLong; - unsigned long long int deltaT; - unsigned long long int deltaT_f3_0; - unsigned long long int deltaT_f3_1; - unsigned char *bufferPtr; - - unsigned int offset_in_samples; - unsigned int offset_in_bytes; - unsigned char f3; - - bufferPtr = NULL; - deltaT = 0; - deltaT_f3_0 = 0xffffffff; - deltaT_f3_1 = 0xffffffff; - f3 = 16; // v, e1 and e2 will be picked up each second, f3 = 16 Hz - - if (lfrCurrentMode == LFR_MODE_STANDBY) - { - spacecraft_potential[0] = 0x00; - spacecraft_potential[1] = 0x00; - spacecraft_potential[2] = 0x00; - spacecraft_potential[3] = 0x00; - spacecraft_potential[4] = 0x00; - spacecraft_potential[5] = 0x00; - } - else - { - localTime_asLong = get_acquisition_time( (unsigned char *) &time_management_regs->coarse_time ); - f3_0_AcquisitionTime_asLong = get_acquisition_time( (unsigned char *) &waveform_picker_regs->f3_0_coarse_time ); - f3_1_AcquisitionTime_asLong = get_acquisition_time( (unsigned char *) &waveform_picker_regs->f3_1_coarse_time ); - printf("localTime 0x%llx, f3_0 0x%llx, f3_1 0x%llx\n", - localTime_asLong, - f3_0_AcquisitionTime_asLong, - f3_1_AcquisitionTime_asLong); - - if ( localTime_asLong >= f3_0_AcquisitionTime_asLong ) - { - deltaT_f3_0 = localTime_asLong - f3_0_AcquisitionTime_asLong; - } - - if ( localTime_asLong > f3_1_AcquisitionTime_asLong ) - { - deltaT_f3_1 = localTime_asLong - f3_1_AcquisitionTime_asLong; - } + unsigned char* v_ptr; + unsigned char* e1_ptr; + unsigned char* e2_ptr; - if ( (deltaT_f3_0 != 0xffffffff) && (deltaT_f3_1 != 0xffffffff) ) - { - if ( deltaT_f3_0 > deltaT_f3_1 ) - { - deltaT = deltaT_f3_1; - bufferPtr = (unsigned char*) waveform_picker_regs->addr_data_f3_1; - } - else - { - deltaT = deltaT_f3_0; - bufferPtr = (unsigned char*) waveform_picker_regs->addr_data_f3_0; - } - } - else if ( (deltaT_f3_0 == 0xffffffff) && (deltaT_f3_1 != 0xffffffff) ) - { - deltaT = deltaT_f3_1; - bufferPtr = (unsigned char*) waveform_picker_regs->addr_data_f3_1; - } - else if ( (deltaT_f3_0 != 0xffffffff) && (deltaT_f3_1 == 0xffffffff) ) - { - deltaT = deltaT_f3_0; - bufferPtr = (unsigned char*) waveform_picker_regs->addr_data_f3_1; - } - else - { - deltaT = 0xffffffff; - } + v_ptr = (unsigned char *) &waveform_picker_regs->v; + e1_ptr = (unsigned char *) &waveform_picker_regs->e1; + e2_ptr = (unsigned char *) &waveform_picker_regs->e2; - if ( deltaT == 0xffffffff ) - { - spacecraft_potential[0] = 0x00; - spacecraft_potential[1] = 0x00; - spacecraft_potential[2] = 0x00; - spacecraft_potential[3] = 0x00; - spacecraft_potential[4] = 0x00; - spacecraft_potential[5] = 0x00; - } - else - { - offset_in_samples = ( (double) deltaT ) / 65536. * f3; - if ( offset_in_samples > (NB_SAMPLES_PER_SNAPSHOT - 1) ) - { - PRINTF1("ERR *** in get_v_e1_e2_f3 *** trying to read out of the buffer, counter = %d\n", offset_in_samples) - offset_in_samples = NB_SAMPLES_PER_SNAPSHOT - 1; - } - offset_in_bytes = offset_in_samples * NB_WORDS_SWF_BLK * 4; - spacecraft_potential[0] = bufferPtr[ offset_in_bytes + 0]; - spacecraft_potential[1] = bufferPtr[ offset_in_bytes + 1]; - spacecraft_potential[2] = bufferPtr[ offset_in_bytes + 2]; - spacecraft_potential[3] = bufferPtr[ offset_in_bytes + 3]; - spacecraft_potential[4] = bufferPtr[ offset_in_bytes + 4]; - spacecraft_potential[5] = bufferPtr[ offset_in_bytes + 5]; - } - } + spacecraft_potential[0] = v_ptr[2]; + spacecraft_potential[1] = v_ptr[3]; + spacecraft_potential[2] = e1_ptr[2]; + spacecraft_potential[3] = e1_ptr[3]; + spacecraft_potential[4] = e2_ptr[2]; + spacecraft_potential[5] = e2_ptr[3]; } void get_cpu_load( unsigned char *resource_statistics ) diff --git a/src/fsw_spacewire.c b/src/fsw_spacewire.c --- a/src/fsw_spacewire.c +++ b/src/fsw_spacewire.c @@ -690,8 +690,8 @@ void init_header_cwf( Header_TM_LFR_SCIE header->userApplication = CCSDS_USER_APP; header->packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE; header->packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT; - header->packetLength[0] = (unsigned char) (TM_LEN_SCI_CWF_336 >> 8); - header->packetLength[1] = (unsigned char) (TM_LEN_SCI_CWF_336 ); + header->packetLength[0] = 0x00; + header->packetLength[1] = 0x00; // DATA FIELD HEADER header->spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2; header->serviceType = TM_TYPE_LFR_SCIENCE; // service type @@ -706,8 +706,8 @@ void init_header_cwf( Header_TM_LFR_SCIE // AUXILIARY DATA HEADER header->sid = 0x00; header->hkBIA = DEFAULT_HKBIA; - header->blkNr[0] = (unsigned char) (BLK_NR_CWF >> 8); - header->blkNr[1] = (unsigned char) (BLK_NR_CWF ); + header->blkNr[0] = 0x00; + header->blkNr[1] = 0x00; } void init_header_swf( Header_TM_LFR_SCIENCE_SWF_t *header ) @@ -808,6 +808,11 @@ int spw_send_waveform_CWF( ring_node *ri fineTime = ring_node_to_send->fineTime; dataPtr = (int*) ring_node_to_send->buffer_address; + header->packetLength[0] = (unsigned char) (TM_LEN_SCI_CWF_336 >> 8); + header->packetLength[1] = (unsigned char) (TM_LEN_SCI_CWF_336 ); + header->blkNr[0] = (unsigned char) (BLK_NR_CWF >> 8); + header->blkNr[1] = (unsigned char) (BLK_NR_CWF ); + for (i=0; ifineTime; dataPtr = (char*) ring_node_to_send->buffer_address; + header->packetLength[0] = (unsigned char) (TM_LEN_SCI_CWF_672 >> 8); + header->packetLength[1] = (unsigned char) (TM_LEN_SCI_CWF_672 ); + header->blkNr[0] = (unsigned char) (BLK_NR_CWF_SHORT_F3 >> 8); + header->blkNr[1] = (unsigned char) (BLK_NR_CWF_SHORT_F3 ); + //********************* // SEND CWF3_light DATA for (i=0; icoarseTime; - msgForMATR.fineTime = ring_node_for_averaging_sm_f0->fineTime; // //**************************************** - ring_node_tab[NB_SM_BEFORE_AVF0-1] = ring_node_for_averaging_sm_f0; + nodeForAveraging = getRingNodeForAveraging( 0 ); + + ring_node_tab[NB_SM_BEFORE_AVF0-1] = nodeForAveraging; for ( i = 2; i < (NB_SM_BEFORE_AVF0+1); i++ ) { - ring_node_for_averaging_sm_f0 = ring_node_for_averaging_sm_f0->previous; - ring_node_tab[NB_SM_BEFORE_AVF0-i] = ring_node_for_averaging_sm_f0; + nodeForAveraging = nodeForAveraging->previous; + ring_node_tab[NB_SM_BEFORE_AVF0-i] = nodeForAveraging; } // compute the average and store it in the averaged_sm_f1 buffer SM_average( current_ring_node_asm_norm_f0->matrix, current_ring_node_asm_burst_sbm_f0->matrix, ring_node_tab, - nb_norm_bp1, nb_sbm_bp1 ); + nb_norm_bp1, nb_sbm_bp1, + &msgForMATR ); // update nb_average nb_norm_bp1 = nb_norm_bp1 + NB_SM_BEFORE_AVF0; @@ -157,7 +160,6 @@ rtems_task avf0_task( rtems_task_argumen if ( (lfrCurrentMode == LFR_MODE_NORMAL) || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) ) { -// PRINTF1("%lld\n", localTime) msgForMATR.event = msgForMATR.event | RTEMS_EVENT_NORM_ASM_F0; } } @@ -185,10 +187,10 @@ rtems_task prc0_task( rtems_task_argumen rtems_status_code status; rtems_id queue_id; rtems_id queue_id_q_p0; - bp_packet_with_spare packet_norm_bp1_f0; - bp_packet packet_norm_bp2_f0; - bp_packet packet_sbm_bp1_f0; - bp_packet packet_sbm_bp2_f0; + bp_packet_with_spare packet_norm_bp1; + bp_packet packet_norm_bp2; + bp_packet packet_sbm_bp1; + bp_packet packet_sbm_bp2; ring_node *current_ring_node_to_send_asm_f0; unsigned long long int localTime; @@ -199,10 +201,10 @@ rtems_task prc0_task( rtems_task_argumen //************* // NORM headers - BP_init_header_with_spare( &packet_norm_bp1_f0.header, + BP_init_header_with_spare( &packet_norm_bp1.header, APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP1_F0, PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0, NB_BINS_COMPRESSED_SM_F0 ); - BP_init_header( &packet_norm_bp2_f0.header, + BP_init_header( &packet_norm_bp2, APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP2_F0, PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0, NB_BINS_COMPRESSED_SM_F0); @@ -210,28 +212,28 @@ rtems_task prc0_task( rtems_task_argumen // BURST SBM1 and SBM2 headers if ( lfrRequestedMode == LFR_MODE_BURST ) { - BP_init_header( &packet_sbm_bp1_f0.header, + BP_init_header( &packet_sbm_bp1, APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP1_F0, PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0); - BP_init_header( &packet_sbm_bp2_f0.header, + BP_init_header( &packet_sbm_bp2, APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP2_F0, PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0); } else if ( lfrRequestedMode == LFR_MODE_SBM1 ) { - BP_init_header( &packet_sbm_bp1_f0.header, + BP_init_header( &packet_sbm_bp1, APID_TM_SCIENCE_SBM1_SBM2, SID_SBM1_BP1_F0, PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0); - BP_init_header( &packet_sbm_bp2_f0.header, + BP_init_header( &packet_sbm_bp2, APID_TM_SCIENCE_SBM1_SBM2, SID_SBM1_BP2_F0, PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0); } else if ( lfrRequestedMode == LFR_MODE_SBM2 ) { - BP_init_header( &packet_sbm_bp1_f0.header, + BP_init_header( &packet_sbm_bp1, APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP1_F0, PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0); - BP_init_header( &packet_sbm_bp2_f0.header, + BP_init_header( &packet_sbm_bp2, APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP2_F0, PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0); } @@ -275,22 +277,22 @@ rtems_task prc0_task( rtems_task_argumen NB_BINS_COMPRESSED_SM_SBM_F0, NB_BINS_TO_AVERAGE_ASM_SBM_F0, ASM_F0_INDICE_START); // 2) compute the BP1 set -// BP1_set( compressed_sm_norm_f0, NB_BINS_COMPRESSED_SM_SBM_F0, bp1_sbm_f0 ); + BP1_set( compressed_sm_sbm_f0, k_coeff_intercalib_f0_sbm, NB_BINS_COMPRESSED_SM_SBM_F0, packet_sbm_bp1.data ); // 3) send the BP1 set - set_time( packet_sbm_bp1_f0.header.time, (unsigned char *) &incomingMsg->coarseTime ); - set_time( packet_sbm_bp1_f0.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime ); - BP_send( (char *) &packet_sbm_bp1_f0, queue_id, + set_time( packet_sbm_bp1.time, (unsigned char *) &incomingMsg->coarseTimeSBM ); + set_time( packet_sbm_bp1.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeSBM ); + BP_send( (char *) &packet_sbm_bp1, queue_id, PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0 + PACKET_LENGTH_DELTA, sid); // 4) compute the BP2 set if needed if ( (incomingMsg->event & RTEMS_EVENT_BURST_BP2_F0) || (incomingMsg->event & RTEMS_EVENT_SBM_BP2_F0) ) { // 1) compute the BP2 set - + BP2_set( compressed_sm_sbm_f0, NB_BINS_COMPRESSED_SM_SBM_F0, packet_sbm_bp2.data ); // 2) send the BP2 set - set_time( packet_sbm_bp2_f0.header.time, (unsigned char *) &incomingMsg->coarseTime ); - set_time( packet_sbm_bp2_f0.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime ); - BP_send( (char *) &packet_sbm_bp2_f0, queue_id, + set_time( packet_sbm_bp2.time, (unsigned char *) &incomingMsg->coarseTimeSBM ); + set_time( packet_sbm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeSBM ); + BP_send( (char *) &packet_sbm_bp2, queue_id, PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0 + PACKET_LENGTH_DELTA, sid); } @@ -309,23 +311,63 @@ rtems_task prc0_task( rtems_task_argumen NB_BINS_COMPRESSED_SM_F0, NB_BINS_TO_AVERAGE_ASM_F0, ASM_F0_INDICE_START ); // 2) compute the BP1 set -// BP1_set( compressed_sm_norm_f0, NB_BINS_COMPRESSED_SM_F0, bp1_norm_f0 ); + BP1_set( compressed_sm_norm_f0, k_coeff_intercalib_f0_norm, NB_BINS_COMPRESSED_SM_F0, packet_norm_bp1.data ); // 3) send the BP1 set - set_time( packet_norm_bp1_f0.header.time, (unsigned char *) &incomingMsg->coarseTime ); - set_time( packet_norm_bp1_f0.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime ); - BP_send( (char *) &packet_norm_bp1_f0, queue_id, + set_time( packet_norm_bp1.header.time, (unsigned char *) &incomingMsg->coarseTimeNORM ); + set_time( packet_norm_bp1.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM ); + BP_send( (char *) &packet_norm_bp1, queue_id, PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0 + PACKET_LENGTH_DELTA, SID_NORM_BP1_F0 ); if (incomingMsg->event & RTEMS_EVENT_NORM_BP2_F0) { // 1) compute the BP2 set using the same ASM as the one used for BP1 - + BP2_set( compressed_sm_norm_f0, NB_BINS_COMPRESSED_SM_F0, packet_norm_bp2.data ); // 2) send the BP2 set - set_time( packet_norm_bp2_f0.header.time, (unsigned char *) &incomingMsg->coarseTime ); - set_time( packet_norm_bp2_f0.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime ); - BP_send( (char *) &packet_norm_bp2_f0, queue_id, + set_time( packet_norm_bp2.time, (unsigned char *) &incomingMsg->coarseTimeNORM ); + set_time( packet_norm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM ); + BP_send( (char *) &packet_norm_bp2, queue_id, PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0 + PACKET_LENGTH_DELTA, SID_NORM_BP2_F0); + + // < TMP DATA> +#define INDEX_COMPRESSED 1 + unsigned int signif; + float significand; + unsigned int nbitexp = 6; + unsigned int nbitsig = 16 - nbitexp; // number of bits for the significand + unsigned int rangesig = (1 << nbitsig)-1; // == 2^nbitsig - 1 + int expmax = 32; + int expmin = expmax - ((int) (1 << nbitexp)) + 1; + int exponent; + float auto_a0; + exponent = ( (int) ( (packet_norm_bp2.data[INDEX_COMPRESSED * NB_BYTES_PER_BP2] & 0xfc) >> 2) ) + expmin; // [1111 1100] + printf("exponent = %x, computed with exp = %x, expmin = %d\n", + exponent, + (packet_norm_bp2.data[INDEX_COMPRESSED * NB_BYTES_PER_BP2] & 0xfc) >> 2, + expmin); + signif = ( (packet_norm_bp2.data[INDEX_COMPRESSED * NB_BYTES_PER_BP2] & 0x3) << 8 ) + packet_norm_bp2.data[INDEX_COMPRESSED * NB_BYTES_PER_BP2+1]; + significand = ( ( (float) signif ) / ( (float) rangesig) + 1) / 2; + auto_a0 = significand * pow(2,exponent); + printf("(BP2) [%d] compressed = %f *** AUTO A0 = %x, %x, exponent = %x, significand = %f ===> %f\n", + INDEX_COMPRESSED, + compressed_sm_norm_f0[INDEX_COMPRESSED * NB_VALUES_PER_SM], + packet_norm_bp2.data[ INDEX_COMPRESSED * NB_BYTES_PER_BP2], + packet_norm_bp2.data[ INDEX_COMPRESSED * NB_BYTES_PER_BP2 + 1], + exponent, significand, auto_a0 ); +// printf("(BP2) 0 = %f, 1 = %f, 2 = %f, 3 = %f, 4 = %f, 5 = %f, 6 = %f, 7 = %f, 8 = %f, 9 = %f, 10 = %f,\n", +// compressed_sm_norm_f0[0 * NB_VALUES_PER_SM], +// compressed_sm_norm_f0[1 * NB_VALUES_PER_SM], +// compressed_sm_norm_f0[2 * NB_VALUES_PER_SM], +// compressed_sm_norm_f0[3 * NB_VALUES_PER_SM], +// compressed_sm_norm_f0[4 * NB_VALUES_PER_SM], +// compressed_sm_norm_f0[5 * NB_VALUES_PER_SM], +// compressed_sm_norm_f0[6 * NB_VALUES_PER_SM], +// compressed_sm_norm_f0[7 * NB_VALUES_PER_SM], +// compressed_sm_norm_f0[8 * NB_VALUES_PER_SM], +// compressed_sm_norm_f0[9 * NB_VALUES_PER_SM], +// compressed_sm_norm_f0[10 * NB_VALUES_PER_SM]); + // + } } @@ -337,9 +379,25 @@ rtems_task prc0_task( rtems_task_argumen nb_sm_before_f0.norm_bp1 ); // 2) convert the float array in a char array ASM_convert( asm_f0_reorganized, (char*) current_ring_node_to_send_asm_f0->buffer_address ); - current_ring_node_to_send_asm_f0->coarseTime = incomingMsg->coarseTime; - current_ring_node_to_send_asm_f0->fineTime = incomingMsg->fineTime; + current_ring_node_to_send_asm_f0->coarseTime = incomingMsg->coarseTimeNORM; + current_ring_node_to_send_asm_f0->fineTime = incomingMsg->fineTimeNORM; current_ring_node_to_send_asm_f0->sid = SID_NORM_ASM_F0; + + // < TMP DATA> +#define INDEX_TO_LOOK_AT 31 + float b11; + unsigned char *b11_charPtr; + b11_charPtr = (unsigned char*) &b11; + b11_charPtr[0] = ((unsigned char *) current_ring_node_to_send_asm_f0->buffer_address)[(INDEX_TO_LOOK_AT * NB_VALUES_PER_SM) * 2]; + b11_charPtr[1] = ((unsigned char *) current_ring_node_to_send_asm_f0->buffer_address)[(INDEX_TO_LOOK_AT * NB_VALUES_PER_SM) * 2 +1]; + b11_charPtr[2] = 0x00; + b11_charPtr[3] = 0x00; + printf("(ASM) initial = %f, reorganized and divided = %f, converted = %f\n", + incomingMsg->norm->matrix[INDEX_TO_LOOK_AT], // 32 * 96 = 3072 Hz + asm_f0_reorganized[ INDEX_TO_LOOK_AT * NB_VALUES_PER_SM ], + b11); + // + // 3) send the spectral matrix packets status = rtems_message_queue_send( queue_id, ¤t_ring_node_to_send_asm_f0, sizeof( ring_node* ) ); // change asm ring node @@ -385,3 +443,56 @@ void reset_nb_sm_f0( unsigned char lfrMo nb_sm_before_f0.burst_sbm_bp2 = nb_sm_before_f0.burst_bp2; } } + +void init_k_coefficients_f0( void ) +{ + init_k_coefficients( k_coeff_intercalib_f0_norm, NB_BINS_COMPRESSED_SM_F0 ); + init_k_coefficients( k_coeff_intercalib_f0_sbm, NB_BINS_COMPRESSED_SM_SBM_F0); +} + +void test_TCH( void ) +{ +#define NB_BINS_COMPRESSED_MATRIX_TCH 1 + + unsigned char LFR_BP1_f0[NB_BINS_COMPRESSED_MATRIX_TCH*NB_BYTES_BP1]; + unsigned char LFR_BP2_f0[NB_BINS_COMPRESSED_MATRIX_TCH*NB_BYTES_BP2]; + float k_coefficients[NB_BINS_COMPRESSED_MATRIX_TCH * NB_K_COEFF_PER_BIN]; + + float compressed_spectral_matrix_TCH[ NB_BINS_COMPRESSED_MATRIX_TCH * NB_VALUES_PER_SPECTRAL_MATRIX ] = { + 1.02217712e+06, + -8.58216250e+04, + -3.22199043e+04, + 1.01597820e+05, + 8.10333875e+05, + 1.19030141e+05, + -8.69636688e+05, + 5.01504031e+05, + -1.01948547e+05, + 1.35475020e+04, + -3.67825469e+04, + -1.10950273e+05, + 2.10715000e+04, + 4.49727383e+04, + -4.37282031e+04, + 3.83337695e+03, + 1.05317175e+06, + -4.04155312e+05, + -1.32987891e+05, + 1.49277250e+05, + -4.39122625e+05, + 9.46006250e+05, + 2.64386625e+05, + 3.71843125e+05, + 3.39770000e+05 + }; + + init_k_coefficients( k_coefficients, NB_BINS_COMPRESSED_MATRIX_TCH ); + + printf("\n"); + + BP1_set(compressed_spectral_matrix_TCH, k_coefficients, NB_BINS_COMPRESSED_MATRIX_TCH, LFR_BP1_f0); + + printf("\n"); + + BP2_set(compressed_spectral_matrix_TCH, NB_BINS_COMPRESSED_MATRIX_TCH, LFR_BP2_f0); +} diff --git a/src/processing/avf1_prc1.c b/src/processing/avf1_prc1.c --- a/src/processing/avf1_prc1.c +++ b/src/processing/avf1_prc1.c @@ -11,6 +11,8 @@ nb_sm_before_bp_asm_f1 nb_sm_before_f1; +extern ring_node sm_ring_f1[ ]; + //*** // F1 ring_node_asm asm_ring_norm_f1 [ NB_RING_NODES_ASM_NORM_F1 ]; @@ -24,6 +26,9 @@ char asm_f1_char [ TIME_OFFSET float compressed_sm_norm_f1[ TOTAL_SIZE_COMPRESSED_ASM_NORM_F1]; float compressed_sm_sbm_f1 [ TOTAL_SIZE_COMPRESSED_ASM_SBM_F1 ]; +float k_coeff_intercalib_f1_norm[ NB_BINS_COMPRESSED_SM_F1 * NB_K_COEFF_PER_BIN ]; // 13 * 32 = 416 +float k_coeff_intercalib_f1_sbm[ NB_BINS_COMPRESSED_SM_SBM_F1 * NB_K_COEFF_PER_BIN ]; // 26 * 32 = 832 + //************ // RTEMS TASKS @@ -35,7 +40,8 @@ rtems_task avf1_task( rtems_task_argumen rtems_status_code status; rtems_id queue_id_prc1; asm_msg msgForMATR; - ring_node *ring_node_tab[8]; + ring_node *nodeForAveraging; + ring_node *ring_node_tab[NB_SM_BEFORE_AVF0]; ring_node_asm *current_ring_node_asm_burst_sbm_f1; ring_node_asm *current_ring_node_asm_norm_f1; @@ -73,23 +79,24 @@ rtems_task avf1_task( rtems_task_argumen msgForMATR.norm = current_ring_node_asm_norm_f1; msgForMATR.burst_sbm = current_ring_node_asm_burst_sbm_f1; msgForMATR.event = 0x00; // this composite event will be sent to the PRC1 task - msgForMATR.coarseTime = ring_node_for_averaging_sm_f1->coarseTime; - msgForMATR.fineTime = ring_node_for_averaging_sm_f1->fineTime; // //**************************************** - ring_node_tab[NB_SM_BEFORE_AVF1-1] = ring_node_for_averaging_sm_f1; + nodeForAveraging = getRingNodeForAveraging( 1 ); + + ring_node_tab[NB_SM_BEFORE_AVF1-1] = nodeForAveraging; for ( i = 2; i < (NB_SM_BEFORE_AVF1+1); i++ ) { - ring_node_for_averaging_sm_f1 = ring_node_for_averaging_sm_f1->previous; - ring_node_tab[NB_SM_BEFORE_AVF1-i] = ring_node_for_averaging_sm_f1; + nodeForAveraging = nodeForAveraging->previous; + ring_node_tab[NB_SM_BEFORE_AVF1-i] = nodeForAveraging; } // compute the average and store it in the averaged_sm_f1 buffer SM_average( current_ring_node_asm_norm_f1->matrix, current_ring_node_asm_burst_sbm_f1->matrix, ring_node_tab, - nb_norm_bp1, nb_sbm_bp1 ); + nb_norm_bp1, nb_sbm_bp1, + &msgForMATR ); // update nb_average nb_norm_bp1 = nb_norm_bp1 + NB_SM_BEFORE_AVF1; @@ -198,7 +205,7 @@ rtems_task prc1_task( rtems_task_argumen BP_init_header_with_spare( &packet_norm_bp1.header, APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP1_F1, PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F1, NB_BINS_COMPRESSED_SM_F1 ); - BP_init_header( &packet_norm_bp2.header, + BP_init_header( &packet_norm_bp2, APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP2_F1, PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F1, NB_BINS_COMPRESSED_SM_F1); @@ -206,19 +213,19 @@ rtems_task prc1_task( rtems_task_argumen // BURST and SBM2 headers if ( lfrRequestedMode == LFR_MODE_BURST ) { - BP_init_header( &packet_sbm_bp1.header, + BP_init_header( &packet_sbm_bp1, APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP1_F1, PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F1, NB_BINS_COMPRESSED_SM_SBM_F1); - BP_init_header( &packet_sbm_bp2.header, + BP_init_header( &packet_sbm_bp2, APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP2_F1, PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F1, NB_BINS_COMPRESSED_SM_SBM_F1); } else if ( lfrRequestedMode == LFR_MODE_SBM2 ) { - BP_init_header( &packet_sbm_bp1.header, + BP_init_header( &packet_sbm_bp1, APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP1_F1, PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F1, NB_BINS_COMPRESSED_SM_SBM_F1); - BP_init_header( &packet_sbm_bp2.header, + BP_init_header( &packet_sbm_bp2, APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP2_F1, PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F1, NB_BINS_COMPRESSED_SM_SBM_F1); } @@ -261,10 +268,10 @@ rtems_task prc1_task( rtems_task_argumen NB_BINS_COMPRESSED_SM_SBM_F1, NB_BINS_TO_AVERAGE_ASM_SBM_F1, ASM_F1_INDICE_START); // 2) compute the BP1 set - + BP1_set( compressed_sm_sbm_f1, k_coeff_intercalib_f1_sbm, NB_BINS_COMPRESSED_SM_SBM_F1, packet_sbm_bp1.data ); // 3) send the BP1 set - set_time( packet_sbm_bp1.header.time, (unsigned char *) &incomingMsg->coarseTime ); - set_time( packet_sbm_bp1.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime ); + set_time( packet_sbm_bp1.time, (unsigned char *) &incomingMsg->coarseTimeSBM ); + set_time( packet_sbm_bp1.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeSBM ); BP_send( (char *) &packet_sbm_bp1, queue_id_send, PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F1 + PACKET_LENGTH_DELTA, sid ); @@ -272,10 +279,10 @@ rtems_task prc1_task( rtems_task_argumen if ( (incomingMsg->event & RTEMS_EVENT_BURST_BP2_F1) || (incomingMsg->event & RTEMS_EVENT_SBM_BP2_F1) ) { // 1) compute the BP2 set - + BP2_set( compressed_sm_sbm_f1, NB_BINS_COMPRESSED_SM_SBM_F1, packet_norm_bp2.data ); // 2) send the BP2 set - set_time( packet_sbm_bp2.header.time, (unsigned char *) &incomingMsg->coarseTime ); - set_time( packet_sbm_bp2.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime ); + set_time( packet_sbm_bp2.time, (unsigned char *) &incomingMsg->coarseTimeSBM ); + set_time( packet_sbm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeSBM ); BP_send( (char *) &packet_sbm_bp2, queue_id_send, PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F1 + PACKET_LENGTH_DELTA, sid ); @@ -295,20 +302,20 @@ rtems_task prc1_task( rtems_task_argumen NB_BINS_COMPRESSED_SM_F0, NB_BINS_TO_AVERAGE_ASM_F0, ASM_F0_INDICE_START ); // 2) compute the BP1 set - + BP1_set( compressed_sm_norm_f1, k_coeff_intercalib_f1_norm, NB_BINS_COMPRESSED_SM_F1, packet_norm_bp1.data ); // 3) send the BP1 set - set_time( packet_norm_bp1.header.time, (unsigned char *) &incomingMsg->coarseTime ); - set_time( packet_norm_bp1.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime ); + set_time( packet_norm_bp1.header.time, (unsigned char *) &incomingMsg->coarseTimeNORM ); + set_time( packet_norm_bp1.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM ); BP_send( (char *) &packet_norm_bp1, queue_id_send, PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F1 + PACKET_LENGTH_DELTA, SID_NORM_BP1_F1 ); if (incomingMsg->event & RTEMS_EVENT_NORM_BP2_F1) { // 1) compute the BP2 set - + BP2_set( compressed_sm_norm_f1, NB_BINS_COMPRESSED_SM_F1, packet_norm_bp2.data ); // 2) send the BP2 set - set_time( packet_norm_bp2.header.time, (unsigned char *) &incomingMsg->coarseTime ); - set_time( packet_norm_bp2.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime ); + set_time( packet_norm_bp2.time, (unsigned char *) &incomingMsg->coarseTimeNORM ); + set_time( packet_norm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM ); BP_send( (char *) &packet_norm_bp2, queue_id_send, PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F1 + PACKET_LENGTH_DELTA, SID_NORM_BP2_F1 ); @@ -323,8 +330,8 @@ rtems_task prc1_task( rtems_task_argumen nb_sm_before_f1.norm_bp1 ); // 2) convert the float array in a char array ASM_convert( asm_f1_reorganized, (char*) current_ring_node_to_send_asm_f1->buffer_address ); - current_ring_node_to_send_asm_f1->coarseTime = incomingMsg->coarseTime; - current_ring_node_to_send_asm_f1->fineTime = incomingMsg->fineTime; + current_ring_node_to_send_asm_f1->coarseTime = incomingMsg->coarseTimeNORM; + current_ring_node_to_send_asm_f1->fineTime = incomingMsg->fineTimeNORM; current_ring_node_to_send_asm_f1->sid = SID_NORM_ASM_F1; // 3) send the spectral matrix packets status = rtems_message_queue_send( queue_id_send, ¤t_ring_node_to_send_asm_f1, sizeof( ring_node* ) ); @@ -365,3 +372,8 @@ void reset_nb_sm_f1( unsigned char lfrMo } } +void init_k_coefficients_f1( void ) +{ + init_k_coefficients( k_coeff_intercalib_f1_norm, NB_BINS_COMPRESSED_SM_F1 ); + init_k_coefficients( k_coeff_intercalib_f1_sbm, NB_BINS_COMPRESSED_SM_SBM_F1); +} diff --git a/src/processing/avf2_prc2.c b/src/processing/avf2_prc2.c --- a/src/processing/avf2_prc2.c +++ b/src/processing/avf2_prc2.c @@ -11,19 +11,23 @@ nb_sm_before_bp_asm_f2 nb_sm_before_f2; +extern ring_node sm_ring_f2[ ]; + //*** // F2 ring_node_asm asm_ring_norm_f2 [ NB_RING_NODES_ASM_NORM_F2 ]; ring_node_asm asm_ring_burst_sbm_f2[ NB_RING_NODES_ASM_BURST_SBM_F2 ]; -ring_node ring_to_send_asm_f2 [ NB_RING_NODES_ASM_F2 ]; -int buffer_asm_f2 [ NB_RING_NODES_ASM_F2 * TOTAL_SIZE_SM ]; +ring_node ring_to_send_asm_f2 [ NB_RING_NODES_ASM_F2 ]; +int buffer_asm_f2 [ NB_RING_NODES_ASM_F2 * TOTAL_SIZE_SM ]; float asm_f2_reorganized [ TOTAL_SIZE_SM ]; char asm_f2_char [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ]; float compressed_sm_norm_f2[ TOTAL_SIZE_COMPRESSED_ASM_NORM_F2]; float compressed_sm_sbm_f2 [ TOTAL_SIZE_COMPRESSED_ASM_SBM_F2 ]; +float k_coeff_intercalib_f2[ NB_BINS_COMPRESSED_SM_F2 * NB_K_COEFF_PER_BIN ]; // 12 * 32 = 384 + //************ // RTEMS TASKS @@ -35,6 +39,7 @@ rtems_task avf2_task( rtems_task_argumen rtems_status_code status; rtems_id queue_id_prc2; asm_msg msgForMATR; + ring_node *nodeForAveraging; ring_node_asm *current_ring_node_asm_norm_f2; unsigned int nb_norm_bp1; @@ -65,15 +70,28 @@ rtems_task avf2_task( rtems_task_argumen msgForMATR.norm = current_ring_node_asm_norm_f2; msgForMATR.burst_sbm = NULL; msgForMATR.event = 0x00; // this composite event will be sent to the PRC2 task - msgForMATR.coarseTime = ring_node_for_averaging_sm_f2->coarseTime; - msgForMATR.fineTime = ring_node_for_averaging_sm_f2->fineTime; // //**************************************** + nodeForAveraging = getRingNodeForAveraging( 2 ); + +// printf(" **0** %x . %x", sm_ring_f2[0].coarseTime, sm_ring_f2[0].fineTime); +// printf(" **1** %x . %x", sm_ring_f2[1].coarseTime, sm_ring_f2[1].fineTime); +// printf(" **2** %x . %x", sm_ring_f2[2].coarseTime, sm_ring_f2[2].fineTime); +// printf(" **3** %x . %x", sm_ring_f2[3].coarseTime, sm_ring_f2[3].fineTime); +// printf(" **4** %x . %x", sm_ring_f2[4].coarseTime, sm_ring_f2[4].fineTime); +// printf(" **5** %x . %x", sm_ring_f2[5].coarseTime, sm_ring_f2[5].fineTime); +// printf(" **6** %x . %x", sm_ring_f2[6].coarseTime, sm_ring_f2[6].fineTime); +// printf(" **7** %x . %x", sm_ring_f2[7].coarseTime, sm_ring_f2[7].fineTime); +// printf(" **8** %x . %x", sm_ring_f2[8].coarseTime, sm_ring_f2[8].fineTime); +// printf(" **9** %x . %x", sm_ring_f2[9].coarseTime, sm_ring_f2[9].fineTime); +// printf(" **10** %x . %x\n", sm_ring_f2[10].coarseTime, sm_ring_f2[10].fineTime); + // compute the average and store it in the averaged_sm_f2 buffer SM_average_f2( current_ring_node_asm_norm_f2->matrix, - ring_node_for_averaging_sm_f2, - nb_norm_bp1 ); + nodeForAveraging, + nb_norm_bp1, + &msgForMATR ); // update nb_average nb_norm_bp1 = nb_norm_bp1 + NB_SM_BEFORE_AVF2; @@ -108,7 +126,6 @@ rtems_task avf2_task( rtems_task_argumen if ( (lfrCurrentMode == LFR_MODE_NORMAL) || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) ) { -// PRINTF1("%lld\n", localTime) msgForMATR.event = msgForMATR.event | RTEMS_EVENT_NORM_ASM_F2; } } @@ -135,8 +152,8 @@ rtems_task prc2_task( rtems_task_argumen rtems_status_code status; rtems_id queue_id; rtems_id queue_id_q_p2; - bp_packet packet_norm_bp1_f2; - bp_packet packet_norm_bp2_f2; + bp_packet packet_norm_bp1; + bp_packet packet_norm_bp2; ring_node *current_ring_node_to_send_asm_f2; unsigned long long int localTime; @@ -149,10 +166,10 @@ rtems_task prc2_task( rtems_task_argumen //************* // NORM headers - BP_init_header( &packet_norm_bp1_f2.header, + BP_init_header( &packet_norm_bp1, APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP1_F2, PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F2, NB_BINS_COMPRESSED_SM_F2 ); - BP_init_header( &packet_norm_bp2_f2.header, + BP_init_header( &packet_norm_bp2, APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP2_F2, PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F2, NB_BINS_COMPRESSED_SM_F2 ); @@ -190,21 +207,21 @@ rtems_task prc2_task( rtems_task_argumen NB_BINS_COMPRESSED_SM_F2, NB_BINS_TO_AVERAGE_ASM_F2, ASM_F2_INDICE_START ); // 2) compute the BP1 set - + BP1_set( compressed_sm_norm_f2, k_coeff_intercalib_f2, NB_BINS_COMPRESSED_SM_F2, packet_norm_bp1.data ); // 3) send the BP1 set - set_time( packet_norm_bp1_f2.header.time, (unsigned char *) &incomingMsg->coarseTime ); - set_time( packet_norm_bp1_f2.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime ); - BP_send( (char *) &packet_norm_bp1_f2, queue_id, + set_time( packet_norm_bp1.time, (unsigned char *) &incomingMsg->coarseTimeNORM ); + set_time( packet_norm_bp1.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM ); + BP_send( (char *) &packet_norm_bp1, queue_id, PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F2 + PACKET_LENGTH_DELTA, SID_NORM_BP1_F2 ); if (incomingMsg->event & RTEMS_EVENT_NORM_BP2_F2) { // 1) compute the BP2 set using the same ASM as the one used for BP1 - + BP2_set( compressed_sm_norm_f2, NB_BINS_COMPRESSED_SM_F2, packet_norm_bp2.data ); // 2) send the BP2 set - set_time( packet_norm_bp2_f2.header.time, (unsigned char *) &incomingMsg->coarseTime ); - set_time( packet_norm_bp2_f2.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime ); - BP_send( (char *) &packet_norm_bp2_f2, queue_id, + set_time( packet_norm_bp2.time, (unsigned char *) &incomingMsg->coarseTimeNORM ); + set_time( packet_norm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM ); + BP_send( (char *) &packet_norm_bp2, queue_id, PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F2 + PACKET_LENGTH_DELTA, SID_NORM_BP2_F2 ); } @@ -218,8 +235,8 @@ rtems_task prc2_task( rtems_task_argumen nb_sm_before_f2.norm_bp1 ); // 2) convert the float array in a char array ASM_convert( asm_f2_reorganized, (char*) current_ring_node_to_send_asm_f2->buffer_address ); - current_ring_node_to_send_asm_f2->coarseTime = incomingMsg->coarseTime; - current_ring_node_to_send_asm_f2->fineTime = incomingMsg->fineTime; + current_ring_node_to_send_asm_f2->coarseTime = incomingMsg->coarseTimeNORM; + current_ring_node_to_send_asm_f2->fineTime = incomingMsg->fineTimeNORM; current_ring_node_to_send_asm_f2->sid = SID_NORM_ASM_F2; // 3) send the spectral matrix packets status = rtems_message_queue_send( queue_id, ¤t_ring_node_to_send_asm_f2, sizeof( ring_node* ) ); @@ -241,8 +258,9 @@ void reset_nb_sm_f2( void ) } void SM_average_f2( float *averaged_spec_mat_f2, - ring_node *ring_node, - unsigned int nbAverageNormF2 ) + ring_node *ring_node, + unsigned int nbAverageNormF2, + asm_msg *msgForMATR ) { float sum; unsigned int i; @@ -253,6 +271,8 @@ void SM_average_f2( float *averaged_spec if ( (nbAverageNormF2 == 0) ) { averaged_spec_mat_f2[ i ] = sum; + msgForMATR->coarseTimeNORM = ring_node->coarseTime; + msgForMATR->fineTimeNORM = ring_node->fineTime; } else { @@ -260,3 +280,8 @@ void SM_average_f2( float *averaged_spec } } } + +void init_k_coefficients_f2( void ) +{ + init_k_coefficients( k_coeff_intercalib_f2, NB_BINS_COMPRESSED_SM_F2); +} 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 @@ -27,78 +27,91 @@ ring_node *ring_node_for_averaging_sm_f0 ring_node *ring_node_for_averaging_sm_f1; ring_node *ring_node_for_averaging_sm_f2; +// +ring_node * getRingNodeForAveraging( unsigned char frequencyChannel) +{ + ring_node *node; + + node = NULL; + switch ( frequencyChannel ) { + case 0: + node = ring_node_for_averaging_sm_f0; + break; + case 1: + node = ring_node_for_averaging_sm_f1; + break; + case 2: + node = ring_node_for_averaging_sm_f2; + break; + default: + break; + } + + return node; +} + //*********************************************************** // Interrupt Service Routine for spectral matrices processing void spectral_matrices_isr_f0( void ) { unsigned char status; - unsigned long long int time_0; - unsigned long long int time_1; - unsigned long long int syncBit0; - unsigned long long int syncBit1; + rtems_status_code status_code; status = spectral_matrix_regs->status & 0x03; // [0011] get the status_ready_matrix_f0_x bits - time_0 = get_acquisition_time( (unsigned char *) &spectral_matrix_regs->f0_0_coarse_time ); - time_1 = get_acquisition_time( (unsigned char *) &spectral_matrix_regs->f0_1_coarse_time ); - syncBit0 = ( (unsigned long long int) (spectral_matrix_regs->f0_0_coarse_time & 0x80000000) ) << 16; - syncBit1 = ( (unsigned long long int) (spectral_matrix_regs->f0_1_coarse_time & 0x80000000) ) << 16; - switch(status) { case 0: break; case 3: - // send a message if two buffers are ready - rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_6 ); - if ( time_0 < time_1 ) - { - close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0], - ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_0 | syncBit0); - current_ring_node_sm_f0 = current_ring_node_sm_f0->next; - spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->buffer_address; - close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0], - ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_1 | syncBit1); - current_ring_node_sm_f0 = current_ring_node_sm_f0->next; - spectral_matrix_regs->f0_1_address = current_ring_node_sm_f0->buffer_address; - } - else - { - close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0], - ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_1 | syncBit1); - current_ring_node_sm_f0 = current_ring_node_sm_f0->next; - spectral_matrix_regs->f0_1_address = current_ring_node_sm_f0->buffer_address; - close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0], - ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_0 | syncBit0); - current_ring_node_sm_f0 = current_ring_node_sm_f0->next; - spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->buffer_address; - } + // UNEXPECTED VALUE spectral_matrix_regs->status = 0x03; // [0011] + status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_11 ); break; case 1: - close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0], - ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_0 | syncBit0); + ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0->previous; current_ring_node_sm_f0 = current_ring_node_sm_f0->next; + ring_node_for_averaging_sm_f0->coarseTime = spectral_matrix_regs->f0_0_coarse_time; + ring_node_for_averaging_sm_f0->fineTime = spectral_matrix_regs->f0_0_fine_time; spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->buffer_address; - spectral_matrix_regs->status = 0x01; // [0001] + spectral_matrix_regs->status = 0x01; // [0000 0001] + // if there are enough ring nodes ready, wake up an AVFx task + nb_sm_f0 = nb_sm_f0 + 1; + if (nb_sm_f0 == NB_SM_BEFORE_AVF0) + { + if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) + { + status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 ); + } + nb_sm_f0 = 0; + } break; case 2: - close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0], - ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_1 | syncBit1); + ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0->previous; current_ring_node_sm_f0 = current_ring_node_sm_f0->next; - spectral_matrix_regs->f0_1_address = current_ring_node_sm_f0->buffer_address; - spectral_matrix_regs->status = 0x02; // [0010] + ring_node_for_averaging_sm_f0->coarseTime = spectral_matrix_regs->f0_1_coarse_time; + ring_node_for_averaging_sm_f0->fineTime = spectral_matrix_regs->f0_1_fine_time; + spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->buffer_address; + spectral_matrix_regs->status = 0x02; // [0000 0010] + // if there are enough ring nodes ready, wake up an AVFx task + nb_sm_f0 = nb_sm_f0 + 1; + if (nb_sm_f0 == NB_SM_BEFORE_AVF0) + { + if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) + { + status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 ); + } + nb_sm_f0 = 0; + } break; } } void spectral_matrices_isr_f1( void ) { + rtems_status_code status_code; unsigned char status; - unsigned long long int time; - unsigned long long int syncBit; - rtems_status_code status_code; status = (spectral_matrix_regs->status & 0x0c) >> 2; // [1100] get the status_ready_matrix_f0_x bits @@ -112,22 +125,40 @@ void spectral_matrices_isr_f1( void ) status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_11 ); break; case 1: - time = get_acquisition_time( (unsigned char *) &spectral_matrix_regs->f1_0_coarse_time ); - syncBit = ( (unsigned long long int) (spectral_matrix_regs->f1_0_coarse_time & 0x80000000) ) << 16; - close_matrix_actions( &nb_sm_f1, NB_SM_BEFORE_AVF1, Task_id[TASKID_AVF1], - ring_node_for_averaging_sm_f1, current_ring_node_sm_f1, time | syncBit); + ring_node_for_averaging_sm_f1 = current_ring_node_sm_f1->previous; current_ring_node_sm_f1 = current_ring_node_sm_f1->next; + ring_node_for_averaging_sm_f1->coarseTime = spectral_matrix_regs->f1_0_coarse_time; + ring_node_for_averaging_sm_f1->fineTime = spectral_matrix_regs->f1_0_fine_time; spectral_matrix_regs->f1_0_address = current_ring_node_sm_f1->buffer_address; - spectral_matrix_regs->status = 0x04; // [0100] + spectral_matrix_regs->status = 0x04; // [0000 0100] + // if there are enough ring nodes ready, wake up an AVFx task + nb_sm_f1 = nb_sm_f1 + 1; + if (nb_sm_f1 == NB_SM_BEFORE_AVF1) + { + if (rtems_event_send( Task_id[TASKID_AVF1], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) + { + status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 ); + } + nb_sm_f1 = 0; + } break; case 2: - time = get_acquisition_time( (unsigned char *) &spectral_matrix_regs->f1_1_coarse_time ); - syncBit = ( (unsigned long long int) (spectral_matrix_regs->f1_1_coarse_time & 0x80000000) ) << 16; - close_matrix_actions( &nb_sm_f1, NB_SM_BEFORE_AVF1, Task_id[TASKID_AVF1], - ring_node_for_averaging_sm_f1, current_ring_node_sm_f1, time | syncBit); + ring_node_for_averaging_sm_f1 = current_ring_node_sm_f1->previous; current_ring_node_sm_f1 = current_ring_node_sm_f1->next; + ring_node_for_averaging_sm_f1->coarseTime = spectral_matrix_regs->f1_1_coarse_time; + ring_node_for_averaging_sm_f1->fineTime = spectral_matrix_regs->f1_1_fine_time; spectral_matrix_regs->f1_1_address = current_ring_node_sm_f1->buffer_address; - spectral_matrix_regs->status = 0x08; // [1000] + spectral_matrix_regs->status = 0x08; // [1000 0000] + // if there are enough ring nodes ready, wake up an AVFx task + nb_sm_f1 = nb_sm_f1 + 1; + if (nb_sm_f1 == NB_SM_BEFORE_AVF1) + { + if (rtems_event_send( Task_id[TASKID_AVF1], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) + { + status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 ); + } + nb_sm_f1 = 0; + } break; } } @@ -139,10 +170,6 @@ void spectral_matrices_isr_f2( void ) status = (spectral_matrix_regs->status & 0x30) >> 4; // [0011 0000] get the status_ready_matrix_f0_x bits - ring_node_for_averaging_sm_f2 = current_ring_node_sm_f2; - - current_ring_node_sm_f2 = current_ring_node_sm_f2->next; - switch(status) { case 0: @@ -153,6 +180,8 @@ void spectral_matrices_isr_f2( void ) status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_11 ); break; case 1: + ring_node_for_averaging_sm_f2 = current_ring_node_sm_f2->previous; + current_ring_node_sm_f2 = current_ring_node_sm_f2->next; ring_node_for_averaging_sm_f2->coarseTime = spectral_matrix_regs->f2_0_coarse_time; ring_node_for_averaging_sm_f2->fineTime = spectral_matrix_regs->f2_0_fine_time; spectral_matrix_regs->f2_0_address = current_ring_node_sm_f2->buffer_address; @@ -163,6 +192,8 @@ void spectral_matrices_isr_f2( void ) } break; case 2: + ring_node_for_averaging_sm_f2 = current_ring_node_sm_f2->previous; + current_ring_node_sm_f2 = current_ring_node_sm_f2->next; ring_node_for_averaging_sm_f2->coarseTime = spectral_matrix_regs->f2_1_coarse_time; ring_node_for_averaging_sm_f2->fineTime = spectral_matrix_regs->f2_1_fine_time; spectral_matrix_regs->f2_1_address = current_ring_node_sm_f2->buffer_address; @@ -177,14 +208,14 @@ void spectral_matrices_isr_f2( void ) void spectral_matrix_isr_error_handler( void ) { -// rtems_status_code status_code; + rtems_status_code status_code; -// if (spectral_matrix_regs->status & 0x7c0) // [0111 1100 0000] -// { -// status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 ); -// } + if (spectral_matrix_regs->status & 0x7c0) // [0111 1100 0000] + { + status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 ); + } -// spectral_matrix_regs->status = spectral_matrix_regs->status & 0x7c0; + spectral_matrix_regs->status = spectral_matrix_regs->status & 0x7c0; } rtems_isr spectral_matrices_isr( rtems_vector_number vector ) @@ -306,7 +337,7 @@ void SM_reset_current_ring_nodes( void ) //***************** // Basic Parameters -void BP_init_header( Header_TM_LFR_SCIENCE_BP_t *header, +void BP_init_header( bp_packet *header, unsigned int apid, unsigned char sid, unsigned int packetLength, unsigned char blkNr ) { @@ -325,15 +356,21 @@ void BP_init_header( Header_TM_LFR_SCIEN header->serviceType = TM_TYPE_LFR_SCIENCE; // service type header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype header->destinationID = TM_DESTINATION_ID_GROUND; + header->time[0] = 0x00; + header->time[1] = 0x00; + header->time[2] = 0x00; + header->time[3] = 0x00; + header->time[4] = 0x00; + header->time[5] = 0x00; // AUXILIARY DATA HEADER header->sid = sid; header->biaStatusInfo = 0x00; - header->time[0] = 0x00; - header->time[0] = 0x00; - header->time[0] = 0x00; - header->time[0] = 0x00; - header->time[0] = 0x00; - header->time[0] = 0x00; + header->acquisitionTime[0] = 0x00; + header->acquisitionTime[1] = 0x00; + header->acquisitionTime[2] = 0x00; + header->acquisitionTime[3] = 0x00; + header->acquisitionTime[4] = 0x00; + header->acquisitionTime[5] = 0x00; header->pa_lfr_bp_blk_nr[0] = 0x00; // BLK_NR MSB header->pa_lfr_bp_blk_nr[1] = blkNr; // BLK_NR LSB } @@ -420,10 +457,13 @@ void reset_spectral_matrix_regs( void ) reset_sm_status(); + // F1 spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->previous->buffer_address; spectral_matrix_regs->f0_1_address = current_ring_node_sm_f0->buffer_address; + // F2 spectral_matrix_regs->f1_0_address = current_ring_node_sm_f1->previous->buffer_address; spectral_matrix_regs->f1_1_address = current_ring_node_sm_f1->buffer_address; + // F3 spectral_matrix_regs->f2_0_address = current_ring_node_sm_f2->previous->buffer_address; spectral_matrix_regs->f2_1_address = current_ring_node_sm_f2->buffer_address; @@ -453,37 +493,6 @@ unsigned long long int get_acquisition_t return acquisitionTimeAslong; } -void close_matrix_actions(unsigned int *nb_sm, unsigned int nb_sm_before_avf, rtems_id avf_task_id, - ring_node *node_for_averaging, ring_node *ringNode, - unsigned long long int time ) -{ - unsigned char *timePtr; - unsigned char *coarseTimePtr; - unsigned char *fineTimePtr; - rtems_status_code status_code; - - timePtr = (unsigned char *) &time; - coarseTimePtr = (unsigned char *) &node_for_averaging->coarseTime; - fineTimePtr = (unsigned char *) &node_for_averaging->fineTime; - - *nb_sm = *nb_sm + 1; - if (*nb_sm == nb_sm_before_avf) - { - node_for_averaging = ringNode; - coarseTimePtr[0] = timePtr[2]; - coarseTimePtr[1] = timePtr[3]; - coarseTimePtr[2] = timePtr[4]; - coarseTimePtr[3] = timePtr[5]; - fineTimePtr[2] = timePtr[6]; - fineTimePtr[3] = timePtr[7]; - if (rtems_event_send( avf_task_id, RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) - { - status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 ); - } - *nb_sm = 0; - } -} - unsigned char getSID( rtems_event_set event ) { unsigned char sid; diff --git a/src/tc_handler.c b/src/tc_handler.c --- a/src/tc_handler.c +++ b/src/tc_handler.c @@ -466,9 +466,6 @@ int stop_current_mode( void ) LEON_Mask_interrupt( IRQ_WAVEFORM_PICKER ); // mask waveform picker interrupt LEON_Mask_interrupt( IRQ_SPECTRAL_MATRIX ); // clear spectral matrix interrupt - // reset lfr VHDL module - reset_lfr(); - // (2) reset waveform picker registers reset_wfp_burst_enable(); // reset burst and enable bits reset_wfp_status(); // reset all the status bits @@ -477,6 +474,9 @@ int stop_current_mode( void ) set_sm_irq_onNewMatrix( 0 ); // stop the spectral matrices reset_sm_status(); + // reset lfr VHDL module + reset_lfr(); + reset_extractSWF(); // reset the extractSWF flag to false // (4) clear interruptions @@ -769,7 +769,7 @@ void launch_waveform_picker( unsigned ch waveform_picker_regs->start_date = transitionCoarseTime; } - PRINTF1("commutation coarse time = %d\n", transitionCoarseTime) + PRINTF1("commutation coarse time = %x\n", transitionCoarseTime) } void launch_spectral_matrix( void ) diff --git a/src/wf_handler.c b/src/wf_handler.c --- a/src/wf_handler.c +++ b/src/wf_handler.c @@ -41,6 +41,50 @@ ring_node ring_node_wf_snap_extracted; //********************* // Interrupt SubRoutine +ring_node * getRingNodeToSendCWF( unsigned char frequencyChannel) +{ + ring_node *node; + + node = NULL; + switch ( frequencyChannel ) { + case 1: + node = ring_node_to_send_cwf_f1; + break; + case 2: + node = ring_node_to_send_cwf_f2; + break; + case 3: + node = ring_node_to_send_cwf_f3; + break; + default: + break; + } + + return node; +} + +ring_node * getRingNodeToSendSWF( unsigned char frequencyChannel) +{ + ring_node *node; + + node = NULL; + switch ( frequencyChannel ) { + case 0: + node = ring_node_to_send_swf_f0; + break; + case 1: + node = ring_node_to_send_swf_f1; + break; + case 2: + node = ring_node_to_send_swf_f2; + break; + default: + break; + } + + return node; +} + void reset_extractSWF( void ) { extractSWF = false; @@ -157,30 +201,37 @@ inline void waveforms_isr_normal( void ) inline void waveforms_isr_burst( void ) { + unsigned char status; rtems_status_code spare_status; - if ( (waveform_picker_regs->status & 0x30) != 0 ){ // [0100] check the f2 full bit - // (1) change the receiving buffer for the waveform picker + status = (waveform_picker_regs->status & 0x30) >> 4; // [0011 0000] get the status_ready_matrix_f0_x bits + + switch(status) + { + case 1: ring_node_to_send_cwf_f2 = current_ring_node_f2->previous; current_ring_node_f2 = current_ring_node_f2->next; - if ( (waveform_picker_regs->status & 0x10) == 0x10) - { - ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_0_coarse_time; - ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_0_fine_time; - waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address; - waveform_picker_regs->status = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000] - } - else if ( (waveform_picker_regs->status & 0x20) == 0x20) - { - ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_1_coarse_time; - ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_1_fine_time; - waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address; - waveform_picker_regs->status = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000] - } - // (2) send an event for the waveforms transmission + ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_0_coarse_time; + ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_0_fine_time; + waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address; + waveform_picker_regs->status = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000] if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) { spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 ); } + break; + case 2: + ring_node_to_send_cwf_f2 = current_ring_node_f2->previous; + current_ring_node_f2 = current_ring_node_f2->next; + ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_1_coarse_time; + ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_1_fine_time; + waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address; + waveform_picker_regs->status = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000] + if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) { + spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 ); + } + break; + default: + break; } } @@ -442,13 +493,13 @@ rtems_task wfrm_task(rtems_task_argument RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out); if(resynchronisationEngaged == false) { // engage resynchronisation -// snapshot_resynchronization( (unsigned char *) ring_node_to_send_swf_f0->coarseTime ); + snapshot_resynchronization( (unsigned char *) &ring_node_to_send_swf_f0->coarseTime ); resynchronisationEngaged = true; } else { // reset delta_snapshot to the nominal value PRINTF("no resynchronisation, reset delta_snapshot to the nominal value\n") -// set_wfp_delta_snapshot(); + set_wfp_delta_snapshot(); resynchronisationEngaged = false; } // @@ -532,12 +583,11 @@ rtems_task cwf3_task(rtems_task_argument { PRINTF("send CWF_LONG_F3\n") ring_node_to_send_cwf_f3->sid = SID_NORM_CWF_LONG_F3; - status = rtems_message_queue_send( queue_id, &ring_node_to_send_cwf_f2, sizeof( ring_node* ) ); + status = rtems_message_queue_send( queue_id, &ring_node_to_send_cwf_f3, sizeof( ring_node* ) ); } else { PRINTF("send CWF_F3 (light)\n") - ring_node_to_send_cwf_f3->sid = SID_NORM_CWF_F3; send_waveform_CWF3_light( ring_node_to_send_cwf_f3, &ring_node_cwf3_light, queue_id ); } @@ -564,6 +614,7 @@ rtems_task cwf2_task(rtems_task_argument rtems_event_set event_out; rtems_id queue_id; rtems_status_code status; + ring_node *ring_node_to_send; status = get_message_queue_id_send( &queue_id ); if (status != RTEMS_SUCCESSFUL) @@ -577,21 +628,26 @@ rtems_task cwf2_task(rtems_task_argument // wait for an RTEMS_EVENT rtems_event_receive( RTEMS_EVENT_MODE_BURST | RTEMS_EVENT_MODE_SBM2, RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out); + ring_node_to_send = getRingNodeToSendCWF( 2 ); + printf("ring_node_to_send_cwf === coarse = %x, fine = %x\n", ring_node_to_send->coarseTime, ring_node_to_send->fineTime); + printf("**0** %x . %x", waveform_ring_f2[0].coarseTime, waveform_ring_f2[0].fineTime); + printf(" **1** %x . %x", waveform_ring_f2[1].coarseTime, waveform_ring_f2[1].fineTime); + printf(" **2** %x . %x", waveform_ring_f2[2].coarseTime, waveform_ring_f2[2].fineTime); + printf(" **3** %x . %x", waveform_ring_f2[3].coarseTime, waveform_ring_f2[3].fineTime); + printf(" **4** %x . %x\n", waveform_ring_f2[4].coarseTime, waveform_ring_f2[4].fineTime); if (event_out == RTEMS_EVENT_MODE_BURST) { -// send_waveform_CWF( ring_node_to_send_cwf_f2, SID_BURST_CWF_F2, headerCWF_F2_BURST, queue_id ); - ring_node_to_send_cwf_f2->sid = SID_BURST_CWF_F2; - status = rtems_message_queue_send( queue_id, &ring_node_to_send_cwf_f2, sizeof( ring_node* ) ); + ring_node_to_send->sid = SID_BURST_CWF_F2; + status = rtems_message_queue_send( queue_id, &ring_node_to_send, sizeof( ring_node* ) ); } if (event_out == RTEMS_EVENT_MODE_SBM2) { -// send_waveform_CWF( ring_node_to_send_cwf_f2, SID_SBM2_CWF_F2, headerCWF_F2_SBM2, queue_id ); - ring_node_to_send_cwf_f2->sid = SID_SBM2_CWF_F2; - status = rtems_message_queue_send( queue_id, &ring_node_to_send_cwf_f2, sizeof( ring_node* ) ); + ring_node_to_send->sid = SID_SBM2_CWF_F2; + status = rtems_message_queue_send( queue_id, &ring_node_to_send, sizeof( ring_node* ) ); // launch snapshot extraction if needed if (extractSWF == true) { - ring_node_to_send_swf_f2 = ring_node_to_send_cwf_f2; + ring_node_to_send_swf_f2 = ring_node_to_send; // extract the snapshot build_snapshot_from_ring( ring_node_to_send_swf_f2, 2 ); // send the snapshot when built @@ -623,7 +679,7 @@ rtems_task cwf1_task(rtems_task_argument rtems_id queue_id; rtems_status_code status; -// init_header_continuous_wf_table( SID_SBM1_CWF_F1, headerCWF_F1 ); + ring_node * ring_node_to_send_cwf; status = get_message_queue_id_send( &queue_id ); if (status != RTEMS_SUCCESSFUL) @@ -637,12 +693,19 @@ rtems_task cwf1_task(rtems_task_argument // wait for an RTEMS_EVENT rtems_event_receive( RTEMS_EVENT_MODE_SBM1, RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out); + ring_node_to_send_cwf = getRingNodeToSendCWF( 1 ); + printf("ring_node_to_send_cwf === coarse = %x, fine = %x\n", ring_node_to_send_cwf->coarseTime, ring_node_to_send_cwf->fineTime); + printf("**0** %x . %x", waveform_ring_f1[0].coarseTime, waveform_ring_f1[0].fineTime); + printf(" **1** %x . %x", waveform_ring_f1[1].coarseTime, waveform_ring_f1[1].fineTime); + printf(" **2** %x . %x", waveform_ring_f1[2].coarseTime, waveform_ring_f1[2].fineTime); + printf(" **3** %x . %x", waveform_ring_f1[3].coarseTime, waveform_ring_f1[3].fineTime); + printf(" **4** %x . %x\n\n", waveform_ring_f1[4].coarseTime, waveform_ring_f1[4].fineTime); ring_node_to_send_cwf_f1->sid = SID_SBM1_CWF_F1; - status = rtems_message_queue_send( queue_id, &ring_node_to_send_cwf_f1, sizeof( ring_node* ) ); + status = rtems_message_queue_send( queue_id, &ring_node_to_send_cwf, sizeof( ring_node* ) ); // launch snapshot extraction if needed if (extractSWF == true) { - ring_node_to_send_swf_f1 = ring_node_to_send_cwf_f1; + ring_node_to_send_swf_f1 = ring_node_to_send_cwf; // launch the snapshot extraction status = rtems_event_send( Task_id[TASKID_SWBD], RTEMS_EVENT_MODE_SBM1 ); extractSWF = false; @@ -750,18 +813,17 @@ void init_ring(ring_node ring[], unsigne void WFP_reset_current_ring_nodes( void ) { - current_ring_node_f0 = waveform_ring_f0; - ring_node_to_send_swf_f0 = waveform_ring_f0; + current_ring_node_f0 = waveform_ring_f0[0].next; + current_ring_node_f1 = waveform_ring_f1[0].next; + current_ring_node_f2 = waveform_ring_f2[0].next; + current_ring_node_f3 = waveform_ring_f3[0].next; - current_ring_node_f1 = waveform_ring_f1; - ring_node_to_send_cwf_f1 = waveform_ring_f1; + ring_node_to_send_swf_f0 = waveform_ring_f0; ring_node_to_send_swf_f1 = waveform_ring_f1; - - current_ring_node_f2 = waveform_ring_f2; - ring_node_to_send_cwf_f2 = waveform_ring_f2; ring_node_to_send_swf_f2 = waveform_ring_f2; - current_ring_node_f3 = waveform_ring_f3; + ring_node_to_send_cwf_f1 = waveform_ring_f1; + ring_node_to_send_cwf_f2 = waveform_ring_f2; ring_node_to_send_cwf_f3 = waveform_ring_f3; } @@ -782,13 +844,10 @@ int send_waveform_CWF3_light( ring_node unsigned int i; int ret; rtems_status_code status; - spw_ioctl_pkt_send spw_ioctl_send_CWF; + char *sample; int *dataPtr; - spw_ioctl_send_CWF.hlen = TM_HEADER_LEN + 4 + 10; // + 4 is for the protocole extra header, + 10 is for the auxiliary header - spw_ioctl_send_CWF.options = 0; - ret = LFR_DEFAULT; dataPtr = (int*) ring_node_to_send->buffer_address; @@ -1076,21 +1135,17 @@ void reset_wfp_status( void ) void reset_wfp_buffer_addresses( void ) { // F0 - waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->buffer_address; // 0x08 - current_ring_node_f0 = current_ring_node_f0->next; - waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address; // 0x0c + waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->previous->buffer_address; // 0x08 + waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address; // 0x0c // F1 - waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->buffer_address; // 0x10 - current_ring_node_f1 = current_ring_node_f1->next; - waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address; // 0x14 + waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->previous->buffer_address; // 0x10 + waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address; // 0x14 // F2 - waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address; // 0x18 - current_ring_node_f2 = current_ring_node_f2->next; - waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address; // 0x1c + waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->previous->buffer_address; // 0x18 + waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address; // 0x1c // F3 - waveform_picker_regs->addr_data_f3_0 = current_ring_node_f3->buffer_address; // 0x20 - current_ring_node_f3 = current_ring_node_f3->next; - waveform_picker_regs->addr_data_f3_1 = current_ring_node_f3->buffer_address; // 0x24 + waveform_picker_regs->addr_data_f3_0 = current_ring_node_f3->previous->buffer_address; // 0x20 + waveform_picker_regs->addr_data_f3_1 = current_ring_node_f3->buffer_address; // 0x24 } void reset_waveform_picker_regs( void ) diff --git a/testbenches/fsw_matrices_handling/deployment.pri b/testbenches/fsw_matrices_handling/deployment.pri new file mode 100644 --- /dev/null +++ b/testbenches/fsw_matrices_handling/deployment.pri @@ -0,0 +1,191 @@ +# This file was generated by an application wizard of Qt Creator. +# The code below handles deployment to Android and Maemo, aswell as copying +# of the application data to shadow build directories on desktop. +# It is recommended not to modify this file, since newer versions of Qt Creator +# may offer an updated version of it. + +defineTest(qtcAddDeployment) { +for(deploymentfolder, DEPLOYMENTFOLDERS) { + item = item$${deploymentfolder} + greaterThan(QT_MAJOR_VERSION, 4) { + itemsources = $${item}.files + } else { + itemsources = $${item}.sources + } + $$itemsources = $$eval($${deploymentfolder}.source) + itempath = $${item}.path + $$itempath= $$eval($${deploymentfolder}.target) + export($$itemsources) + export($$itempath) + DEPLOYMENT += $$item +} + +MAINPROFILEPWD = $$PWD + +android-no-sdk { + for(deploymentfolder, DEPLOYMENTFOLDERS) { + item = item$${deploymentfolder} + itemfiles = $${item}.files + $$itemfiles = $$eval($${deploymentfolder}.source) + itempath = $${item}.path + $$itempath = /data/user/qt/$$eval($${deploymentfolder}.target) + export($$itemfiles) + export($$itempath) + INSTALLS += $$item + } + + target.path = /data/user/qt + + export(target.path) + INSTALLS += target +} else:android { + for(deploymentfolder, DEPLOYMENTFOLDERS) { + item = item$${deploymentfolder} + itemfiles = $${item}.files + $$itemfiles = $$eval($${deploymentfolder}.source) + itempath = $${item}.path + $$itempath = /assets/$$eval($${deploymentfolder}.target) + export($$itemfiles) + export($$itempath) + INSTALLS += $$item + } + + x86 { + target.path = /libs/x86 + } else: armeabi-v7a { + target.path = /libs/armeabi-v7a + } else { + target.path = /libs/armeabi + } + + export(target.path) + INSTALLS += target +} else:win32 { + copyCommand = + for(deploymentfolder, DEPLOYMENTFOLDERS) { + source = $$MAINPROFILEPWD/$$eval($${deploymentfolder}.source) + source = $$replace(source, /, \\) + sourcePathSegments = $$split(source, \\) + target = $$OUT_PWD/$$eval($${deploymentfolder}.target)/$$last(sourcePathSegments) + target = $$replace(target, /, \\) + target ~= s,\\\\\\.?\\\\,\\, + !isEqual(source,$$target) { + !isEmpty(copyCommand):copyCommand += && + isEqual(QMAKE_DIR_SEP, \\) { + copyCommand += $(COPY_DIR) \"$$source\" \"$$target\" + } else { + source = $$replace(source, \\\\, /) + target = $$OUT_PWD/$$eval($${deploymentfolder}.target) + target = $$replace(target, \\\\, /) + copyCommand += test -d \"$$target\" || mkdir -p \"$$target\" && cp -r \"$$source\" \"$$target\" + } + } + } + !isEmpty(copyCommand) { + copyCommand = @echo Copying application data... && $$copyCommand + copydeploymentfolders.commands = $$copyCommand + first.depends = $(first) copydeploymentfolders + export(first.depends) + export(copydeploymentfolders.commands) + QMAKE_EXTRA_TARGETS += first copydeploymentfolders + } +} else:ios { + copyCommand = + for(deploymentfolder, DEPLOYMENTFOLDERS) { + source = $$MAINPROFILEPWD/$$eval($${deploymentfolder}.source) + source = $$replace(source, \\\\, /) + target = $CODESIGNING_FOLDER_PATH/$$eval($${deploymentfolder}.target) + target = $$replace(target, \\\\, /) + sourcePathSegments = $$split(source, /) + targetFullPath = $$target/$$last(sourcePathSegments) + targetFullPath ~= s,/\\.?/,/, + !isEqual(source,$$targetFullPath) { + !isEmpty(copyCommand):copyCommand += && + copyCommand += mkdir -p \"$$target\" + copyCommand += && cp -r \"$$source\" \"$$target\" + } + } + !isEmpty(copyCommand) { + copyCommand = echo Copying application data... && $$copyCommand + !isEmpty(QMAKE_POST_LINK): QMAKE_POST_LINK += ";" + QMAKE_POST_LINK += "$$copyCommand" + export(QMAKE_POST_LINK) + } +} else:unix { + maemo5 { + desktopfile.files = $${TARGET}.desktop + desktopfile.path = /usr/share/applications/hildon + icon.files = $${TARGET}64.png + icon.path = /usr/share/icons/hicolor/64x64/apps + } else:!isEmpty(MEEGO_VERSION_MAJOR) { + desktopfile.files = $${TARGET}_harmattan.desktop + desktopfile.path = /usr/share/applications + icon.files = $${TARGET}80.png + icon.path = /usr/share/icons/hicolor/80x80/apps + } else { # Assumed to be a Desktop Unix + copyCommand = + for(deploymentfolder, DEPLOYMENTFOLDERS) { + source = $$MAINPROFILEPWD/$$eval($${deploymentfolder}.source) + source = $$replace(source, \\\\, /) + macx { + target = $$OUT_PWD/$${TARGET}.app/Contents/Resources/$$eval($${deploymentfolder}.target) + } else { + target = $$OUT_PWD/$$eval($${deploymentfolder}.target) + } + target = $$replace(target, \\\\, /) + sourcePathSegments = $$split(source, /) + targetFullPath = $$target/$$last(sourcePathSegments) + targetFullPath ~= s,/\\.?/,/, + !isEqual(source,$$targetFullPath) { + !isEmpty(copyCommand):copyCommand += && + copyCommand += $(MKDIR) \"$$target\" + copyCommand += && $(COPY_DIR) \"$$source\" \"$$target\" + } + } + !isEmpty(copyCommand) { + copyCommand = @echo Copying application data... && $$copyCommand + copydeploymentfolders.commands = $$copyCommand + first.depends = $(first) copydeploymentfolders + export(first.depends) + export(copydeploymentfolders.commands) + QMAKE_EXTRA_TARGETS += first copydeploymentfolders + } + } + !isEmpty(target.path) { + installPrefix = $${target.path} + } else { + installPrefix = /opt/$${TARGET} + } + for(deploymentfolder, DEPLOYMENTFOLDERS) { + item = item$${deploymentfolder} + itemfiles = $${item}.files + $$itemfiles = $$eval($${deploymentfolder}.source) + itempath = $${item}.path + $$itempath = $${installPrefix}/$$eval($${deploymentfolder}.target) + export($$itemfiles) + export($$itempath) + INSTALLS += $$item + } + + !isEmpty(desktopfile.path) { + export(icon.files) + export(icon.path) + export(desktopfile.files) + export(desktopfile.path) + INSTALLS += icon desktopfile + } + + isEmpty(target.path) { + target.path = $${installPrefix}/bin + export(target.path) + } + INSTALLS += target +} + +export (ICON) +export (INSTALLS) +export (DEPLOYMENT) +export (LIBS) +export (QMAKE_EXTRA_TARGETS) +} + diff --git a/testbenches/fsw_matrices_handling/fsw_matrices_handling.pro b/testbenches/fsw_matrices_handling/fsw_matrices_handling.pro new file mode 100644 --- /dev/null +++ b/testbenches/fsw_matrices_handling/fsw_matrices_handling.pro @@ -0,0 +1,13 @@ +TEMPLATE = app +CONFIG += console +CONFIG -= app_bundle +CONFIG -= qt + +SOURCES += main.c + +include(deployment.pri) +qtcAddDeployment() + +HEADERS += \ + functions.h + diff --git a/testbenches/fsw_matrices_handling/functions.h b/testbenches/fsw_matrices_handling/functions.h new file mode 100644 --- /dev/null +++ b/testbenches/fsw_matrices_handling/functions.h @@ -0,0 +1,65 @@ +#define NB_VALUES_PER_SM 25 +#define NB_BINS_PER_SM 128 + +#define NB_BINS_COMPRESSED_SM_F0 11 +#define ASM_F0_INDICE_START 17 // 88 bins +#define ASM_F0_INDICE_STOP 104 // 2 packets of 44 bins +#define NB_BINS_TO_AVERAGE_ASM_F0 8 + +void ASM_reorganize_and_divide( float *averaged_spec_mat, float *averaged_spec_mat_reorganized, float divider ) +{ + int frequencyBin; + int asmComponent; + unsigned int offsetASM; + unsigned int offsetASMReorganized; + + // BUILD DATA + for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++) + { + for( frequencyBin = 0; frequencyBin < NB_BINS_PER_SM; frequencyBin++ ) + { + offsetASMReorganized = + frequencyBin * NB_VALUES_PER_SM + + asmComponent; + offsetASM = + asmComponent * NB_BINS_PER_SM + + frequencyBin; + averaged_spec_mat_reorganized[offsetASMReorganized ] = + averaged_spec_mat[ offsetASM ] / divider; + } + } +} + +void ASM_compress_reorganize_and_divide(float *averaged_spec_mat, float *compressed_spec_mat , float divider, + unsigned char nbBinsCompressedMatrix, unsigned char nbBinsToAverage, unsigned char ASMIndexStart ) +{ + int frequencyBin; + int asmComponent; + int offsetASM; + int offsetCompressed; + int k; + + // BUILD DATA + for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++) + { + for( frequencyBin = 0; frequencyBin < nbBinsCompressedMatrix; frequencyBin++ ) + { + offsetCompressed = // NO TIME OFFSET + frequencyBin * NB_VALUES_PER_SM + + asmComponent; + offsetASM = // NO TIME OFFSET + asmComponent * NB_BINS_PER_SM + + ASMIndexStart + + frequencyBin * nbBinsToAverage; + compressed_spec_mat[ offsetCompressed ] = 0; + for ( k = 0; k < nbBinsToAverage; k++ ) + { + compressed_spec_mat[offsetCompressed ] = + ( compressed_spec_mat[ offsetCompressed ] + + averaged_spec_mat[ offsetASM + k ] ); + } + compressed_spec_mat[ offsetCompressed ] = + compressed_spec_mat[ offsetCompressed ] / (divider * nbBinsToAverage); + } + } +} diff --git a/testbenches/fsw_matrices_handling/main.c b/testbenches/fsw_matrices_handling/main.c new file mode 100644 --- /dev/null +++ b/testbenches/fsw_matrices_handling/main.c @@ -0,0 +1,64 @@ +#include + +#include "functions.h" + +int main(void) +{ + printf("Hello World!\n"); + + unsigned int asmComponent; + unsigned int frequencyBin; + unsigned int offset_input_ASM; + + float input_ASM [ NB_VALUES_PER_SM * NB_BINS_PER_SM ]; + float output_ASM [ NB_VALUES_PER_SM * NB_BINS_PER_SM ]; + float output_ASM_compressed [ NB_VALUES_PER_SM * NB_BINS_COMPRESSED_SM_F0 ]; + + //******* + // TEST 1 + + offset_input_ASM = 0; + + for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++) + { + for (frequencyBin = 0; frequencyBin < NB_BINS_PER_SM; frequencyBin++) + { + offset_input_ASM = asmComponent * NB_BINS_PER_SM + frequencyBin; + input_ASM[ offset_input_ASM ] = asmComponent; + } + } + + ASM_reorganize_and_divide( input_ASM, output_ASM, + 1 ); // divider + + ASM_compress_reorganize_and_divide( input_ASM, output_ASM_compressed, + 1, // divider + NB_BINS_COMPRESSED_SM_F0, + NB_BINS_TO_AVERAGE_ASM_F0, + ASM_F0_INDICE_START); + + //******* + // TEST 2 + offset_input_ASM = 0; + + for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++) + { + for (frequencyBin = 0; frequencyBin < NB_BINS_PER_SM; frequencyBin++) + { + offset_input_ASM = asmComponent * NB_BINS_PER_SM + frequencyBin; + input_ASM[ offset_input_ASM ] = asmComponent * NB_BINS_PER_SM + frequencyBin; + } + } + + ASM_reorganize_and_divide( input_ASM, output_ASM, + 1 ); // divider + + ASM_compress_reorganize_and_divide( input_ASM, output_ASM_compressed, + 10, // divider + NB_BINS_COMPRESSED_SM_F0, + NB_BINS_TO_AVERAGE_ASM_F0, + ASM_F0_INDICE_START); + + return 0; +} +