diff --git a/FSW-qt/bin/LEON3_LOAD_SPW.py b/FSW-qt/bin/LEON3_LOAD_SPW.py --- a/FSW-qt/bin/LEON3_LOAD_SPW.py +++ b/FSW-qt/bin/LEON3_LOAD_SPW.py @@ -1,12 +1,12 @@ #!/usr/bin/lppmon -e -proxy.loadSysDriver("RMAPPlugin","RMAPplugin0"); -proxy.loadSysDriverToParent("dsu3plugin","RMAPplugin0"); +proxy.loadSysDriver("RMAPPlugin","RMAPPlugin0"); +proxy.loadSysDriverToParent("dsu3plugin","RMAPPlugin0"); #BUTTON_selectStarDundee.click() BUTTON_selectGRESB.click() +BUTTON_rmapOpenCommunication.click() -BUTTON_rmapOpenCommunication.click() dsu3plugin0.openFile("/opt/DEV_PLE/FSW-qt/bin/fsw") dsu3plugin0.loadFile() dsu3plugin0.run() diff --git a/FSW-qt/bin/load_spectral_matrix.py b/FSW-qt/bin/load_spectral_matrix.py --- a/FSW-qt/bin/load_spectral_matrix.py +++ b/FSW-qt/bin/load_spectral_matrix.py @@ -7,13 +7,14 @@ print hex(matrixF0_Address0) # BUILD THE DATA dataToWrite = [] -for frequencyBin in range(128): - for component in range (25): - dataToWrite.append( component ) +dataToWrite.append( 0x1234abcd ) +dataToWrite.append( 0x4321dcba ) -#for frequencyBin in range(64): -# for component in range (25): -# dataToWrite.append( 2 * component ) +for component in range(25): + for frequencyBin in range (64): + dataToWrite.append( component + frequencyBin ) + for frequencyBin in range (64): + dataToWrite.append( - (component + frequencyBin) ) # WRITE THE DATA print len(dataToWrite) diff --git a/FSW-qt/fsw-qt.pro.user b/FSW-qt/fsw-qt.pro.user --- a/FSW-qt/fsw-qt.pro.user +++ b/FSW-qt/fsw-qt.pro.user @@ -1,6 +1,6 @@ - + ProjectExplorer.Project.ActiveTarget diff --git a/header/fsw_processing.h b/header/fsw_processing.h --- a/header/fsw_processing.h +++ b/header/fsw_processing.h @@ -12,9 +12,9 @@ #include "fsw_spacewire.h" #include "basic_parameters.h" -extern volatile int sm_f0[ ][ SM_HEADER + TOTAL_SIZE_SM ]; -extern volatile int sm_f1[ ][ SM_HEADER + TOTAL_SIZE_SM ]; -extern volatile int sm_f2[ ][ SM_HEADER + TOTAL_SIZE_SM ]; +extern volatile int sm_f0[ ][ TIME_OFFSET + TOTAL_SIZE_SM ]; +extern volatile int sm_f1[ ][ TIME_OFFSET + TOTAL_SIZE_SM ]; +extern volatile int sm_f2[ ][ TIME_OFFSET + TOTAL_SIZE_SM ]; // parameters extern struct param_local_str param_local; @@ -44,9 +44,10 @@ void BP1_set_old(float * compressed_spec void BP2_set_old(float * compressed_spec_mat, unsigned char nb_bins_compressed_spec_mat); // void init_header_asm( Header_TM_LFR_SCIENCE_ASM_t *header); -void compress_averaged_spectral_matrix( float *averaged_spec_mat, unsigned char fChannel, float *compressed_spec_mat ); -void convert_averaged_spectral_matrix(volatile float *input_matrix, char *output_matrix); -void send_averaged_spectral_matrix(Header_TM_LFR_SCIENCE_ASM_t *header, char *spectral_matrix, +void ASM_reorganize( float *averaged_spec_mat, float *averaged_spec_mat_reorganized ); +void ASM_compress( float *averaged_spec_mat, unsigned char fChannel, float *compressed_spec_mat ); +void ASM_convert(volatile float *input_matrix, char *output_matrix); +void ASM_send(Header_TM_LFR_SCIENCE_ASM_t *header, char *spectral_matrix, unsigned int sid, spw_ioctl_pkt_send *spw_ioctl_send, rtems_id queue_id); void fill_averaged_spectral_matrix( void ); void reset_spectral_matrix_regs(); diff --git a/header/tc_handler.h b/header/tc_handler.h --- a/header/tc_handler.h +++ b/header/tc_handler.h @@ -39,6 +39,9 @@ int restart_science_tasks(); int suspend_science_tasks(); void launch_waveform_picker( unsigned char mode ); void launch_spectral_matrix( unsigned char mode ); +void enable_irq_on_new_ready_matrix( void ); +void disable_irq_on_new_ready_matrix( void ); +void launch_spectral_matrix_simu( unsigned char mode ); // other functions void updateLFRCurrentMode(); diff --git a/src/fsw_globals.c b/src/fsw_globals.c --- a/src/fsw_globals.c +++ b/src/fsw_globals.c @@ -46,9 +46,9 @@ volatile int wf_cont_f3_b [ (NB_SAMPL char wf_cont_f3_light[ (NB_SAMPLES_PER_SNAPSHOT) * NB_BYTES_CWF3_LIGHT_BLK + TIME_OFFSET_IN_BYTES ] __attribute__((aligned(0x100))); // SPECTRAL MATRICES GLOBAL VARIABLES -volatile int sm_f0[ NB_RING_NODES_ASM_F0 ][ SM_HEADER + TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); -volatile int sm_f1[ NB_RING_NODES_ASM_F1 ][ SM_HEADER + TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); -volatile int sm_f2[ NB_RING_NODES_ASM_F2 ][ SM_HEADER + TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); +volatile int sm_f0[ NB_RING_NODES_ASM_F0 ][ TIME_OFFSET + TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); +volatile int sm_f1[ NB_RING_NODES_ASM_F1 ][ TIME_OFFSET + TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); +volatile int sm_f2[ NB_RING_NODES_ASM_F2 ][ TIME_OFFSET + TOTAL_SIZE_SM ] __attribute__((aligned(0x100))); // APB CONFIGURATION REGISTERS time_management_regs_t *time_management_regs = (time_management_regs_t*) REGS_ADDR_TIME_MANAGEMENT; diff --git a/src/fsw_init.c b/src/fsw_init.c --- a/src/fsw_init.c +++ b/src/fsw_init.c @@ -179,6 +179,10 @@ rtems_task Init( rtems_task_argument ign status = rtems_interrupt_catch( waveforms_isr, IRQ_SPARC_WAVEFORM_PICKER, &old_isr_handler) ; + // configure IRQ handling for the spectral matrices unit + status = rtems_interrupt_catch( spectral_matrices_isr, + IRQ_SPARC_SPECTRAL_MATRIX, + &old_isr_handler) ; // if the spacewire link is not up then send an event to the SPIQ task for link recovery if ( status_spw != RTEMS_SUCCESSFUL ) diff --git a/src/fsw_misc.c b/src/fsw_misc.c --- a/src/fsw_misc.c +++ b/src/fsw_misc.c @@ -232,21 +232,23 @@ rtems_task dumb_task( rtems_task_argumen unsigned int fine_time = 0; rtems_event_set event_out; - char *DumbMessages[8] = {"in DUMB *** default", // RTEMS_EVENT_0 + char *DumbMessages[9] = {"in DUMB *** default", // RTEMS_EVENT_0 "in DUMB *** timecode_irq_handler", // RTEMS_EVENT_1 "in DUMB *** waveforms_isr", // RTEMS_EVENT_2 "in DUMB *** in SMIQ *** Error sending event to AVF0", // RTEMS_EVENT_3 "in DUMB *** spectral_matrices_isr *** Error sending event to SMIQ", // RTEMS_EVENT_4 "in DUMB *** waveforms_simulator_isr", // RTEMS_EVENT_5 "ERR HK", // RTEMS_EVENT_6 - "ready for dump" // RTEMS_EVENT_7 + "ready for dump", // RTEMS_EVENT_7 + "in DUMB *** spectral_matrices_isr" // RTEMS_EVENT_8 }; BOOT_PRINTF("in DUMB *** \n") while(1){ rtems_event_receive(RTEMS_EVENT_0 | RTEMS_EVENT_1 | RTEMS_EVENT_2 | RTEMS_EVENT_3 - | RTEMS_EVENT_4 | RTEMS_EVENT_5 | RTEMS_EVENT_6 | RTEMS_EVENT_7, + | RTEMS_EVENT_4 | RTEMS_EVENT_5 | RTEMS_EVENT_6 | RTEMS_EVENT_7 + | RTEMS_EVENT_8, RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT intEventOut = (unsigned int) event_out; for ( i=0; i<32; i++) @@ -256,7 +258,6 @@ rtems_task dumb_task( rtems_task_argumen coarse_time = time_management_regs->coarse_time; fine_time = time_management_regs->fine_time; printf("in DUMB *** coarse: %x, fine: %x, %s\n", coarse_time, fine_time, DumbMessages[i]); - PRINTF1("status = %x\n", waveform_picker_regs->status) } } } diff --git a/src/fsw_processing.c b/src/fsw_processing.c --- a/src/fsw_processing.c +++ b/src/fsw_processing.c @@ -22,9 +22,10 @@ ring_node *current_ring_node_sm_f1; ring_node *current_ring_node_sm_f2; BP1_t data_BP1[ NB_BINS_COMPRESSED_SM_F0 ]; -float averaged_sm_f0[ TOTAL_SIZE_SM ]; -char averaged_sm_f0_char[ TOTAL_SIZE_SM * 2 ]; -float compressed_sm_f0[ TOTAL_SIZE_COMPRESSED_ASM_F0 ]; +float averaged_sm_f0 [ TIME_OFFSET + TOTAL_SIZE_SM ]; +float averaged_sm_f0_reorganized[ TIME_OFFSET + TOTAL_SIZE_SM ]; +char averaged_sm_f0_char [ TIME_OFFSET_IN_BYTES + TOTAL_SIZE_SM * 2 ]; +float compressed_sm_f0 [ TOTAL_SIZE_COMPRESSED_ASM_F0 ]; unsigned int nb_sm_f0; @@ -69,54 +70,76 @@ void reset_nb_sm_f0( void ) rtems_isr spectral_matrices_isr( rtems_vector_number vector ) { -// unsigned char status; -// unsigned char i; + rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 ); + + if ( (spectral_matrix_regs->status & 0x1) == 0x01) + { + current_ring_node_sm_f0 = current_ring_node_sm_f0->next; + spectral_matrix_regs->matrixF0_Address0 = current_ring_node_sm_f0->buffer_address; + spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffffe; // 1110 + nb_sm_f0 = nb_sm_f0 + 1; + } + else if ( (spectral_matrix_regs->status & 0x2) == 0x02) + { + current_ring_node_sm_f0 = current_ring_node_sm_f0->next; + spectral_matrix_regs->matrixFO_Address1 = current_ring_node_sm_f0->buffer_address; + spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffffd; // 1101 + nb_sm_f0 = nb_sm_f0 + 1; + } -// status = spectral_matrix_regs->status; //[f2 f1 f0_1 f0_0] -// for (i=0; i<4; i++) -// { -// if ( ( (status >> i) & 0x01) == 1) // (1) buffer rotation -// { -// switch(i) -// { -// case 0: -// current_ring_node_sm_f0 = current_ring_node_sm_f0->next; -// spectral_matrix_regs->matrixF0_Address0 = current_ring_node_sm_f0->buffer_address; -// spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffffe; -// nb_interrupt_f0 = nb_interrupt_f0 + 1; -// if (nb_interrupt_f0 == NB_SM_TO_RECEIVE_BEFORE_AVF0 ){ -// ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0; -// if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) -// { -// rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 ); -// } -// nb_interrupt_f0 = 0; -// } -// break; -// case 1: -// break; -// case 2: -// break; -// default: -// break; -// } -// } -// } + if ( (spectral_matrix_regs->status & 0x30) != 0x00) + { + rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 ); + spectral_matrix_regs->status = spectral_matrix_regs->status & 0xffffffcf; // 1100 1111 + } + + spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffff3; // 0011 -// // reset error codes to 0 -// spectral_matrix_regs->status = spectral_matrix_regs->status & 0xffffffcf; // [1100 1111] + if (nb_sm_f0 == (NB_SM_TO_RECEIVE_BEFORE_AVF0-1) ) + { + ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0; + if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) + { + rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 ); + } + nb_sm_f0 = 0; + } + else + { + nb_sm_f0 = nb_sm_f0 + 1; + } } rtems_isr spectral_matrices_isr_simu( rtems_vector_number vector ) { - current_ring_node_sm_f0 = current_ring_node_sm_f0->next; - spectral_matrix_regs->matrixF0_Address0 = current_ring_node_sm_f0->buffer_address; - spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffffe; + rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 ); + + if ( (spectral_matrix_regs->status & 0x1) == 0x01) + { + current_ring_node_sm_f0 = current_ring_node_sm_f0->next; + spectral_matrix_regs->matrixF0_Address0 = current_ring_node_sm_f0->buffer_address; + spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffffe; // 1110 + nb_sm_f0 = nb_sm_f0 + 1; + } + else if ( (spectral_matrix_regs->status & 0x2) == 0x02) + { + current_ring_node_sm_f0 = current_ring_node_sm_f0->next; + spectral_matrix_regs->matrixFO_Address1 = current_ring_node_sm_f0->buffer_address; + spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffffd; // 1101 + nb_sm_f0 = nb_sm_f0 + 1; + } + + if ( (spectral_matrix_regs->status & 0x30) != 0x00) + { + rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 ); + spectral_matrix_regs->status = spectral_matrix_regs->status & 0xffffffcf; // 1100 1111 + } + + spectral_matrix_regs->status = spectral_matrix_regs->status & 0xfffffff3; // 0011 if (nb_sm_f0 == (NB_SM_TO_RECEIVE_BEFORE_AVF0-1) ) { -// ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0; - ring_node_for_averaging_sm_f0 = &sm_ring_f0[NB_SM_TO_RECEIVE_BEFORE_AVF0-1]; + ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0; if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) { rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 ); @@ -165,15 +188,16 @@ rtems_task avf0_task(rtems_task_argument } for(i=0; ibuffer_address) ) [i] - + ( (int *) (ring_node_tab[1]->buffer_address) ) [i] - + ( (int *) (ring_node_tab[2]->buffer_address) ) [i] - + ( (int *) (ring_node_tab[3]->buffer_address) ) [i] - + ( (int *) (ring_node_tab[4]->buffer_address) ) [i] - + ( (int *) (ring_node_tab[5]->buffer_address) ) [i] - + ( (int *) (ring_node_tab[6]->buffer_address) ) [i] - + ( (int *) (ring_node_tab[7]->buffer_address) ) [i]; + averaged_sm_f0[i] = ( (int *) (ring_node_tab[0]->buffer_address) ) [i + TIME_OFFSET] + + ( (int *) (ring_node_tab[1]->buffer_address) ) [i + TIME_OFFSET] + + ( (int *) (ring_node_tab[2]->buffer_address) ) [i + TIME_OFFSET] + + ( (int *) (ring_node_tab[3]->buffer_address) ) [i + TIME_OFFSET] + + ( (int *) (ring_node_tab[4]->buffer_address) ) [i + TIME_OFFSET] + + ( (int *) (ring_node_tab[5]->buffer_address) ) [i + TIME_OFFSET] + + ( (int *) (ring_node_tab[6]->buffer_address) ) [i + TIME_OFFSET] + + ( (int *) (ring_node_tab[7]->buffer_address) ) [i + TIME_OFFSET]; } + nb_average = nb_average + NB_SM_TO_RECEIVE_BEFORE_AVF0; if (nb_average == NB_AVERAGE_NORMAL_f0) { nb_average = 0; @@ -208,13 +232,14 @@ rtems_task matr_task(rtems_task_argument while(1){ rtems_event_receive(RTEMS_EVENT_0, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT0 // 1) compress the matrix for Basic Parameters calculation - compress_averaged_spectral_matrix( averaged_sm_f0, 0, compressed_sm_f0 ); + ASM_compress( averaged_sm_f0, 0, compressed_sm_f0 ); // 2) //BP1_set(compressed_sm_f0, NB_BINS_COMPRESSED_SM_F0, LFR_BP1_F0); // 3) convert the float array in a char array - convert_averaged_spectral_matrix( averaged_sm_f0, averaged_sm_f0_char); + ASM_reorganize( averaged_sm_f0, averaged_sm_f0_reorganized ); + ASM_convert( averaged_sm_f0_reorganized, averaged_sm_f0_char); // 4) send the spectral matrix packets - send_averaged_spectral_matrix( &headerASM, averaged_sm_f0_char, SID_NORM_ASM_F0, &spw_ioctl_send_ASM, queue_id); + ASM_send( &headerASM, averaged_sm_f0_char, SID_NORM_ASM_F0, &spw_ioctl_send_ASM, queue_id); } } @@ -229,33 +254,51 @@ void matrix_reset(volatile float *averag } } -void compress_averaged_spectral_matrix( float *averaged_spec_mat, unsigned char fChannel, float *compressed_spec_mat ) +void ASM_reorganize( float *averaged_spec_mat, float *averaged_spec_mat_reorganized ) +{ + int frequencyBin; + int asmComponent; + + // copy the time information + averaged_spec_mat_reorganized[ 0 ] = averaged_spec_mat[ 0 ]; + averaged_spec_mat_reorganized[ 1 ] = averaged_spec_mat[ 1 ]; + + for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++) + { + for( frequencyBin = 0; frequencyBin < NB_BINS_PER_SM; frequencyBin++ ) + { + averaged_spec_mat_reorganized[ frequencyBin * NB_VALUES_PER_SM + asmComponent + TIME_OFFSET ] = + averaged_spec_mat[ asmComponent * NB_BINS_PER_SM + frequencyBin + TIME_OFFSET]; + } + } +} + +void ASM_compress( float *averaged_spec_mat, unsigned char fChannel, float *compressed_spec_mat ) { int frequencyBin; int asmComponent; int offsetASM; - int generalOffsetASM; int offsetCompressed; int k; switch (fChannel){ case 0: - generalOffsetASM = ASM_F0_INDICE_START * NB_VALUES_PER_SM; - for( frequencyBin = 0; frequencyBin < NB_BINS_COMPRESSED_SM_F0; frequencyBin++ ) + for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++) { - offsetCompressed = frequencyBin * NB_VALUES_PER_SM; - offsetASM = generalOffsetASM + frequencyBin * NB_BINS_TO_AVERAGE_ASM_F0 * NB_VALUES_PER_SM; - for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++) + for( frequencyBin = 0; frequencyBin < NB_BINS_COMPRESSED_SM_F0; frequencyBin++ ) { - compressed_spec_mat[ offsetCompressed + asmComponent ] = 0; + offsetASM = asmComponent * NB_BINS_PER_SM + + ASM_F0_INDICE_START + + frequencyBin * NB_BINS_TO_AVERAGE_ASM_F0; + offsetCompressed = frequencyBin * NB_VALUES_PER_SM + + asmComponent; + compressed_spec_mat[ offsetCompressed ] = 0; for ( k = 0; k < NB_BINS_TO_AVERAGE_ASM_F0; k++ ) { - compressed_spec_mat[ offsetCompressed + asmComponent ] = - compressed_spec_mat[ offsetCompressed + asmComponent ] - + averaged_spec_mat[ offsetASM + (k*NB_VALUES_PER_SM) + asmComponent ]; + compressed_spec_mat[offsetCompressed ] = + compressed_spec_mat[ offsetCompressed ] + + averaged_spec_mat[ offsetASM + k ]; } - compressed_spec_mat[ offsetCompressed + asmComponent ] = - compressed_spec_mat[ offsetCompressed + asmComponent ] / NB_BINS_TO_AVERAGE_ASM_F0; } } break; @@ -273,29 +316,37 @@ void compress_averaged_spectral_matrix( } } -void convert_averaged_spectral_matrix( volatile float *input_matrix, char *output_matrix) +void ASM_convert( volatile float *input_matrix, char *output_matrix) { unsigned int i; - unsigned int j; + unsigned int frequencyBin; + unsigned int asmComponent; char * pt_char_input; char * pt_char_output; - pt_char_input = NULL; - pt_char_output = NULL; + pt_char_input = (char*) &input_matrix; + pt_char_output = (char*) &output_matrix; - for( i=0; idlen = TOTAL_SIZE_ASM_F0_IN_BYTES / 2; - spw_ioctl_send->data = &spectral_matrix[ ( (ASM_F0_INDICE_START+ (i*NB_BINS_PER_PKT_ASM_F0)) * NB_VALUES_PER_SM) * 2 ]; + spw_ioctl_send->data = &spectral_matrix[ + ( (ASM_F0_INDICE_START + (i*NB_BINS_PER_PKT_ASM_F0) ) * NB_VALUES_PER_SM ) * 2 + + TIME_OFFSET_IN_BYTES + ]; length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F0; header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F0) >> 8 ); // BLK_NR MSB header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F0); // BLK_NR LSB @@ -319,7 +373,7 @@ void send_averaged_spectral_matrix(Heade case SID_NORM_ASM_F2: break; default: - PRINTF1("ERR *** in send_averaged_spectral_matrix *** unexpected sid %d\n", sid) + PRINTF1("ERR *** in ASM_send *** unexpected sid %d\n", sid) break; } spw_ioctl_send->hlen = HEADER_LENGTH_TM_LFR_SCIENCE_ASM + CCSDS_PROTOCOLE_EXTRA_BYTES; @@ -351,7 +405,7 @@ void send_averaged_spectral_matrix(Heade // (4) SEND PACKET status = rtems_message_queue_send( queue_id, spw_ioctl_send, ACTION_MSG_SPW_IOCTL_SEND_SIZE); if (status != RTEMS_SUCCESSFUL) { - printf("in send_averaged_spectral_matrix *** ERR %d\n", (int) status); + printf("in ASM_send *** ERR %d\n", (int) status); } } } @@ -665,6 +719,9 @@ void reset_spectral_matrix_regs() * */ + spectral_matrix_regs->config = 0x00; + spectral_matrix_regs->status = 0x00; + spectral_matrix_regs->matrixF0_Address0 = current_ring_node_sm_f0->buffer_address; spectral_matrix_regs->matrixFO_Address1 = current_ring_node_sm_f0->buffer_address; spectral_matrix_regs->matrixF1_Address = current_ring_node_sm_f1->buffer_address; diff --git a/src/tc_handler.c b/src/tc_handler.c --- a/src/tc_handler.c +++ b/src/tc_handler.c @@ -388,15 +388,16 @@ int stop_current_mode(void) // (1) mask interruptions LEON_Mask_interrupt( IRQ_WAVEFORM_PICKER ); // mask waveform picker interrupt - //LEON_Mask_interrupt( IRQ_SPECTRAL_MATRIX ); // clear spectral matrix interrupt + LEON_Mask_interrupt( IRQ_SPECTRAL_MATRIX ); // clear spectral matrix interrupt // (2) clear interruptions LEON_Clear_interrupt( IRQ_WAVEFORM_PICKER ); // clear waveform picker interrupt - //LEON_Clear_interrupt( IRQ_SPECTRAL_MATRIX ); // clear spectral matrix interrupt + LEON_Clear_interrupt( IRQ_SPECTRAL_MATRIX ); // clear spectral matrix interrupt // (3) reset registers reset_wfp_burst_enable(); // reset burst and enable bits reset_wfp_status(); // reset all the status bits + disable_irq_on_new_ready_matrix(); // stop the spectral matrices // LEON_Mask_interrupt( IRQ_SM_SIMULATOR ); // mask spectral matrix interrupt simulator @@ -445,7 +446,7 @@ int enter_mode(unsigned char mode ) #endif status = restart_science_tasks(); launch_waveform_picker( mode ); - //launch_spectral_matrix( mode ); + launch_spectral_matrix( mode ); } else if ( mode == LFR_MODE_STANDBY ) { @@ -609,6 +610,29 @@ void launch_spectral_matrix( unsigned ch reset_current_sm_ring_nodes(); reset_spectral_matrix_regs(); + enable_irq_on_new_ready_matrix(); + + LEON_Clear_interrupt( IRQ_SPECTRAL_MATRIX ); + LEON_Unmask_interrupt( IRQ_SPECTRAL_MATRIX ); +} + +void enable_irq_on_new_ready_matrix( void ) +{ + spectral_matrix_regs->config = spectral_matrix_regs->config | 0x01; +} + +void disable_irq_on_new_ready_matrix( void ) +{ + spectral_matrix_regs->config = spectral_matrix_regs->config & 0xfffffffe; // 1110 +} + + +void launch_spectral_matrix_simu( unsigned char mode ) +{ + reset_nb_sm_f0(); + reset_current_sm_ring_nodes(); + reset_spectral_matrix_regs(); + // Spectral Matrices simulator timer_start( (gptimer_regs_t*) REGS_ADDR_GPTIMER, TIMER_SM_SIMULATOR ); LEON_Clear_interrupt( IRQ_SM_SIMULATOR );