HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/LFR_FSW Commit - r182:4c7c1d90c7d1

sync

paul -

r182:4c7c1d90c7d1 VHDL_0_1_28

parent child

Context file:

r182:4c7c1d90c7d1

Collapse all files

.hgsubstate +2 -2

@@ -1,2 +1,2
1	a0aa2c6f13574ae69c8645af2a2afa5d448e6c76 LFR_basic-parameters	1	0f2eb26d750be2b6d8a3f5dee479b4575d3b93be LFR_basic-parameters
2	a8668a35669295aaba22432d247158626f00a52a header/lfr_common_headers	2	95a8d83f1d0c59f28a679e66e23464f21c12dd8a header/lfr_common_headers

header/fsw_misc.h +2 -1

             void getTime( unsigned char *time);
             unsigned long long int getTimeAsUnsignedLongLongInt( );
             void send_dumb_hk( void );
-            void get_v_e1_e2_f3(unsigned char *spacecraft_potential);
+            void get_v_e1_e2_f3( unsigned char *spacecraft_potential );
+            void get_temperatures( unsigned char *temperatures );
             void get_cpu_load( unsigned char *resource_statistics );
             extern int sched_yield( void );

header/grlib_regs.h +3 0

                 volatile int coarse_time_load;
                 volatile int coarse_time;
                 volatile int fine_time;
+                volatile int temp_scm;
+                volatile int temp_pcb;
+                volatile int temp_fpga;
             } time_management_regs_t;
             // PDB >= 0.1.28

header/processing/fsw_processing.h +4 0

             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 );
+            void ASM_patch( float *inputASM, float *outputASM );
+            void extractReImVectors(float *inputASM, float *outputASM, unsigned int asmComponent );
             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,

src/fsw_init.c +3 -3

                 {
                     status = rtems_task_create(
                         Task_name[TASKID_PRC0], TASK_PRIORITY_PRC0, RTEMS_MINIMUM_STACK_SIZE * 2,
-                        RTEMS_DEFAULT_MODES,
+                        RTEMS_DEFAULT_MODES | RTEMS_NO_PREEMPT,
                         RTEMS_DEFAULT_ATTRIBUTES | RTEMS_FLOATING_POINT, &Task_id[TASKID_PRC0]
                     );
                 }
                 {
                     status = rtems_task_create(
                         Task_name[TASKID_PRC1], TASK_PRIORITY_PRC1, RTEMS_MINIMUM_STACK_SIZE * 2,
-                        RTEMS_DEFAULT_MODES,
+                        RTEMS_DEFAULT_MODES | RTEMS_NO_PREEMPT,
                         RTEMS_DEFAULT_ATTRIBUTES | RTEMS_FLOATING_POINT, &Task_id[TASKID_PRC1]
                     );
                 }
                 {
                     status = rtems_task_create(
                         Task_name[TASKID_PRC2], TASK_PRIORITY_PRC2, RTEMS_MINIMUM_STACK_SIZE * 2,
-                        RTEMS_DEFAULT_MODES,
+                        RTEMS_DEFAULT_MODES | RTEMS_NO_PREEMPT,
                         RTEMS_DEFAULT_ATTRIBUTES | RTEMS_FLOATING_POINT, &Task_id[TASKID_PRC2]
                     );
                 }

src/fsw_misc.c +19 0

@@ -226,6 +226,7 rtems_task hous_task(rtems_task_argument
226	spacewire_update_statistics();	226	spacewire_update_statistics();
227		227
228	get_v_e1_e2_f3( housekeeping_packet.hk_lfr_sc_v_f3 );	228	get_v_e1_e2_f3( housekeeping_packet.hk_lfr_sc_v_f3 );
		229	get_temperatures( housekeeping_packet.hk_lfr_temp_scm);
229	get_cpu_load( (unsigned char *) &housekeeping_packet.hk_lfr_cpu_load );	230	get_cpu_load( (unsigned char *) &housekeeping_packet.hk_lfr_cpu_load );
230		231
231	// SEND PACKET	232	// SEND PACKET
@@ -459,6 +460,24 void get_v_e1_e2_f3( unsigned char *spac
459	spacecraft_potential[5] = e2_ptr[3];	460	spacecraft_potential[5] = e2_ptr[3];
460	}	461	}
461		462
		463	void get_temperatures( unsigned char *temperatures )
		464	{
		465	unsigned char* temp_scm_ptr;
		466	unsigned char* temp_pcb_ptr;
		467	unsigned char* temp_fpga_ptr;
		468
		469	temp_scm_ptr = (unsigned char *) &time_management_regs->temp_scm;
		470	temp_pcb_ptr = (unsigned char *) &time_management_regs->temp_pcb;
		471	temp_fpga_ptr = (unsigned char *) &time_management_regs->temp_fpga;
		472
		473	temperatures[0] = temp_scm_ptr[2];
		474	temperatures[1] = temp_scm_ptr[3];
		475	temperatures[2] = temp_pcb_ptr[2];
		476	temperatures[3] = temp_pcb_ptr[3];
		477	temperatures[4] = temp_fpga_ptr[2];
		478	temperatures[5] = temp_fpga_ptr[3];
		479	}
		480
462	void get_cpu_load( unsigned char *resource_statistics )	481	void get_cpu_load( unsigned char *resource_statistics )
463	{	482	{
464	unsigned char cpu_load;	483	unsigned char cpu_load;

src/processing/avf0_prc0.c +12 -6

             ring_node ring_to_send_asm_f0       [ NB_RING_NODES_ASM_F0 ];
             int buffer_asm_f0                   [ NB_RING_NODES_ASM_F0 * TOTAL_SIZE_SM ];
-            float asm_f0_reorganized   [ TOTAL_SIZE_SM ];
+            float asm_f0_patched_norm       [ TOTAL_SIZE_SM ];
+            float asm_f0_patched_burst_sbm  [ TOTAL_SIZE_SM ];
+            float asm_f0_reorganized        [ TOTAL_SIZE_SM ];
             char  asm_f0_char          [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ];
             float compressed_sm_norm_f0[ TOTAL_SIZE_COMPRESSED_ASM_NORM_F0];
             float compressed_sm_sbm_f0 [ TOTAL_SIZE_COMPRESSED_ASM_SBM_F0 ];
                     incomingMsg = (asm_msg*) incomingData;
+                    ASM_patch( incomingMsg->norm->matrix,      asm_f0_patched_norm      );
+                    ASM_patch( incomingMsg->burst_sbm->matrix, asm_f0_patched_burst_sbm );
                     //****************
                     //****************
                     // BURST SBM1 SBM2
                     {
                         sid = getSID( incomingMsg->event );
                         // 1)  compress the matrix for Basic Parameters calculation
-                        ASM_compress_reorganize_and_divide( incomingMsg->burst_sbm->matrix, compressed_sm_sbm_f0,
+                        ASM_compress_reorganize_and_divide( asm_f0_patched_burst_sbm, compressed_sm_sbm_f0,
                                                      nb_sm_before_f0.burst_sbm_bp1,
                                                      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_sbm_f0, k_coeff_intercalib_f0_sbm, NB_BINS_COMPRESSED_SM_SBM_F0, packet_sbm_bp1.data );
+            //            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.time,            (unsigned char *) &incomingMsg->coarseTimeSBM );
                         set_time( packet_sbm_bp1.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeSBM );
                     if (incomingMsg->event & RTEMS_EVENT_NORM_BP1_F0)
                     {
                         // 1)  compress the matrix for Basic Parameters calculation
-                        ASM_compress_reorganize_and_divide( incomingMsg->norm->matrix, compressed_sm_norm_f0,
+                        ASM_compress_reorganize_and_divide( asm_f0_patched_norm, compressed_sm_norm_f0,
                                                      nb_sm_before_f0.norm_bp1,
                                                      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, k_coeff_intercalib_f0_norm, NB_BINS_COMPRESSED_SM_F0, packet_norm_bp1.data );
+            //            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.time,            (unsigned char *) &incomingMsg->coarseTimeNORM );
                         set_time( packet_norm_bp1.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM );
                     if (incomingMsg->event & RTEMS_EVENT_NORM_ASM_F0)
                     {
                         // 1) reorganize the ASM and divide
-                        ASM_reorganize_and_divide( incomingMsg->norm->matrix,
+                        ASM_reorganize_and_divide( asm_f0_patched_norm,
                                                    asm_f0_reorganized,
                                                    nb_sm_before_f0.norm_bp1 );
                         // 2) convert the float array in a char array

src/processing/avf1_prc1.c +2 -2

             int buffer_asm_f1                   [ NB_RING_NODES_ASM_F1 * TOTAL_SIZE_SM ];
             float asm_f1_reorganized   [ TOTAL_SIZE_SM ];
-            char  asm_f1_char          [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ];
+            char  asm_f1_char          [ TOTAL_SIZE_SM * 2 ];
             float compressed_sm_norm_f1[ TOTAL_SIZE_COMPRESSED_ASM_NORM_F1];
             float compressed_sm_sbm_f1 [ TOTAL_SIZE_COMPRESSED_ASM_SBM_F1 ];
                                                      NB_BINS_COMPRESSED_SM_F1, NB_BINS_TO_AVERAGE_ASM_F1,
                                                      ASM_F1_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 );
+            //            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.time,            (unsigned char *) &incomingMsg->coarseTimeNORM );
                         set_time( packet_norm_bp1.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM   );

src/processing/avf2_prc2.c +22 -20

                 while(1){
                     status = rtems_message_queue_receive( queue_id_q_p2, incomingData, &size, //************************************
-                                                         RTEMS_WAIT, RTEMS_NO_TIMEOUT );      // wait for a message coming from AVF0
+                                                         RTEMS_WAIT, RTEMS_NO_TIMEOUT );      // wait for a message coming from AVF2
                     incomingMsg = (asm_msg*) incomingData;
                     // NORM
                     //*****
                     //*****
+                    // 1)  compress the matrix for Basic Parameters calculation
+                    ASM_compress_reorganize_and_divide( incomingMsg->norm->matrix, compressed_sm_norm_f2,
+                                                 nb_sm_before_f2.norm_bp1,
+                                                 NB_BINS_COMPRESSED_SM_F2, NB_BINS_TO_AVERAGE_ASM_F2,
+                                                 ASM_F2_INDICE_START );
+                    // BP1_F2
                     if (incomingMsg->event & RTEMS_EVENT_NORM_BP1_F2)
                     {
-                        // 1)  compress the matrix for Basic Parameters calculation
+                        // 1) compute the BP1 set
-                        ASM_compress_reorganize_and_divide( incomingMsg->norm->matrix, compressed_sm_norm_f2,
+            //            BP1_set( compressed_sm_norm_f2, k_coeff_intercalib_f2, NB_BINS_COMPRESSED_SM_F2, packet_norm_bp1.data );
-                                                     nb_sm_before_f2.norm_bp1,
+                        // 2) send the BP1 set
-                                                     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.time,            (unsigned char *) &incomingMsg->coarseTimeNORM );
                         set_time( packet_norm_bp1.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM );
                         BP_send( (char *) &packet_norm_bp1, queue_id_send,
                                  PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F2 + PACKET_LENGTH_DELTA,
                                  SID_NORM_BP1_F2 );
-                        if (incomingMsg->event & RTEMS_EVENT_NORM_BP2_F2)
+                    // BP2_F2
-                            // 1) compute the BP2 set using the same ASM as the one used for BP1
+                    if (incomingMsg->event & RTEMS_EVENT_NORM_BP2_F2)
-                            BP2_set( compressed_sm_norm_f2, NB_BINS_COMPRESSED_SM_F2, packet_norm_bp2.data );
-                            // 2) send the BP2 set
+                        // 1) compute the BP2 set
-                            set_time( packet_norm_bp2.time,            (unsigned char *) &incomingMsg->coarseTimeNORM );
+                        BP2_set( compressed_sm_norm_f2, NB_BINS_COMPRESSED_SM_F2, packet_norm_bp2.data );
-                            set_time( packet_norm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM );
+                        // 2) send the BP2 set
-                            BP_send( (char *) &packet_norm_bp2, queue_id_send,
+                        set_time( packet_norm_bp2.time,            (unsigned char *) &incomingMsg->coarseTimeNORM );
-                                     PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F2 + PACKET_LENGTH_DELTA,
+                        set_time( packet_norm_bp2.acquisitionTime, (unsigned char *) &incomingMsg->coarseTimeNORM );
-                                     SID_NORM_BP2_F2 );
+                        BP_send( (char *) &packet_norm_bp2, queue_id_send,
+                                 PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F2 + PACKET_LENGTH_DELTA,
+                                 SID_NORM_BP2_F2 );
                     }
                     if (incomingMsg->event & RTEMS_EVENT_NORM_ASM_F2)

src/processing/fsw_processing.c +60 -12

             //***********************************************************
             // Interrupt Service Routine for spectral matrices processing
-            void spectral_matrices_isr_f0( void )
+            void spectral_matrices_isr_f0( unsigned char statusReg )
             {
                 unsigned char status;
                 rtems_status_code status_code;
                 ring_node *full_ring_node;
-                status = spectral_matrix_regs->status & 0x03;   // [0011] get the status_ready_matrix_f0_x bits
+                status = statusReg & 0x03;   // [0011] get the status_ready_matrix_f0_x bits
                 switch(status)
                 {
                 }
             }
-            void spectral_matrices_isr_f1( void )
+            void spectral_matrices_isr_f1( unsigned char statusReg )
             {
                 rtems_status_code status_code;
                 unsigned char status;
                 ring_node *full_ring_node;
-                status = (spectral_matrix_regs->status & 0x0c) >> 2;   // [1100] get the status_ready_matrix_f0_x bits
+                status = (statusReg & 0x0c) >> 2;   // [1100] get the status_ready_matrix_f0_x bits
                 switch(status)
                 {
                 }
             }
-            void spectral_matrices_isr_f2( void )
+            void spectral_matrices_isr_f2( unsigned char statusReg )
             {
                 unsigned char status;
                 rtems_status_code status_code;
-                status = (spectral_matrix_regs->status & 0x30) >> 4;   // [0011 0000] get the status_ready_matrix_f0_x bits
+                status = (statusReg & 0x30) >> 4;   // [0011 0000] get the status_ready_matrix_f0_x bits
                 switch(status)
                 {
                 }
             }
-            void spectral_matrix_isr_error_handler( void )
+            void spectral_matrix_isr_error_handler( unsigned char statusReg )
             {
                 rtems_status_code status_code;
-                if (spectral_matrix_regs->status & 0x7c0)    // [0111 1100 0000]
+                if (statusReg & 0x7c0)    // [0111 1100 0000]
                 {
                     status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 );
                 }
                 // buffer_full ** bad_component_err ** f2_1 ** f2_0 ** f1_1 ** f1_0 ** f0_1 ** f0_0
                 //      7                  6             5       4       3       2       1       0
-                spectral_matrices_isr_f0();
+                unsigned char statusReg;
-                spectral_matrices_isr_f1();
+                statusReg = spectral_matrix_regs->status;
+                spectral_matrices_isr_f0( statusReg );
-                spectral_matrices_isr_f2();
+                spectral_matrices_isr_f1( statusReg );
-                spectral_matrix_isr_error_handler();
+                spectral_matrices_isr_f2( statusReg );
+                spectral_matrix_isr_error_handler( statusReg );
             }
             rtems_isr spectral_matrices_isr_simu( rtems_vector_number vector )
                 return sid;
             }
+            void extractReImVectors( float *inputASM, float *outputASM, unsigned int asmComponent )
+            {
+                unsigned int i;
+                float re;
+                float im;
+                for (i=0; i<NB_BINS_PER_SM; i++){
+                    re = inputASM[ (asmComponent*NB_BINS_PER_SM) + i * 2    ];
+                    im = inputASM[ (asmComponent*NB_BINS_PER_SM) + i * 2 + 1];
+                    outputASM[ (asmComponent   *NB_BINS_PER_SM)  +  i] = re;
+                    outputASM[ (asmComponent+1)*NB_BINS_PER_SM   +  i] = im;
+                }
+            }
+            void copyReVectors( float *inputASM, float *outputASM, unsigned int asmComponent )
+            {
+                unsigned int i;
+                float re;
+                for (i=0; i<NB_BINS_PER_SM; i++){
+                    re = inputASM[ (asmComponent*NB_BINS_PER_SM) + i];
+                    outputASM[ (asmComponent*NB_BINS_PER_SM)  +  i] = re;
+                }
+            }
+            void ASM_patch( float *inputASM, float *outputASM )
+            {
+                extractReImVectors( inputASM, outputASM, 1);    // b1b2
+                extractReImVectors( inputASM, outputASM, 3 );   // b1b3
+                extractReImVectors( inputASM, outputASM, 5 );   // b1e1
+                extractReImVectors( inputASM, outputASM, 7 );   // b1e2
+                extractReImVectors( inputASM, outputASM, 10 );  // b2b3
+                extractReImVectors( inputASM, outputASM, 12 );  // b2e1
+                extractReImVectors( inputASM, outputASM, 14 );  // b2e2
+                extractReImVectors( inputASM, outputASM, 17 );  // b3e1
+                extractReImVectors( inputASM, outputASM, 19 );  // b3e2
+                extractReImVectors( inputASM, outputASM, 22 );  // e1e2
+                copyReVectors(inputASM, outputASM, 0 );    // b1b1
+                copyReVectors(inputASM, outputASM, 9 );    // b2b2
+                copyReVectors(inputASM, outputASM, 16);    // b3b3
+                copyReVectors(inputASM, outputASM, 21);    // e1e1
+                copyReVectors(inputASM, outputASM, 24);    // e2e2
+            }

testbenches/fsw_matrices_handling/functions.h +29 0

@@ -63,3 +63,32 void ASM_compress_reorganize_and_divide(
63	}	63	}
64	}	64	}
65	}	65	}
		66
		67	void extractReImVectors( float inputASM, float outputASM, unsigned int asmComponent )
		68	{
		69	unsigned int i;
		70	float re;
		71	float im;
		72
		73	for (i=0; i<NB_BINS_PER_SM; i++){
		74	re = inputASM[ (asmComponentNB_BINS_PER_SM) + i 2 ];
		75	im = inputASM[ (asmComponentNB_BINS_PER_SM) + i 2 + 1];
		76	outputASM[ (asmComponent *NB_BINS_PER_SM) + i] = re;
		77	outputASM[ (asmComponent+1)*NB_BINS_PER_SM + i] = im;
		78	}
		79
		80	}
		81
		82	void ASM_patch( float inputASM, float outputASM )
		83	{
		84	extractReImVectors( inputASM, outputASM, 1); // b1b2
		85	extractReImVectors( inputASM, outputASM, 3 ); // b1b3
		86	extractReImVectors( inputASM, outputASM, 5 ); // b1e1
		87	extractReImVectors( inputASM, outputASM, 7 ); // b1e2
		88	extractReImVectors( inputASM, outputASM, 10 ); // b2b3
		89	extractReImVectors( inputASM, outputASM, 12 ); // b2e1
		90	extractReImVectors( inputASM, outputASM, 14 ); // b2e2
		91	extractReImVectors( inputASM, outputASM, 17 ); // b3e1
		92	extractReImVectors( inputASM, outputASM, 19 ); // b3e2
		93	extractReImVectors( inputASM, outputASM, 22 ); // e1e2
		94	}

testbenches/fsw_matrices_handling/main.c +5 0

                 float input_ASM             [ NB_VALUES_PER_SM * NB_BINS_PER_SM           ];
                 float output_ASM            [ NB_VALUES_PER_SM * NB_BINS_PER_SM           ];
+                float patched_ASM           [ NB_VALUES_PER_SM * NB_BINS_PER_SM           ];
                 float output_ASM_compressed [ NB_VALUES_PER_SM * NB_BINS_COMPRESSED_SM_F0 ];
                 //*******
                     }
                 }
+                ASM_patch( input_ASM, patched_ASM );
                 ASM_reorganize_and_divide( input_ASM, output_ASM,
 ); // divider
                                                     NB_BINS_TO_AVERAGE_ASM_F0,
                                                     ASM_F0_INDICE_START);
+                ASM_patch( input_ASM, patched_ASM );
                 return 0;
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages